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