mcs/class/System.Web/Test/System.Web.UI.WebControls/ObjectDataSourceViewTest.cs

   1 //
   2 // Tests for System.Web.UI.WebControls.ObjectDataSourceView
   3 //
   4 // Author:
   5 //      Chris Toshok (toshok@novell.com)
   6 //      Konstantin Triger (kostat@mainsoft.com)
   7 //      Yoni Klain (yonik@mainsoft.com)
   8 //
   9
  10 //
  11 // Copyright (C) 2006 Novell, Inc (http://www.novell.com)
  12 //
  13 // Permission is hereby granted, free of charge, to any person obtaining
  14 // a copy of this software and associated documentation files (the
  15 // "Software"), to deal in the Software without restriction, including
  16 // without limitation the rights to use, copy, modify, merge, publish,
  17 // distribute, sublicense, and/or sell copies of the Software, and to
  18 // permit persons to whom the Software is furnished to do so, subject to
  19 // the following conditions:
  20 //
  21 // The above copyright notice and this permission notice shall be
  22 // included in all copies or substantial portions of the Software.
  23 //
  24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  28 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  29 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  30 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  31 //
  32 // WARNING NOTES  : ALL NUNITWEB TESTS DOING UNLOAD BETWEEN TESTS FOR RELOAD
  33 // OBJECT DATA SOURCE DEFAULT DATA
  34
  35
  36
  37 using NUnit.Framework;
  38 using System;
  39 using Sys = System;
  40 using System.Configuration;
  41 using System.Data.Common;
  42 using System.IO;
  43 using System.Globalization;
  44 using System.Web;
  45 using System.Web.UI;
  46 using System.Web.UI.WebControls;
  47 using System.Data;
  48 using System.Collections;
  49 using MonoTests.SystemWeb.Framework;
  50 using MonoTests.stand_alone.WebHarness;
  51 using System.Threading;
  52
  53 namespace MonoTests.System.Web.UI.WebControls
  54 {
  55         class ObjectViewPoker : ObjectDataSourceView
  56         {
  57                 public ObjectViewPoker (ObjectDataSource ds, string name, HttpContext context)
  58                         : base (ds, name, context)
  59                 {
  60                         TrackViewState ();
  61                 }
  62
  63                 public bool GetIsTrackingViewState ()
  64                 {
  65                         return base.IsTrackingViewState;
  66                 }
  67
  68                 public object SaveToViewState ()
  69                 {
  70                         return SaveViewState ();
  71                 }
  72
  73                 public void LoadFromViewState (object savedState)
  74                 {
  75                         LoadViewState (savedState);
  76                 }
  77
  78                 public void DoOnDeleting (ObjectDataSourceMethodEventArgs e)
  79                 {
  80                         base.OnDeleting (e);
  81                 }
  82
  83                 public void DoOnInserting (ObjectDataSourceMethodEventArgs e)
  84                 {
  85                         base.OnInserting (e);
  86                 }
  87
  88                 public void DoOnFiltering (ObjectDataSourceFilteringEventArgs e)
  89                 {
  90                         base.OnFiltering (e);
  91                 }
  92
  93                 public void DoOnObjectCreating (ObjectDataSourceEventArgs e)
  94                 {
  95                         base.OnObjectCreating (e);
  96                 }
  97
  98                 public void DoOnObjectCreated (ObjectDataSourceEventArgs e)
  99                 {
 100                         base.OnObjectCreated (e);
 101                 }
 102
 103                 public void DoOnObjectDisposing (ObjectDataSourceDisposingEventArgs e)
 104                 {
 105                         base.OnObjectDisposing (e);
 106                 }
 107
 108                 public void DoOnSelecting (ObjectDataSourceSelectingEventArgs e)
 109                 {
 110                         base.OnSelecting (e);
 111                 }
 112
 113                 public void DoOnUpdating (ObjectDataSourceMethodEventArgs e)
 114                 {
 115                         base.OnUpdating (e);
 116                 }
 117
 118                 public void DoOnUpdated (ObjectDataSourceStatusEventArgs e)
 119                 {
 120                         base.OnUpdated (e);
 121                 }
 122
 123                 public void DoOnDeleted (ObjectDataSourceStatusEventArgs e)
 124                 {
 125                         base.OnDeleted (e);
 126                 }
 127
 128                 public void DoOnInserted (ObjectDataSourceStatusEventArgs e)
 129                 {
 130                         base.OnInserted (e);
 131                 }
 132
 133                 public void DoOnSelected (ObjectDataSourceStatusEventArgs e)
 134                 {
 135                         base.OnSelected (e);
 136                 }
 137
 138                 public int DoExecuteDelete (IDictionary keys, IDictionary oldValues)
 139                 {
 140                         return base.ExecuteDelete (keys, oldValues);
 141                 }
 142
 143                 public void DoOnDataSourceViewChanged ()
 144                 {
 145                         base.OnDataSourceViewChanged (new EventArgs ());
 146                 }
 147
 148         }
 149
 150         [TestFixture]
 151         public class ObjectDataSourceViewTest
 152         {
 153
 154                 [TestFixtureTearDown]
 155                 public void TearDown ()
 156                 {
 157                         WebTest.Unload ();
 158                 }
 159
 160                 [SetUp()]
 161                 public void Setup ()
 162                 {
 163                         eventsCalled = null;
 164                 }
 165
 166                 [Test]
 167                 public void Defaults ()
 168                 {
 169                         ObjectDataSource ds = new ObjectDataSource ();
 170                         ObjectViewPoker sql = new ObjectViewPoker (ds, "DefaultView", null);
 171
 172                         Assert.IsFalse (sql.CanDelete, "CanDelete");
 173                         Assert.IsFalse (sql.CanInsert, "CanInsert");
 174                         Assert.IsFalse (sql.CanPage, "CanPage");
 175                         Assert.IsTrue (sql.CanSort, "CanSort");
 176                         Assert.IsFalse (sql.CanUpdate, "CanUpdate");
 177                         Assert.AreEqual (ConflictOptions.OverwriteChanges, sql.ConflictDetection, "ConflictDetection");
 178                         Assert.IsFalse (sql.ConvertNullToDBNull, "ConvertNullToDBNull");
 179                         Assert.AreEqual ("", sql.DataObjectTypeName, "DataObjectTypeName");
 180                         Assert.AreEqual ("", sql.DeleteMethod, "DeleteMethod");
 181                         Assert.IsNotNull (sql.DeleteParameters, "DeleteParameters");
 182                         Assert.AreEqual (0, sql.DeleteParameters.Count, "DeleteParameters.Count");
 183                         Assert.IsFalse (sql.EnablePaging, "EnablePaging");
 184                         Assert.AreEqual ("", sql.InsertMethod, "InsertMethod");
 185                         Assert.IsNotNull (sql.InsertParameters, "InsertParameters");
 186                         Assert.AreEqual (0, sql.InsertParameters.Count, "InsertParameters.Count");
 187                         Assert.AreEqual ("", sql.FilterExpression, "FilterExpression");
 188                         Assert.IsNotNull (sql.FilterParameters, "FilterParameters");
 189                         Assert.AreEqual (0, sql.FilterParameters.Count, "FilterParameters.Count");
 190                         Assert.AreEqual ("maximumRows", sql.MaximumRowsParameterName, "MaximumRowsParameterName");
 191                         Assert.AreEqual ("", sql.SelectCountMethod, "SelectCountMethod");
 192                         Assert.AreEqual ("", sql.SelectMethod, "SelectMethod");
 193                         Assert.AreEqual ("{0}", sql.OldValuesParameterFormatString, "OldValuesParameterFormatString");
 194                         Assert.IsNotNull (sql.SelectParameters, "SelectParameters");
 195                         Assert.AreEqual (0, sql.SelectParameters.Count, "SelectParameters.Count");
 196                         Assert.AreEqual ("", sql.SortParameterName, "SortParameterName");
 197                         Assert.IsNotNull (sql.UpdateParameters, "UpdateParameters");
 198                         Assert.AreEqual (0, sql.UpdateParameters.Count, "UpdateParameters.Count");
 199                         Assert.AreEqual ("startRowIndex", sql.StartRowIndexParameterName, "StartRowIndexParameterName");
 200                         Assert.AreEqual ("", sql.TypeName, "TypeName");
 201                         Assert.AreEqual ("", sql.UpdateMethod, "UpdateMethod");
 202                         Assert.AreEqual (true, sql.GetIsTrackingViewState (), "IsTrackingViewState");
 203                         Assert.IsTrue (sql.CanRetrieveTotalRowCount, "CanRetrieveTotalRowCount");
 204                 }
 205
 206                 [Test]
 207                 public void DefaultsAssignProperties ()
 208                 {
 209
 210                         ObjectDataSource ds = new ObjectDataSource ();
 211                         ObjectViewPoker sql = new ObjectViewPoker (ds, "DefaultView", null);
 212
 213                         sql.ConflictDetection = ConflictOptions.CompareAllValues;
 214                         Assert.AreEqual (ConflictOptions.CompareAllValues, sql.ConflictDetection, "ConflictDetection");
 215
 216                         sql.ConvertNullToDBNull = true;
 217                         Assert.IsTrue (sql.ConvertNullToDBNull, "ConvertNullToDBNull");
 218
 219                         sql.DataObjectTypeName = "test";
 220                         Assert.AreEqual ("test", sql.DataObjectTypeName, "DataObjectTypeName");
 221
 222                         sql.DeleteMethod = "test";
 223                         Assert.AreEqual ("test", sql.DeleteMethod, "DeleteMethod");
 224
 225                         sql.EnablePaging = true;
 226                         Assert.IsTrue (sql.EnablePaging, "EnablePaging");
 227
 228                         sql.InsertMethod = "test";
 229                         Assert.AreEqual ("test", sql.InsertMethod, "InsertMethod");
 230
 231                         sql.FilterExpression = "test";
 232                         Assert.AreEqual ("test", sql.FilterExpression, "FilterExpression");
 233
 234                         sql.MaximumRowsParameterName = "test";
 235                         Assert.AreEqual ("test", sql.MaximumRowsParameterName, "MaximumRowsParameterName");
 236
 237                         sql.SelectCountMethod = "test";
 238                         Assert.AreEqual ("test", sql.SelectCountMethod, "SelectCountMethod");
 239
 240                         sql.SelectMethod = "test";
 241                         Assert.AreEqual ("test", sql.SelectMethod, "SelectMethod");
 242
 243                         sql.OldValuesParameterFormatString = "test";
 244                         Assert.AreEqual ("test", sql.OldValuesParameterFormatString, "OldValuesParameterFormatString");
 245
 246                         sql.StartRowIndexParameterName = "test";
 247                         Assert.AreEqual ("test", sql.StartRowIndexParameterName, "StartRowIndexParameterName");
 248
 249                         sql.TypeName = "test";
 250                         Assert.AreEqual ("test", sql.TypeName, "TypeName");
 251
 252                         sql.UpdateMethod = "test";
 253                         Assert.AreEqual ("test", sql.UpdateMethod, "UpdateMethod");
 254
 255                         Assert.AreEqual ("DefaultView", sql.Name, "Name");
 256
 257                 }
 258
 259                 [Test]
 260                 public void ViewStateSupport ()
 261                 {
 262                         ObjectDataSourceView view;
 263                         MyDataSource ds = new MyDataSource ();
 264
 265                         ds.ID = "ObjectDataSource2";
 266                         ds.TypeName = "MonoTests.System.Web.UI.WebControls.DataSourceObject";
 267                         ds.SelectMethod = "Select";
 268                         ds.SelectCountMethod = "SelectCount";
 269
 270                         view = (ObjectDataSourceView) ds.DoGetView ("DefaultView");
 271                         ((IStateManager) view).TrackViewState ();
 272
 273                         Parameter p1 = new Parameter ("test", TypeCode.String);
 274
 275                         Assert.IsTrue (((IStateManager) view).IsTrackingViewState, "IsTrackingViewState");
 276                         Assert.IsTrue (((IStateManager) view.FilterParameters).IsTrackingViewState, "FilterParameters.IsTrackingViewState");
 277                         Assert.IsTrue (((IStateManager) view.SelectParameters).IsTrackingViewState, "SelecteParameters.IsTrackingViewState");
 278                         Assert.IsFalse (((IStateManager) view.DeleteParameters).IsTrackingViewState, "DeleteParameters.IsTrackingViewState");
 279                         Assert.IsFalse (((IStateManager) view.InsertParameters).IsTrackingViewState, "InsertParameters.IsTrackingViewState");
 280                         Assert.IsFalse (((IStateManager) view.UpdateParameters).IsTrackingViewState, "UpdateParameters.IsTrackingViewState");
 281
 282                         object state = ((IStateManager) view).SaveViewState ();
 283                         Assert.IsNull (state, "view ViewState not null");
 284
 285                         view.DeleteParameters.Add (p1);
 286                         view.InsertParameters.Add (p1);
 287                         //view.UpdateParameters.Add (p1);
 288
 289                         state = ((IStateManager) view).SaveViewState ();
 290                         Assert.IsNull (state, "view ViewState not null");
 291
 292                         view.FilterParameters.Add (p1);
 293                         //view.SelectParameters.Add (p1);
 294
 295                         state = ((IStateManager) view).SaveViewState ();
 296                         Assert.IsNotNull (state, "view ViewState not null");
 297
 298                         state = ((IStateManager) view.FilterParameters).SaveViewState ();
 299                         Assert.IsNotNull (state, "FilterParamenters ViewState not null");
 300                         state = ((IStateManager) view.SelectParameters).SaveViewState ();
 301                         Assert.IsNull (state, "SelectParameters ViewState not null");
 302
 303                         state = ((IStateManager) view.DeleteParameters).SaveViewState ();
 304                         Assert.IsNotNull (state, "DeleteParameters ViewState not null");
 305                         state = ((IStateManager) view.InsertParameters).SaveViewState ();
 306                         Assert.IsNotNull (state, "InsertParameters ViewState not null");
 307                         state = ((IStateManager) view.UpdateParameters).SaveViewState ();
 308                         Assert.IsNull (state, "UpdateParameters ViewState not null");
 309                 }
 310
 311                 [Test]
 312                 public void ViewState ()
 313                 {
 314                         // Note :
 315                         // IStateManager implementation allows public access to control state
 316                         // Nothing added to viewstate
 317
 318                         ObjectDataSourceView view;
 319                         MyDataSource ds = new MyDataSource ();
 320
 321                         ds.ID = "ObjectDataSource2";
 322                         ds.TypeName = "MonoTests.System.Web.UI.WebControls.DataSourceObject";
 323                         ds.SelectMethod = "Select";
 324                         ds.SelectCountMethod = "SelectCount";
 325
 326                         view = (ObjectDataSourceView) ds.DoGetView ("DefaultView");
 327                         ((IStateManager) view).TrackViewState ();
 328
 329                         view.ConflictDetection = ConflictOptions.CompareAllValues;
 330                         view.ConvertNullToDBNull = true;
 331                         view.DataObjectTypeName = "test";
 332                         view.DeleteMethod = "test";
 333                         view.EnablePaging = true;
 334                         view.InsertMethod = "test";
 335                         view.FilterExpression = "test";
 336                         view.MaximumRowsParameterName = "test";
 337                         view.SelectCountMethod = "test";
 338                         view.SelectMethod = "test";
 339                         view.OldValuesParameterFormatString = "test";
 340                         view.StartRowIndexParameterName = "test";
 341                         view.TypeName = "test";
 342                         view.UpdateMethod = "test";
 343
 344                         object state = ((IStateManager) view).SaveViewState ();
 345                         Assert.IsNull (state, "ViewState#1");
 346
 347                         ObjectDataSourceView copy = new ObjectDataSourceView (ds, "DefaultView", null);
 348                         ((IStateManager) copy).LoadViewState (state);
 349
 350                 }
 351
 352                 [Test]
 353                 public void CanDelete ()
 354                 {
 355                         ObjectDataSource ds = new ObjectDataSource ();
 356                         ObjectViewPoker sql = new ObjectViewPoker (ds, "DefaultView", null);
 357
 358                         sql.DeleteMethod = "DeleteMethod";
 359                         Assert.IsTrue (sql.CanDelete, "A1");
 360
 361                         sql.DeleteMethod = "";
 362                         Assert.IsFalse (sql.CanDelete, "A2");
 363
 364                         sql.DeleteMethod = null;
 365                         Assert.IsFalse (sql.CanDelete, "A3");
 366                 }
 367
 368                 [Test]
 369                 public void CanInsert ()
 370                 {
 371                         ObjectDataSource ds = new ObjectDataSource ();
 372                         ObjectViewPoker sql = new ObjectViewPoker (ds, "DefaultView", null);
 373
 374                         sql.InsertMethod = "InsertMethod";
 375                         Assert.IsTrue (sql.CanInsert, "A1");
 376
 377                         sql.InsertMethod = "";
 378                         Assert.IsFalse (sql.CanInsert, "A2");
 379
 380                         sql.InsertMethod = null;
 381                         Assert.IsFalse (sql.CanInsert, "A3");
 382                 }
 383
 384                 [Test]
 385                 public void CanUpdate ()
 386                 {
 387                         ObjectDataSource ds = new ObjectDataSource ();
 388                         ObjectViewPoker sql = new ObjectViewPoker (ds, "DefaultView", null);
 389
 390                         sql.UpdateMethod = "UpdateMethod";
 391                         Assert.IsTrue (sql.CanUpdate, "A1");
 392
 393                         sql.UpdateMethod = "";
 394                         Assert.IsFalse (sql.CanUpdate, "A2");
 395
 396                         sql.UpdateMethod = null;
 397                         Assert.IsFalse (sql.CanUpdate, "A3");
 398                 }
 399
 400                 [Test]
 401                 public void CanRetrieveTotalRowCount ()
 402                 {
 403                         ObjectDataSource ds = new ObjectDataSource ();
 404                         ObjectDataSourceView view = new ObjectDataSourceView (ds, "DefaultView", null);
 405
 406                         Assert.IsFalse (view.CanPage, "CanPage#1");
 407                         Assert.IsTrue (view.CanRetrieveTotalRowCount, "CanRetrieveTotalRowCount#1");
 408
 409                         view.EnablePaging = true;
 410                         Assert.IsTrue (view.CanPage, "CanPage#2");
 411                         Assert.IsFalse (view.CanRetrieveTotalRowCount, "CanRetrieveTotalRowCount#2");
 412
 413                         view.SelectCountMethod = "SelectCountMethod";
 414                         Assert.IsTrue (view.CanPage, "CanPage#3");
 415                         Assert.IsTrue (view.CanRetrieveTotalRowCount, "CanRetrieveTotalRowCount#3");
 416
 417                         view.EnablePaging = false;
 418                         Assert.IsFalse (view.CanPage, "CanPage#4");
 419                         Assert.IsTrue (view.CanRetrieveTotalRowCount, "CanRetrieveTotalRowCount#4");
 420                 }
 421
 422                 [Test]
 423                 public void OldValuesParameterFormatString ()
 424                 {
 425                         ObjectDataSource ds = new ObjectDataSource ();
 426
 427                         Assert.AreEqual ("{0}", ds.OldValuesParameterFormatString, "A1");
 428
 429                         ds.OldValuesParameterFormatString = "hi {0}";
 430
 431                         ObjectViewPoker sql = new ObjectViewPoker (ds, "DefaultView", null);
 432
 433                         Assert.AreEqual ("{0}", sql.OldValuesParameterFormatString, "A2");
 434
 435                         ds.OldValuesParameterFormatString = "hi {0}";
 436
 437                         Assert.AreEqual ("{0}", sql.OldValuesParameterFormatString, "A3");
 438
 439                         ds.OldValuesParameterFormatString = "{0}";
 440                         sql.OldValuesParameterFormatString = "hi {0}";
 441
 442                         Assert.AreEqual ("{0}", ds.OldValuesParameterFormatString, "A4");
 443                 }
 444
 445                 [Test]
 446                 [Category("NunitWeb")]
 447                 public void DeleteMethod ()
 448                 {
 449                         WebTest t = new WebTest (PageInvoker.CreateOnLoad (delete));
 450                         string html = t.Run ();
 451                         Assert.AreEqual (-1, html.IndexOf("Yonik"), "ObjectDataSourceViewDelete");
 452                 }
 453
 454                 public static void delete (Page p)
 455                 {
 456                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
 457                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
 458                         ObjectDataSourceView view;
 459                         GridView grid = new GridView ();
 460                         MyDataSource ds = new MyDataSource ();
 461                         ds.ID = "ObjectDataSource2";
 462
 463                         ds.TypeName = "MonoTests.System.Web.UI.WebControls.DataSourceObject";
 464                         ds.SelectMethod = "Select";
 465                         ds.DeleteMethod = "Delete";
 466                         ds.InsertMethod = "Insert";
 467                         ds.UpdateMethod = "Update";
 468                         Parameter p1 = new Parameter ("ID", TypeCode.String);
 469                         Parameter p2 = new Parameter ("FName", TypeCode.String);
 470                         Parameter p3 = new Parameter ("LName", TypeCode.String);
 471                         ds.DeleteParameters.Add (p1);
 472                         ds.DeleteParameters.Add (p2);
 473                         ds.DeleteParameters.Add (p3);
 474                         grid.ID = "Grid";
 475                         grid.DataKeyNames = new string[] { "ID", "FName", "LName" };
 476                         grid.DataSourceID = "ObjectDataSource2";
 477                         p.Form.Controls.Add (lcb);
 478                         p.Form.Controls.Add (ds);
 479                         p.Form.Controls.Add (grid);
 480                         p.Form.Controls.Add (lce);
 481                         view = (ObjectDataSourceView) ds.DoGetView ("DefaultView");
 482                         view.Deleting += new ObjectDataSourceMethodEventHandler (Event);
 483
 484                         DataSourceObject.InitDS ();
 485
 486                         Hashtable table = new Hashtable ();
 487                         table.Add ("ID", "1001");
 488                         table.Add ("FName", "Yonik");
 489                         table.Add ("LName", "Laim");
 490                         view.Delete (table, null);
 491                         Assert.AreEqual (true, view.CanDelete, "CanDelete");
 492                         Assert.AreEqual ("Delete", view.DeleteMethod, "DeleteMethod");
 493                         Assert.AreEqual (3, view.DeleteParameters.Count, "DeleteParameters.Count");
 494                         Assert.AreEqual ("ID", view.DeleteParameters[0].Name, "DeleteParametersName#1");
 495                         Assert.AreEqual ("FName", view.DeleteParameters[1].Name, "DeleteParametersName#2");
 496                         Assert.AreEqual ("LName", view.DeleteParameters[2].Name, "DeleteParametersName#3");
 497                         ObjectDataSourceViewTest.Eventassert ("Delete event has not fired");
 498                 }
 499
 500
 501                 [Test]
 502                 [Category ("NunitWeb")]
 503                 public void SelectMethod ()
 504                 {
 505                         WebTest t = new WebTest (PageInvoker.CreateOnLoad (select));
 506                         string html = t.Run ();
 507 #if NET_4_0
 508                         string origin = "<div>\r\n\t<table cellspacing=\"0\" rules=\"all\" border=\"1\" id=\"Grid\" style=\"border-collapse:collapse;\">\r\n\t\t<tr>\r\n\t\t\t<th scope=\"col\">ID</th><th scope=\"col\">FName</th><th scope=\"col\">LName</th>\r\n\t\t</tr><tr>\r\n\t\t\t<td>1001</td><td>Mahesh</td><td>Chand</td>\r\n\t\t</tr>\r\n\t</table>\r\n</div>";
 509 #else
 510                         string origin = "<div>\r\n\t<table cellspacing=\"0\" rules=\"all\" border=\"1\" id=\"Grid\" style=\"border-collapse:collapse;\">\r\n\t\t<tr>\r\n\t\t\t<th scope=\"col\">ID</th><th scope=\"col\">FName</th><th scope=\"col\">LName</th>\r\n\t\t</tr><tr>\r\n\t\t\t<td>1001</td><td>Mahesh</td><td>Chand</td>\r\n\t\t</tr>\r\n\t</table>\r\n</div>";
 511 #endif
 512                         string renderedHtml = HtmlDiff.GetControlFromPageHtml (html);
 513                         HtmlDiff.AssertAreEqual (origin, renderedHtml, "ObjectDataSourceViewSelect");
 514                 }
 515
 516                 public static void select (Page p)
 517                 {
 518                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
 519                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
 520                         ObjectDataSourceView view;
 521                         GridView grid = new GridView ();
 522                         MyDataSource ds = new MyDataSource ();
 523                         ds.ID = "ObjectDataSource2";
 524                         ds.TypeName = "MonoTests.System.Web.UI.WebControls.DataSourceObject";
 525                         ds.SelectMethod = "Select";
 526
 527                         grid.ID = "Grid";
 528                         grid.DataKeyNames = new string[] { "ID" };
 529                         grid.DataSourceID = "ObjectDataSource2";
 530                         p.Form.Controls.Add (lcb);
 531                         p.Form.Controls.Add (ds);
 532                         p.Form.Controls.Add (grid);
 533                         p.Form.Controls.Add (lce);
 534                         view = (ObjectDataSourceView) ds.DoGetView ("DefaultView");
 535                         view.Selecting += new ObjectDataSourceSelectingEventHandler (view_Selecting);
 536
 537                         DataSourceObject.InitDS ();
 538
 539                         DataView view1 = (DataView) view.Select (new DataSourceSelectArguments ());
 540                         Assert.AreEqual (1, view1.Count, "SelectedRowsCount");
 541                         Assert.AreEqual (1001, view1[0].Row["ID"], "SelectedRowsValue#1");
 542                         Assert.AreEqual ("Mahesh", view1[0].Row["FName"], "SelectedRowsValue#2");
 543                         Assert.AreEqual ("Chand", view1[0].Row["LName"], "SelectedRowsValue#3");
 544                         ObjectDataSourceViewTest.Eventassert ("Select event has not fired");
 545                 }
 546
 547                 [Test]
 548                 [Category ("NunitWeb")]
 549                 public void SelectCountMethod ()
 550                 {
 551                         // This method will render grid view with paging
 552                         // Note : ObjectDataSource will return page counter 5 hard coded
 553                         WebTest t = new WebTest (PageInvoker.CreateOnLoad (selectcount));
 554                         string html = t.Run ();
 555 #if NET_4_0
 556                         string origin = "<div>\r\n\t<table cellspacing=\"0\" rules=\"all\" border=\"1\" id=\"Grid\" style=\"border-collapse:collapse;\">\r\n\t\t<tr>\r\n\t\t\t<th scope=\"col\">ID</th><th scope=\"col\">FName</th><th scope=\"col\">LName</th>\r\n\t\t</tr><tr>\r\n\t\t\t<td>1001</td><td>Mahesh</td><td>Chand</td>\r\n\t\t</tr><tr>\r\n\t\t\t<td colspan=\"3\"><table>\r\n\t\t\t\t<tr>\r\n\t\t\t\t\t<td><span>1</span></td><td><a href=\"javascript:__doPostBack(&#39;Grid&#39;,&#39;Page$2&#39;)\">2</a></td><td><a href=\"javascript:__doPostBack(&#39;Grid&#39;,&#39;Page$3&#39;)\">3</a></td><td><a href=\"javascript:__doPostBack(&#39;Grid&#39;,&#39;Page$4&#39;)\">4</a></td><td><a href=\"javascript:__doPostBack(&#39;Grid&#39;,&#39;Page$5&#39;)\">5</a></td>\r\n\t\t\t\t</tr>\r\n\t\t\t</table></td>\r\n\t\t</tr>\r\n\t</table>\r\n</div>";
 557 #else
 558                         string origin = "<div>\r\n\t<table cellspacing=\"0\" rules=\"all\" border=\"1\" id=\"Grid\" style=\"border-collapse:collapse;\">\r\n\t\t<tr>\r\n\t\t\t<th scope=\"col\">ID</th><th scope=\"col\">FName</th><th scope=\"col\">LName</th>\r\n\t\t</tr><tr>\r\n\t\t\t<td>1001</td><td>Mahesh</td><td>Chand</td>\r\n\t\t</tr><tr>\r\n\t\t\t<td colspan=\"3\"><table border=\"0\">\r\n\t\t\t\t<tr>\r\n\t\t\t\t\t<td><span>1</span></td><td><a href=\"javascript:__doPostBack('Grid','Page$2')\">2</a></td><td><a href=\"javascript:__doPostBack('Grid','Page$3')\">3</a></td><td><a href=\"javascript:__doPostBack('Grid','Page$4')\">4</a></td><td><a href=\"javascript:__doPostBack('Grid','Page$5')\">5</a></td>\r\n\t\t\t\t</tr>\r\n\t\t\t</table></td>\r\n\t\t</tr>\r\n\t</table>\r\n</div>";
 559 #endif
 560                         string renderedHtml = HtmlDiff.GetControlFromPageHtml (html);
 561                         HtmlDiff.AssertAreEqual (origin, renderedHtml, "ObjectDataSourceViewSelectCount");
 562                 }
 563
 564                 public static void selectcount (Page p)
 565                 {
 566                         // This method will render grid view with paging
 567                         // Note : ObjectDataSource will return page counter 5 hard coded
 568
 569                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
 570                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
 571                         ObjectDataSourceView view;
 572                         GridView grid = new GridView ();
 573                         MyDataSource ds = new MyDataSource ();
 574                         ds.ID = "ObjectDataSource2";
 575                         ds.EnablePaging = true;
 576                         ds.TypeName = "MonoTests.System.Web.UI.WebControls.DataSourceObject";
 577                         ds.SelectMethod = "Select";
 578                         ds.SelectCountMethod = "SelectCount";
 579
 580
 581                         grid.ID = "Grid";
 582                         grid.DataKeyNames = new string[] { "ID" };
 583                         grid.DataSourceID = "ObjectDataSource2";
 584                         grid.AllowPaging = true;
 585                         grid.PageSize = 1;
 586
 587                         p.Form.Controls.Add (lcb);
 588                         p.Form.Controls.Add (ds);
 589                         p.Form.Controls.Add (grid);
 590                         p.Form.Controls.Add (lce);
 591                         view = (ObjectDataSourceView) ds.DoGetView ("DefaultView");
 592                         Assert.IsTrue (view.CanRetrieveTotalRowCount, "CanRetrieveTotalRowCount");
 593                 }
 594
 595
 596                 [Test]
 597                 [Category ("NunitWeb")]
 598                 public void InsertMethod ()
 599                 {
 600                         WebTest t = new WebTest (PageInvoker.CreateOnLoad (insert));
 601                         string html = t.Run ();
 602                         string origin = "<div>\r\n\t<table cellspacing=\"0\" rules=\"all\" border=\"1\" id=\"Grid\" style=\"border-collapse:collapse;\">\r\n\t\t<tr>\r\n\t\t\t<th scope=\"col\">ID</th><th scope=\"col\">FName</th><th scope=\"col\">LName</th>\r\n\t\t</tr><tr>\r\n\t\t\t<td>1001</td><td>Mahesh</td><td>Chand</td>\r\n\t\t</tr><tr>\r\n\t\t\t<td>1000</td><td>Yonik</td><td>Laim</td>\r\n\t\t</tr>\r\n\t</table>\r\n</div>";
 603                         string renderedHtml = HtmlDiff.GetControlFromPageHtml (html);
 604                         HtmlDiff.AssertAreEqual (origin, renderedHtml, "ObjectDataSourceViewInsert");
 605                 }
 606
 607                 public static void insert (Page p)
 608                 {
 609                         DataSourceObject.InitDS ();
 610
 611                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
 612                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
 613                         ObjectDataSourceView view;
 614                         GridView grid = new GridView ();
 615                         MyDataSource ds = new MyDataSource ();
 616                         ds.ID = "ObjectDataSource1";
 617                         ds.TypeName = "MonoTests.System.Web.UI.WebControls.DataSourceObject";
 618                         ds.SelectMethod = "Select";
 619                         ds.InsertMethod = "Insert";
 620
 621
 622                         Parameter p1 = new Parameter ("ID", TypeCode.String);
 623                         Parameter p2 = new Parameter ("FName", TypeCode.String);
 624                         Parameter p3 = new Parameter ("LName", TypeCode.String);
 625
 626                         ds.InsertParameters.Add (p1);
 627                         ds.InsertParameters.Add (p2);
 628                         ds.InsertParameters.Add (p3);
 629
 630                         grid.ID = "Grid";
 631                         grid.DataSourceID = "ObjectDataSource1";
 632                         p.Form.Controls.Add (lcb);
 633                         p.Form.Controls.Add (ds);
 634                         p.Form.Controls.Add (grid);
 635                         p.Form.Controls.Add (lce);
 636                         view = (ObjectDataSourceView) ds.DoGetView ("DefaultView");
 637                         view.Inserting += new ObjectDataSourceMethodEventHandler (Event);
 638
 639                         Hashtable table = new Hashtable ();
 640                         table.Add ("ID", "1000");
 641                         table.Add ("FName", "Yonik");
 642                         table.Add ("LName", "Laim");
 643                         view.Insert (table);
 644                         Assert.AreEqual (true, view.CanInsert, "CanInsert");
 645                         Assert.AreEqual ("Insert", view.InsertMethod, "InsertMethod");
 646                         Assert.AreEqual (3, view.InsertParameters.Count, "InsertParameters.Count");
 647                         Assert.AreEqual ("ID", view.InsertParameters[0].Name, "InsertParametersName#1");
 648                         Assert.AreEqual ("FName", view.InsertParameters[1].Name, "InsertParametersName#2");
 649                         Assert.AreEqual ("LName", view.InsertParameters[2].Name, "InsertParametersName#3");
 650                         ObjectDataSourceViewTest.Eventassert ("Insert event has not fired");
 651                 }
 652
 653                 [Test]
 654                 [Category ("NunitWeb")]
 655                 public void UpdateMethod ()
 656                 {
 657                         WebTest t = new WebTest (PageInvoker.CreateOnLoad (update));
 658                         string html = t.Run ();
 659                         string origin = "<div>\r\n\t<table cellspacing=\"0\" rules=\"all\" border=\"1\" id=\"Grid\" style=\"border-collapse:collapse;\">\r\n\t\t<tr>\r\n\t\t\t<th scope=\"col\">ID</th><th scope=\"col\">FName</th><th scope=\"col\">LName</th>\r\n\t\t</tr><tr>\r\n\t\t\t<td>1001</td><td>Yonik</td><td>Laim</td>\r\n\t\t</tr>\r\n\t</table>\r\n</div>";
 660                         string renderedHtml = HtmlDiff.GetControlFromPageHtml (html);
 661                         HtmlDiff.AssertAreEqual (origin, renderedHtml, "ObjectDataSourceViewUpdate");
 662                 }
 663
 664                 public static void update (Page p)
 665                 {
 666                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
 667                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
 668                         ObjectDataSourceView view;
 669                         GridView grid = new GridView ();
 670                         MyDataSource ds = new MyDataSource ();
 671                         ds.ID = "ObjectDataSource1";
 672                         ds.TypeName = "MonoTests.System.Web.UI.WebControls.DataSourceObject";
 673
 674                         ds.SelectMethod = "Select";
 675                         ds.DeleteMethod = "Delete";
 676                         ds.InsertMethod = "Insert";
 677                         ds.UpdateMethod = "Update";
 678
 679                         Parameter p1 = new Parameter ("ID", TypeCode.String);
 680                         Parameter p2 = new Parameter ("FName", TypeCode.String);
 681                         Parameter p3 = new Parameter ("LName", TypeCode.String);
 682
 683                         ds.UpdateParameters.Add (p1);
 684                         ds.UpdateParameters.Add (p2);
 685                         ds.UpdateParameters.Add (p3);
 686
 687                         grid.ID = "Grid";
 688                         grid.DataSourceID = "ObjectDataSource1";
 689                         p.Form.Controls.Add (lcb);
 690                         p.Form.Controls.Add (ds);
 691                         p.Form.Controls.Add (grid);
 692                         p.Form.Controls.Add (lce);
 693                         view = (ObjectDataSourceView) ds.DoGetView ("defaultView");
 694                         view.Updating += new ObjectDataSourceMethodEventHandler (Event);
 695
 696                         DataSourceObject.InitDS ();
 697
 698                         Hashtable table = new Hashtable ();
 699                         table.Add ("ID", "1001");
 700                         table.Add ("FName", "Yonik");
 701                         table.Add ("LName", "Laim");
 702                         view.Update (null, table, null);
 703                         Assert.AreEqual (true, view.CanUpdate, "CanUpdate");
 704                         Assert.AreEqual ("Update", view.UpdateMethod, "UpdateMethod");
 705                         Assert.AreEqual (3, view.UpdateParameters.Count, "UpdateParameters.Count");
 706                         Assert.AreEqual ("ID", view.UpdateParameters[0].Name, "UpdateParametersName#1");
 707                         Assert.AreEqual ("FName", view.UpdateParameters[1].Name, "UpdateParametersName#2");
 708                         Assert.AreEqual ("LName", view.UpdateParameters[2].Name, "UpdateParametersName#3");
 709                         ObjectDataSourceViewTest.Eventassert ("Update event has not fired");
 710                 }
 711
 712
 713                 //Events
 714                 [Test]
 715                 public void UpdateEvent ()
 716                 {
 717                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
 718                         view.Updating += new ObjectDataSourceMethodEventHandler (Event);
 719                         view.DoOnUpdating (new ObjectDataSourceMethodEventArgs (null));
 720                         Eventassert ("UpdateEvent");
 721                         view.Updated += new ObjectDataSourceStatusEventHandler (view_Status);
 722                         view.DoOnUpdated (new ObjectDataSourceStatusEventArgs (null, null));
 723                         Eventassert ("UpdateEvent");
 724                 }
 725
 726                 [Test]
 727                 public void SelectEvent ()
 728                 {
 729                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
 730                         view.Selecting += new ObjectDataSourceSelectingEventHandler (view_Selecting);
 731                         view.DoOnSelecting (new ObjectDataSourceSelectingEventArgs (null, new DataSourceSelectArguments (), false));
 732                         Eventassert ("SelectingEvent");
 733                         view.Selected += new ObjectDataSourceStatusEventHandler (view_Status);
 734                         view.DoOnSelected (new ObjectDataSourceStatusEventArgs (null, null));
 735                         Eventassert ("SelectedEvent");
 736                 }
 737
 738                 [Test]
 739                 public void InsertEvent ()
 740                 {
 741                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
 742                         view.Inserting += new ObjectDataSourceMethodEventHandler (Event);
 743                         view.DoOnInserting (new ObjectDataSourceMethodEventArgs (null));
 744                         Eventassert ("InsertingEvent");
 745                         view.Inserted += new ObjectDataSourceStatusEventHandler (view_Status);
 746                         view.DoOnInserted (new ObjectDataSourceStatusEventArgs (null, null));
 747                         Eventassert ("InsertedEvent");
 748                 }
 749
 750                 [Test]
 751                 public void DeleteEvent ()
 752                 {
 753                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
 754                         view.Deleting += new ObjectDataSourceMethodEventHandler (Event);
 755                         view.DoOnDeleting (new ObjectDataSourceMethodEventArgs (null));
 756                         Eventassert ("DeletingEvent");
 757                         view.Deleted += new ObjectDataSourceStatusEventHandler (view_Status);
 758                         view.DoOnDeleted (new ObjectDataSourceStatusEventArgs (null, null));
 759                         Eventassert ("DeletedEvent");
 760                 }
 761
 762                 [Test]
 763                 public void FilterEvent ()
 764                 {
 765                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
 766                         view.Filtering += new ObjectDataSourceFilteringEventHandler (view_Filtering);
 767                         view.DoOnFiltering (new ObjectDataSourceFilteringEventArgs (null));
 768                         Eventassert ("FilterEvent");
 769                 }
 770
 771                 [Test]
 772                 public void ObjectCreatingEvent ()
 773                 {
 774                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
 775                         view.ObjectCreating += new ObjectDataSourceObjectEventHandler (view_ObjectCreate);
 776                         view.DoOnObjectCreating (new ObjectDataSourceEventArgs (null));
 777                         Eventassert ("ObjectCreatingEvent");
 778                         view.ObjectCreated += new ObjectDataSourceObjectEventHandler (view_ObjectCreate);
 779                         view.DoOnObjectCreated (new ObjectDataSourceEventArgs (null));
 780                         Eventassert ("ObjectCreatedEvent");
 781                         view.ObjectDisposing += new ObjectDataSourceDisposingEventHandler (view_ObjectDisposing);
 782                 }
 783
 784                 [Test]
 785                 public void ObjectDisposing ()
 786                 {
 787                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
 788                         view.ObjectDisposing += new ObjectDataSourceDisposingEventHandler (view_ObjectDisposing);
 789                         view.DoOnObjectDisposing (new ObjectDataSourceDisposingEventArgs (null));
 790                         Eventassert ("ObjectDisposing");
 791                 }
 792
 793                 IEnumerable returnedData;
 794                 void SelectCallback (IEnumerable data)
 795                 {
 796                         returnedData = data;
 797                 }
 798
 799                 [Test] // bug #471767
 800                 public void SelectReturnsObjectArray ()
 801                 {
 802                         ObjectDataSource ds = new ObjectDataSource ();
 803                         ds.TypeName=typeof(DataSourceObject).AssemblyQualifiedName;
 804                         ds.SelectMethod="SelectObject";
 805
 806                         DataSourceView dsv = ((IDataSource)ds).GetView (String.Empty);
 807                         dsv.Select (DataSourceSelectArguments.Empty, new DataSourceViewSelectCallback (SelectCallback));
 808                         Assert.IsTrue (returnedData != null, "#A1");
 809                         Assert.AreEqual (typeof (object[]), returnedData.GetType (), "#A2");
 810
 811                         object[] data = returnedData as object[];
 812                         Assert.AreEqual (1, data.Length, "#A3");
 813                         Assert.AreEqual (typeof (MyCustomDataObject), data [0].GetType (), "#A4");
 814                 }
 815
 816                 enum InitViewType
 817                 {
 818                         MatchParamsToValues,
 819                         MatchParamsToOldValues,
 820                         DontMatchParams,
 821                 }
 822
 823                 public class DummyDataSourceObject
 824                 {
 825                         public static IEnumerable Select (string filter)
 826                         {
 827                                 if (eventsCalled == null) {
 828                                         eventsCalled = new ArrayList ();
 829                                 }
 830                                 eventsCalled.Add (String.Format ("Select(filter = {0})", filter));
 831                                 return new string [] { "one", "two", "three" };
 832                         }
 833
 834                         public static int Update (string ID)
 835                         {
 836                                 if (eventsCalled == null) {
 837                                         eventsCalled = new ArrayList ();
 838                                 }
 839                                 eventsCalled.Add (String.Format ("Update(ID = {0})", ID));
 840                                 return 1;
 841                         }
 842
 843                         public static int Update (string ID, string oldvalue_ID)
 844                         {
 845                                 if (eventsCalled == null) {
 846                                         eventsCalled = new ArrayList ();
 847                                 }
 848                                 eventsCalled.Add (String.Format ("Update(ID = {0}, oldvalue_ID = {1})", ID, oldvalue_ID));
 849                                 return 1;
 850                         }
 851
 852                         public static int UpdateOther (string ID, string OtherValue, string oldvalue_ID)
 853                         {
 854                                 if (eventsCalled == null) {
 855                                         eventsCalled = new ArrayList ();
 856                                 }
 857                                 eventsCalled.Add (String.Format ("UpdateOther(ID = {0}, OtherValue = {1}, oldvalue_ID = {2})", ID, OtherValue, oldvalue_ID));
 858                                 return 1;
 859                         }
 860
 861                         public static int Insert (string ID)
 862                         {
 863                                 if (eventsCalled == null) {
 864                                         eventsCalled = new ArrayList ();
 865                                 }
 866                                 eventsCalled.Add (String.Format ("Insert(ID = {0})", ID));
 867                                 return 1;
 868                         }
 869
 870                         public static int Insert (string ID, string oldvalue_ID)
 871                         {
 872                                 if (eventsCalled == null) {
 873                                         eventsCalled = new ArrayList ();
 874                                 }
 875                                 eventsCalled.Add (String.Format ("Insert(ID = {0}, oldvalue_ID = {1})", ID, oldvalue_ID));
 876                                 return 1;
 877                         }
 878
 879                         public static int InsertOther (string ID, string OtherValue)
 880                         {
 881                                 if (eventsCalled == null) {
 882                                         eventsCalled = new ArrayList ();
 883                                 }
 884                                 eventsCalled.Add (String.Format ("InsertOther(ID = {0}, OtherValue = {1})", ID, OtherValue));
 885                                 return 1;
 886                         }
 887
 888                         public static int Delete (string ID, string oldvalue_ID)
 889                         {
 890                                 if (eventsCalled == null) {
 891                                         eventsCalled = new ArrayList ();
 892                                 }
 893                                 eventsCalled.Add (String.Format ("Delete(ID = {0}, oldvalue_ID = {1})", ID, oldvalue_ID));
 894                                 return 1;
 895                         }
 896
 897                         public static int Delete (string oldvalue_ID)
 898                         {
 899                                 if (eventsCalled == null) {
 900                                         eventsCalled = new ArrayList ();
 901                                 }
 902                                 eventsCalled.Add (String.Format ("Delete(oldvalue_ID = {0})", oldvalue_ID));
 903                                 return 1;
 904                         }
 905
 906                         public static int DeleteOther (string oldvalue_ID, string OtherValue)
 907                         {
 908                                 if (eventsCalled == null) {
 909                                         eventsCalled = new ArrayList ();
 910                                 }
 911                                 eventsCalled.Add (String.Format ("DeleteOther(oldvalue_ID = {0}, OtherValue = {1})", oldvalue_ID, OtherValue));
 912                                 return 1;
 913                         }
 914                 }
 915
 916                 public class AlwaysChangingParameter : Parameter
 917                 {
 918                         int evaluateCount;
 919
 920                         public AlwaysChangingParameter (string name, TypeCode type, string defaultValue)
 921                                 : base (name, type, defaultValue)
 922                         {
 923                                 evaluateCount = 0;
 924                         }
 925
 926 #if NET_4_0
 927                         internal
 928 #endif
 929                         protected override object Evaluate (HttpContext context, Control control)
 930                         {
 931                                 evaluateCount++;
 932                                 return String.Format ("{0}{1}", DefaultValue, evaluateCount);
 933                         }
 934                 }
 935
 936                 #region help_results
 937                 class eventAssert
 938                 {
 939                         private static int _testcounter;
 940                         private static bool _eventChecker;
 941                         private eventAssert ()
 942                         {
 943                                 _testcounter = 0;
 944                         }
 945
 946                         public static bool eventChecker
 947                         {
 948                                 get
 949                                 {
 950                                         throw new NotImplementedException ();
 951                                 }
 952                                 set
 953                                 {
 954                                         _eventChecker = value;
 955                                 }
 956                         }
 957
 958                         static private void testAdded ()
 959                         {
 960                                 _testcounter++;
 961                                 _eventChecker = false;
 962                         }
 963
 964                         public static void IsTrue (string msg)
 965                         {
 966                                 Assert.IsTrue (_eventChecker, msg + "#" + _testcounter);
 967                                 testAdded ();
 968
 969                         }
 970
 971                         public static void IsFalse (string msg)
 972                         {
 973                                 Assert.IsFalse (_eventChecker, msg + "#" + _testcounter);
 974                                 testAdded ();
 975                         }
 976                 }
 977                 #endregion
 978
 979                 [Test]
 980                 public void ObjectDataSourceView_DataSourceViewChanged ()
 981                 {
 982                         ObjectDataSource ds = new ObjectDataSource ();
 983                         ObjectViewPoker sql = new ObjectViewPoker (ds, "DefaultView", null);
 984                         sql.DataSourceViewChanged += new EventHandler (sql_DataSourceViewChanged);
 985
 986                         sql.DoOnDataSourceViewChanged ();
 987                         eventAssert.IsTrue ("DataSourceViewChanged");
 988
 989                         sql.ConflictDetection = ConflictOptions.CompareAllValues;
 990                         eventAssert.IsTrue ("DataSourceViewChanged");
 991
 992                         sql.ConvertNullToDBNull = true;
 993                         eventAssert.IsFalse ("DataSourceViewChanged");
 994
 995                         sql.DataObjectTypeName = "test";
 996                         eventAssert.IsTrue ("DataSourceViewChanged");
 997
 998                         sql.DeleteMethod = "test";
 999                         eventAssert.IsFalse ("DataSourceViewChanged");
1000
1001                         sql.EnablePaging = true;
1002                         eventAssert.IsTrue ("DataSourceViewChanged");
1003
1004                         sql.InsertMethod = "test";
1005                         eventAssert.IsFalse ("DataSourceViewChanged");
1006
1007                         sql.FilterExpression = "test";
1008                         eventAssert.IsTrue ("DataSourceViewChanged");
1009
1010                         sql.MaximumRowsParameterName = "test";
1011                         eventAssert.IsTrue ("DataSourceViewChanged");
1012
1013                         sql.SelectCountMethod = "test";
1014                         eventAssert.IsTrue ("DataSourceViewChanged");
1015
1016                         sql.SelectMethod = "test";
1017                         eventAssert.IsTrue ("DataSourceViewChanged");
1018
1019                         sql.OldValuesParameterFormatString = "test";
1020                         eventAssert.IsTrue ("DataSourceViewChanged");
1021
1022                         sql.StartRowIndexParameterName = "test";
1023                         eventAssert.IsTrue ("DataSourceViewChanged");
1024
1025                         sql.TypeName = "test";
1026                         eventAssert.IsTrue ("DataSourceViewChanged");
1027
1028                         sql.UpdateMethod = "test";
1029                         eventAssert.IsFalse ("DataSourceViewChanged");
1030                 }
1031
1032                 void sql_DataSourceViewChanged (object sender, EventArgs e)
1033                 {
1034                         eventAssert.eventChecker = true;
1035                 }
1036
1037                 [Test]
1038                 public void SelectCountMethod_DataSourceViewChanged ()
1039                 {
1040                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1041                         view.DataSourceViewChanged += new EventHandler (view_DataSourceViewChanged);
1042
1043                         Assert.AreEqual ("", view.SelectCountMethod);
1044                         view.SelectCountMethod = null;
1045                         Assert.AreEqual (1, eventsCalled.Count);
1046                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [0]);
1047                         Assert.AreEqual ("", view.SelectCountMethod);
1048
1049                         view.SelectCountMethod = null;
1050                         Assert.AreEqual (2, eventsCalled.Count);
1051                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [1]);
1052                         Assert.AreEqual ("", view.SelectCountMethod);
1053
1054                         view.SelectCountMethod = "";
1055                         Assert.AreEqual (2, eventsCalled.Count);
1056                 }
1057
1058                 [Test]
1059                 public void SelectMethod_DataSourceViewChanged2 ()
1060                 {
1061                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1062                         view.DataSourceViewChanged += new EventHandler (view_DataSourceViewChanged);
1063
1064                         Assert.AreEqual ("", view.SelectMethod);
1065                         view.SelectMethod = null;
1066                         Assert.AreEqual (1, eventsCalled.Count);
1067                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [0]);
1068                         Assert.AreEqual ("", view.SelectMethod);
1069
1070                         view.SelectMethod = null;
1071                         Assert.AreEqual (2, eventsCalled.Count);
1072                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [1]);
1073                         Assert.AreEqual ("", view.SelectMethod);
1074
1075                         view.SelectMethod = "";
1076                         Assert.AreEqual (2, eventsCalled.Count);
1077                 }
1078
1079                 [Test]
1080                 public void SelectMethod_DataSourceViewChanged1 ()
1081                 {
1082                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1083                         view.DataSourceViewChanged+=new EventHandler(view_DataSourceViewChanged);
1084
1085                         view.SelectMethod = "select_1";
1086                         Assert.AreEqual (1, eventsCalled.Count);
1087                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [0]);
1088
1089                         view.SelectMethod = "select_2";
1090                         Assert.AreEqual (2, eventsCalled.Count);
1091                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [1]);
1092
1093                         view.SelectMethod = "select_2";
1094                         Assert.AreEqual (2, eventsCalled.Count);
1095
1096                         view.SelectCountMethod = "selectCount_1";
1097                         Assert.AreEqual (3, eventsCalled.Count);
1098                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2]);
1099
1100                         view.SelectCountMethod = "selectCount_2";
1101                         Assert.AreEqual (4, eventsCalled.Count);
1102                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [3]);
1103
1104                         view.SelectCountMethod = "selectCount_2";
1105                         Assert.AreEqual (4, eventsCalled.Count);
1106                 }
1107
1108                 private static void InitializeView (ObjectViewPoker view, InitViewType initType, out Hashtable keys, out Hashtable old_value, out Hashtable new_value)
1109                 {
1110                         view.TypeName = typeof (DummyDataSourceObject).AssemblyQualifiedName;
1111                         view.OldValuesParameterFormatString = "oldvalue_{0}";
1112                         view.SelectMethod = "Select";
1113                         if (initType == InitViewType.DontMatchParams) {
1114                                 view.UpdateMethod = "UpdateOther";
1115                                 view.InsertMethod = "InsertOther";
1116                                 view.DeleteMethod = "DeleteOther";
1117                         }
1118                         else {
1119                                 view.UpdateMethod = "Update";
1120                                 view.InsertMethod = "Insert";
1121                                 view.DeleteMethod = "Delete";
1122                         }
1123
1124                         Parameter selectParameter = null;
1125                         Parameter insertParameter = null;
1126                         Parameter updateParameter = null;
1127                         Parameter deleteParameter = null;
1128
1129                         selectParameter = new AlwaysChangingParameter ("filter", TypeCode.String, "p_ValueSelect");
1130                         view.SelectParameters.Add (selectParameter);
1131
1132                         switch (initType) {
1133                         case InitViewType.MatchParamsToOldValues:
1134                                 insertParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueInsert");
1135                                 view.InsertParameters.Add (insertParameter);
1136                                 updateParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueUpdate");
1137                                 view.UpdateParameters.Add (updateParameter);
1138                                 deleteParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueDelete");
1139                                 view.DeleteParameters.Add (deleteParameter);
1140                                 break;
1141
1142                         case InitViewType.MatchParamsToValues:
1143                                 insertParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueInsert");
1144                                 view.InsertParameters.Add (insertParameter);
1145                                 updateParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueUpdate");
1146                                 view.UpdateParameters.Add (updateParameter);
1147                                 deleteParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueDelete");
1148                                 view.DeleteParameters.Add (deleteParameter);
1149                                 break;
1150
1151                         case InitViewType.DontMatchParams:
1152                                 insertParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueInsert");
1153                                 view.InsertParameters.Add (insertParameter);
1154                                 updateParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueUpdate");
1155                                 view.UpdateParameters.Add (updateParameter);
1156                                 deleteParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueDelete");
1157                                 view.DeleteParameters.Add (deleteParameter);
1158                                 break;
1159                         }
1160
1161                         view.SelectParameters.ParametersChanged += new EventHandler (SelectParameters_ParametersChanged);
1162                         view.InsertParameters.ParametersChanged += new EventHandler (InsertParameters_ParametersChanged);
1163                         view.UpdateParameters.ParametersChanged += new EventHandler (UpdateParameters_ParametersChanged);
1164                         view.DeleteParameters.ParametersChanged += new EventHandler (DeleteParameters_ParametersChanged);
1165
1166                         keys = new Hashtable ();
1167                         keys.Add ("ID", "k_1001");
1168
1169                         old_value = new Hashtable ();
1170                         old_value.Add ("ID", "ov_1001");
1171
1172                         new_value = new Hashtable ();
1173                         new_value.Add ("ID", "n_1001");
1174
1175                         view.DataSourceViewChanged += new EventHandler (view_DataSourceViewChanged);
1176                 }
1177
1178                 private static IList eventsCalled;
1179
1180                 static void view_DataSourceViewChanged (object sender, EventArgs e)
1181                 {
1182                         if (eventsCalled == null) {
1183                                 eventsCalled = new ArrayList ();
1184                         }
1185                         eventsCalled.Add ("view_DataSourceViewChanged");
1186                 }
1187
1188                 static void SelectParameters_ParametersChanged (object sender, EventArgs e)
1189                 {
1190                         if (eventsCalled == null) {
1191                                 eventsCalled = new ArrayList ();
1192                         }
1193                         eventsCalled.Add ("SelectParameters_ParametersChanged");
1194                 }
1195
1196                 static void InsertParameters_ParametersChanged (object sender, EventArgs e)
1197                 {
1198                         if (eventsCalled == null) {
1199                                 eventsCalled = new ArrayList ();
1200                         }
1201                         eventsCalled.Add ("InsertParameters_ParametersChanged");
1202                 }
1203
1204                 static void UpdateParameters_ParametersChanged (object sender, EventArgs e)
1205                 {
1206                         if (eventsCalled == null) {
1207                                 eventsCalled = new ArrayList ();
1208                         }
1209                         eventsCalled.Add ("UpdateParameters_ParametersChanged");
1210                 }
1211
1212                 static void DeleteParameters_ParametersChanged (object sender, EventArgs e)
1213                 {
1214                         if (eventsCalled == null) {
1215                                 eventsCalled = new ArrayList ();
1216                         }
1217                         eventsCalled.Add ("DeleteParameters_ParametersChanged");
1218                 }
1219
1220                 [Test]
1221                 public void ParametersAndViewChangedEvent_Select ()
1222                 {
1223                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1224                         Hashtable keys = null;
1225                         Hashtable old_values = null;
1226                         Hashtable new_values = null;
1227                         InitializeView (view, InitViewType.MatchParamsToValues, out keys, out old_values, out new_values);
1228
1229                         view.Select (DataSourceSelectArguments.Empty);
1230
1231                         Assert.IsNotNull (eventsCalled, "Events not raized");
1232                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1233                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [0], "view_DataSourceViewChanged");
1234                         Assert.AreEqual ("SelectParameters_ParametersChanged", eventsCalled [1], "SelectParameters_ParametersChanged");
1235                         Assert.AreEqual ("Select(filter = p_ValueSelect1)", eventsCalled [2], "DataSource Method params");
1236                 }
1237
1238                 [Test]
1239                 public void ParametersAndViewChangedEvent_MatchInsert ()
1240                 {
1241                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1242                         Hashtable keys = null;
1243                         Hashtable old_values = null;
1244                         Hashtable new_values = null;
1245                         InitializeView (view, InitViewType.MatchParamsToValues, out keys, out old_values, out new_values);
1246
1247                         view.Insert (new_values);
1248
1249                         Assert.IsNotNull (eventsCalled, "Events not raized");
1250                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1251                         Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
1252                         Assert.AreEqual ("Insert(ID = n_1001)", eventsCalled [1], "DataSource Method params");
1253                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1254                 }
1255
1256                 [Test]
1257                 public void ParametersAndViewChangedEvent_MatchOldInsert ()
1258                 {
1259                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1260                         Hashtable keys = null;
1261                         Hashtable old_values = null;
1262                         Hashtable new_values = null;
1263                         InitializeView (view, InitViewType.MatchParamsToOldValues, out keys, out old_values, out new_values);
1264
1265                         view.Insert (new_values);
1266
1267                         Assert.IsNotNull (eventsCalled, "Events not raized");
1268                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1269                         Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
1270                         Assert.AreEqual ("Insert(ID = n_1001, oldvalue_ID = p_OldValueInsert1)", eventsCalled [1], "DataSource Method params");
1271                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1272                 }
1273
1274                 [Test]
1275                 public void ParametersAndViewChangedEvent_DontMatchInsert ()
1276                 {
1277                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1278                         Hashtable keys = null;
1279                         Hashtable old_values = null;
1280                         Hashtable new_values = null;
1281                         InitializeView (view, InitViewType.DontMatchParams, out keys, out old_values, out new_values);
1282
1283                         view.Insert (new_values);
1284
1285                         Assert.IsNotNull (eventsCalled, "Events not raized");
1286                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1287                         Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
1288                         Assert.AreEqual ("InsertOther(ID = n_1001, OtherValue = p_OtherValueInsert1)", eventsCalled [1], "DataSource Method params");
1289                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1290                 }
1291
1292                 [Test]
1293                 public void ParametersAndViewChangedEvent_MatchUpdate ()
1294                 {
1295                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1296                         Hashtable keys = null;
1297                         Hashtable old_values = null;
1298                         Hashtable new_values = null;
1299                         InitializeView (view, InitViewType.MatchParamsToValues, out keys, out old_values, out new_values);
1300
1301                         view.Update (keys, new_values, old_values);
1302
1303                         Assert.IsNotNull (eventsCalled, "Events not raized");
1304                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1305                         Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
1306                         Assert.AreEqual ("Update(ID = n_1001, oldvalue_ID = k_1001)", eventsCalled [1], "DataSource Method params");
1307                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1308                 }
1309
1310                 [Test]
1311                 public void ParametersAndViewChangedEvent_MatchOldUpdate ()
1312                 {
1313                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1314                         Hashtable keys = null;
1315                         Hashtable old_values = null;
1316                         Hashtable new_values = null;
1317                         InitializeView (view, InitViewType.MatchParamsToOldValues, out keys, out old_values, out new_values);
1318
1319                         view.Update (keys, new_values, old_values);
1320
1321                         Assert.IsNotNull (eventsCalled, "Events not raized");
1322                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1323                         Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
1324                         Assert.AreEqual ("Update(ID = n_1001, oldvalue_ID = k_1001)", eventsCalled [1], "DataSource Method params");
1325                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1326                 }
1327
1328                 [Test]
1329                 public void ParametersAndViewChangedEvent_DontMatchUpdate ()
1330                 {
1331                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1332                         Hashtable keys = null;
1333                         Hashtable old_values = null;
1334                         Hashtable new_values = null;
1335                         InitializeView (view, InitViewType.DontMatchParams, out keys, out old_values, out new_values);
1336
1337                         view.Update (keys, new_values, old_values);
1338
1339                         Assert.IsNotNull (eventsCalled, "Events not raized");
1340                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1341                         Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
1342                         Assert.AreEqual ("UpdateOther(ID = n_1001, OtherValue = p_OtherValueUpdate1, oldvalue_ID = k_1001)", eventsCalled [1], "DataSource Method params");
1343                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1344                 }
1345
1346                 [Test]
1347                 public void ParametersAndViewChangedEvent_MatchDelete ()
1348                 {
1349                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1350                         Hashtable keys = null;
1351                         Hashtable old_values = null;
1352                         Hashtable new_values = null;
1353                         InitializeView (view, InitViewType.MatchParamsToValues, out keys, out old_values, out new_values);
1354
1355                         view.Delete (keys, old_values);
1356
1357                         Assert.IsNotNull (eventsCalled, "Events not raized");
1358                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1359                         Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
1360                         Assert.AreEqual ("Delete(ID = p_ValueDelete1, oldvalue_ID = k_1001)", eventsCalled [1], "DataSource Method params");
1361                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1362                 }
1363
1364                 [Test]
1365                 public void ParametersAndViewChangedEvent_MatchOldDelete ()
1366                 {
1367                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1368                         Hashtable keys = null;
1369                         Hashtable old_values = null;
1370                         Hashtable new_values = null;
1371                         InitializeView (view, InitViewType.MatchParamsToOldValues, out keys, out old_values, out new_values);
1372
1373                         view.Delete (keys, old_values);
1374
1375                         Assert.IsNotNull (eventsCalled, "Events not raized");
1376                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1377                         Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
1378                         Assert.AreEqual ("Delete(oldvalue_ID = k_1001)", eventsCalled [1], "DataSource Method params");
1379                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1380                 }
1381
1382                 [Test]
1383                 public void ParametersAndViewChangedEvent_DontMatchDelete ()
1384                 {
1385                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1386                         Hashtable keys = null;
1387                         Hashtable old_values = null;
1388                         Hashtable new_values = null;
1389                         InitializeView (view, InitViewType.DontMatchParams, out keys, out old_values, out new_values);
1390
1391                         view.Delete (keys, old_values);
1392
1393                         Assert.IsNotNull (eventsCalled, "Events not raized");
1394                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1395                         Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
1396                         Assert.AreEqual ("DeleteOther(oldvalue_ID = k_1001, OtherValue = p_OtherValueDelete1)", eventsCalled [1], "DataSource Method params");
1397                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1398                 }
1399
1400                 /// <summary>
1401                 /// Helper methods
1402                 /// </summary>
1403
1404                 private static bool event_checker;
1405
1406                 private static void Eventassert (string message)
1407                 {
1408                         Assert.IsTrue (ObjectDataSourceViewTest.event_checker, message);
1409                         ObjectDataSourceViewTest.event_checker = false;
1410                 }
1411
1412                 static void Event (object sender, ObjectDataSourceMethodEventArgs e)
1413                 {
1414                         ObjectDataSourceViewTest.event_checker = true;
1415                 }
1416
1417                 static void view_Selecting (object sender, ObjectDataSourceSelectingEventArgs e)
1418                 {
1419                         event_checker = true;
1420                 }
1421
1422                 void view_Filtering (object sender, ObjectDataSourceFilteringEventArgs e)
1423                 {
1424                         event_checker = true;
1425                 }
1426
1427                 void view_ObjectCreate (object sender, ObjectDataSourceEventArgs e)
1428                 {
1429                         event_checker = true;
1430                 }
1431
1432                 void view_Status (object sender, ObjectDataSourceStatusEventArgs e)
1433                 {
1434                         event_checker = true;
1435                 }
1436
1437                 void view_ObjectDisposing (object sender, ObjectDataSourceDisposingEventArgs e)
1438                 {
1439                         event_checker = true;
1440                 }
1441
1442                 private class MyDataSource : ObjectDataSource
1443                 {
1444                         public DataSourceView DoGetView (string viewName)
1445                         {
1446                                 return base.GetView (viewName);
1447                         }
1448
1449                         public void DoTrackViewState ()
1450                         {
1451                                 base.TrackViewState ();
1452                         }
1453                 }
1454         }
1455
1456         public class MyCustomDataObject
1457         {
1458         }
1459
1460         public class DataSourceObject
1461         {
1462                 private static int maximumRows;
1463                 public static DataTable ds = CreateDataTable ();
1464                 public static void InitDS ()
1465                 {
1466                         ds = CreateDataTable ();
1467                 }
1468                 public static DataTable Select ()
1469                 {
1470                         return ds;
1471                 }
1472
1473                 public static MyCustomDataObject SelectObject ()
1474                 {
1475                         return new MyCustomDataObject ();
1476                 }
1477
1478                 [Sys.ComponentModel.DataObjectMethod(Sys.ComponentModel.DataObjectMethodType.Select, false)]
1479                 public static DataTable Select (int maximumRows, short startRowIndex) {
1480                         Assert.Fail ("Should not be called since not default Select DataObjectMethod");
1481                         return null;
1482                 }
1483
1484                 [Sys.ComponentModel.DataObjectMethod(Sys.ComponentModel.DataObjectMethodType.Select, true)]
1485                 public static DataTable Select (int maximumRows, int startRowIndex)
1486                 {
1487                         DataSourceObject.maximumRows = maximumRows;
1488                         if (ds.Rows.Count > maximumRows) {
1489                                 DataTable temp = ds.Clone ();
1490                                 int i = 0;
1491                                 while (i < maximumRows && startRowIndex <= ds.Rows.Count) {
1492                                         object[] o = ds.Rows[startRowIndex].ItemArray;
1493                                         temp.Rows.Add (o);
1494                                         i++;
1495                                         startRowIndex++;
1496                                 }
1497                                 return temp;
1498                         }
1499                         return ds;
1500                 }
1501
1502                 public static DataTable Delete (string ID, string FName, string LName)
1503                 {
1504                         DataRow dr = ds.Rows.Find (ID);
1505                         if (dr != null) {
1506                                 ds.Rows.Remove (dr);
1507                         }
1508                         return ds;
1509                 }
1510
1511                 public static DataTable Insert (string ID, string FName, string LName)
1512                 {
1513                         DataRow dr = ds.NewRow ();
1514                         dr["ID"] = ID;
1515                         dr["FName"] = FName;
1516                         dr["LName"] = LName;
1517                         ds.Rows.Add (dr);
1518                         return ds;
1519                 }
1520
1521                 public static DataTable Update (string ID, string FName, string LName)
1522                 {
1523                         foreach (DataRow row in ds.Rows) {
1524                                 if (row["ID"].ToString () == ID) {
1525                                         row["FName"] = FName;
1526                                         row["LName"] = LName;
1527                                 }
1528                         }
1529                         return ds;
1530                 }
1531
1532
1533                 public static int SelectCount ()
1534                 {
1535
1536                         //Note: This is return 5 only for test goal
1537                         return 5;
1538                 }
1539
1540                 public static DataTable CreateDataTable ()
1541                 {
1542                         DataTable aTable = new DataTable ("A");
1543                         DataColumn dtCol;
1544                         DataRow dtRow;
1545
1546                         // Create ID column and add to the DataTable.
1547                         dtCol = new DataColumn ();
1548                         dtCol.DataType = Type.GetType ("System.Int32");
1549                         dtCol.ColumnName = "ID";
1550                         dtCol.AutoIncrement = true;
1551                         dtCol.Caption = "ID";
1552                         dtCol.ReadOnly = true;
1553                         dtCol.Unique = true;
1554                         aTable.Columns.Add (dtCol);
1555
1556                         // Create Name column and add to the table
1557                         dtCol = new DataColumn ();
1558                         dtCol.DataType = Type.GetType ("System.String");
1559                         dtCol.ColumnName = "FName";
1560                         dtCol.AutoIncrement = false;
1561                         dtCol.Caption = "First Name";
1562                         dtCol.ReadOnly = false;
1563                         dtCol.Unique = false;
1564                         aTable.Columns.Add (dtCol);
1565
1566                         // Create Last Name column and add to the table.
1567                         dtCol = new DataColumn ();
1568                         dtCol.DataType = Type.GetType ("System.String");
1569                         dtCol.ColumnName = "LName";
1570                         dtCol.AutoIncrement = false;
1571                         dtCol.Caption = "Last Name";
1572                         dtCol.ReadOnly = false;
1573                         dtCol.Unique = false;
1574                         aTable.Columns.Add (dtCol);
1575
1576                         // Create three rows to the table
1577                         dtRow = aTable.NewRow ();
1578                         dtRow["ID"] = 1001;
1579                         dtRow["FName"] = "Mahesh";
1580                         dtRow["LName"] = "Chand";
1581                         aTable.Rows.Add (dtRow);
1582
1583                         aTable.PrimaryKey = new DataColumn[] { aTable.Columns["ID"] };
1584                         return aTable;
1585                 }
1586         }
1587 }
1588