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>\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                         string renderedHtml = HtmlDiff.GetControlFromPageHtml (html);
 510                         HtmlDiff.AssertAreEqual (origin, renderedHtml, "ObjectDataSourceViewSelect");
 511                 }
 512
 513                 public static void select (Page p)
 514                 {
 515                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
 516                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
 517                         ObjectDataSourceView view;
 518                         GridView grid = new GridView ();
 519                         MyDataSource ds = new MyDataSource ();
 520                         ds.ID = "ObjectDataSource2";
 521                         ds.TypeName = "MonoTests.System.Web.UI.WebControls.DataSourceObject";
 522                         ds.SelectMethod = "Select";
 523
 524                         grid.ID = "Grid";
 525                         grid.DataKeyNames = new string[] { "ID" };
 526                         grid.DataSourceID = "ObjectDataSource2";
 527                         p.Form.Controls.Add (lcb);
 528                         p.Form.Controls.Add (ds);
 529                         p.Form.Controls.Add (grid);
 530                         p.Form.Controls.Add (lce);
 531                         view = (ObjectDataSourceView) ds.DoGetView ("DefaultView");
 532                         view.Selecting += new ObjectDataSourceSelectingEventHandler (view_Selecting);
 533
 534                         DataSourceObject.InitDS ();
 535
 536                         DataView view1 = (DataView) view.Select (new DataSourceSelectArguments ());
 537                         Assert.AreEqual (1, view1.Count, "SelectedRowsCount");
 538                         Assert.AreEqual (1001, view1[0].Row["ID"], "SelectedRowsValue#1");
 539                         Assert.AreEqual ("Mahesh", view1[0].Row["FName"], "SelectedRowsValue#2");
 540                         Assert.AreEqual ("Chand", view1[0].Row["LName"], "SelectedRowsValue#3");
 541                         ObjectDataSourceViewTest.Eventassert ("Select event has not fired");
 542                 }
 543
 544                 [Test]
 545                 [Category ("NunitWeb")]
 546                 public void SelectCountMethod ()
 547                 {
 548                         // This method will render grid view with paging
 549                         // Note : ObjectDataSource will return page counter 5 hard coded
 550                         WebTest t = new WebTest (PageInvoker.CreateOnLoad (selectcount));
 551                         string html = t.Run ();
 552                         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>";
 553                         string renderedHtml = HtmlDiff.GetControlFromPageHtml (html);
 554                         HtmlDiff.AssertAreEqual (origin, renderedHtml, "ObjectDataSourceViewSelectCount");
 555                 }
 556
 557                 public static void selectcount (Page p)
 558                 {
 559                         // This method will render grid view with paging
 560                         // Note : ObjectDataSource will return page counter 5 hard coded
 561
 562                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
 563                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
 564                         ObjectDataSourceView view;
 565                         GridView grid = new GridView ();
 566                         MyDataSource ds = new MyDataSource ();
 567                         ds.ID = "ObjectDataSource2";
 568                         ds.EnablePaging = true;
 569                         ds.TypeName = "MonoTests.System.Web.UI.WebControls.DataSourceObject";
 570                         ds.SelectMethod = "Select";
 571                         ds.SelectCountMethod = "SelectCount";
 572
 573
 574                         grid.ID = "Grid";
 575                         grid.DataKeyNames = new string[] { "ID" };
 576                         grid.DataSourceID = "ObjectDataSource2";
 577                         grid.AllowPaging = true;
 578                         grid.PageSize = 1;
 579
 580                         p.Form.Controls.Add (lcb);
 581                         p.Form.Controls.Add (ds);
 582                         p.Form.Controls.Add (grid);
 583                         p.Form.Controls.Add (lce);
 584                         view = (ObjectDataSourceView) ds.DoGetView ("DefaultView");
 585                         Assert.IsTrue (view.CanRetrieveTotalRowCount, "CanRetrieveTotalRowCount");
 586                 }
 587
 588
 589                 [Test]
 590                 [Category ("NunitWeb")]
 591                 public void InsertMethod ()
 592                 {
 593                         WebTest t = new WebTest (PageInvoker.CreateOnLoad (insert));
 594                         string html = t.Run ();
 595                         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>";
 596                         string renderedHtml = HtmlDiff.GetControlFromPageHtml (html);
 597                         HtmlDiff.AssertAreEqual (origin, renderedHtml, "ObjectDataSourceViewInsert");
 598                 }
 599
 600                 public static void insert (Page p)
 601                 {
 602                         DataSourceObject.InitDS ();
 603
 604                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
 605                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
 606                         ObjectDataSourceView view;
 607                         GridView grid = new GridView ();
 608                         MyDataSource ds = new MyDataSource ();
 609                         ds.ID = "ObjectDataSource1";
 610                         ds.TypeName = "MonoTests.System.Web.UI.WebControls.DataSourceObject";
 611                         ds.SelectMethod = "Select";
 612                         ds.InsertMethod = "Insert";
 613
 614
 615                         Parameter p1 = new Parameter ("ID", TypeCode.String);
 616                         Parameter p2 = new Parameter ("FName", TypeCode.String);
 617                         Parameter p3 = new Parameter ("LName", TypeCode.String);
 618
 619                         ds.InsertParameters.Add (p1);
 620                         ds.InsertParameters.Add (p2);
 621                         ds.InsertParameters.Add (p3);
 622
 623                         grid.ID = "Grid";
 624                         grid.DataSourceID = "ObjectDataSource1";
 625                         p.Form.Controls.Add (lcb);
 626                         p.Form.Controls.Add (ds);
 627                         p.Form.Controls.Add (grid);
 628                         p.Form.Controls.Add (lce);
 629                         view = (ObjectDataSourceView) ds.DoGetView ("DefaultView");
 630                         view.Inserting += new ObjectDataSourceMethodEventHandler (Event);
 631
 632                         Hashtable table = new Hashtable ();
 633                         table.Add ("ID", "1000");
 634                         table.Add ("FName", "Yonik");
 635                         table.Add ("LName", "Laim");
 636                         view.Insert (table);
 637                         Assert.AreEqual (true, view.CanInsert, "CanInsert");
 638                         Assert.AreEqual ("Insert", view.InsertMethod, "InsertMethod");
 639                         Assert.AreEqual (3, view.InsertParameters.Count, "InsertParameters.Count");
 640                         Assert.AreEqual ("ID", view.InsertParameters[0].Name, "InsertParametersName#1");
 641                         Assert.AreEqual ("FName", view.InsertParameters[1].Name, "InsertParametersName#2");
 642                         Assert.AreEqual ("LName", view.InsertParameters[2].Name, "InsertParametersName#3");
 643                         ObjectDataSourceViewTest.Eventassert ("Insert event has not fired");
 644                 }
 645
 646                 [Test]
 647                 [Category ("NunitWeb")]
 648                 public void UpdateMethod ()
 649                 {
 650                         WebTest t = new WebTest (PageInvoker.CreateOnLoad (update));
 651                         string html = t.Run ();
 652                         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>";
 653                         string renderedHtml = HtmlDiff.GetControlFromPageHtml (html);
 654                         HtmlDiff.AssertAreEqual (origin, renderedHtml, "ObjectDataSourceViewUpdate");
 655                 }
 656
 657                 public static void update (Page p)
 658                 {
 659                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
 660                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
 661                         ObjectDataSourceView view;
 662                         GridView grid = new GridView ();
 663                         MyDataSource ds = new MyDataSource ();
 664                         ds.ID = "ObjectDataSource1";
 665                         ds.TypeName = "MonoTests.System.Web.UI.WebControls.DataSourceObject";
 666
 667                         ds.SelectMethod = "Select";
 668                         ds.DeleteMethod = "Delete";
 669                         ds.InsertMethod = "Insert";
 670                         ds.UpdateMethod = "Update";
 671
 672                         Parameter p1 = new Parameter ("ID", TypeCode.String);
 673                         Parameter p2 = new Parameter ("FName", TypeCode.String);
 674                         Parameter p3 = new Parameter ("LName", TypeCode.String);
 675
 676                         ds.UpdateParameters.Add (p1);
 677                         ds.UpdateParameters.Add (p2);
 678                         ds.UpdateParameters.Add (p3);
 679
 680                         grid.ID = "Grid";
 681                         grid.DataSourceID = "ObjectDataSource1";
 682                         p.Form.Controls.Add (lcb);
 683                         p.Form.Controls.Add (ds);
 684                         p.Form.Controls.Add (grid);
 685                         p.Form.Controls.Add (lce);
 686                         view = (ObjectDataSourceView) ds.DoGetView ("defaultView");
 687                         view.Updating += new ObjectDataSourceMethodEventHandler (Event);
 688
 689                         DataSourceObject.InitDS ();
 690
 691                         Hashtable table = new Hashtable ();
 692                         table.Add ("ID", "1001");
 693                         table.Add ("FName", "Yonik");
 694                         table.Add ("LName", "Laim");
 695                         view.Update (null, table, null);
 696                         Assert.AreEqual (true, view.CanUpdate, "CanUpdate");
 697                         Assert.AreEqual ("Update", view.UpdateMethod, "UpdateMethod");
 698                         Assert.AreEqual (3, view.UpdateParameters.Count, "UpdateParameters.Count");
 699                         Assert.AreEqual ("ID", view.UpdateParameters[0].Name, "UpdateParametersName#1");
 700                         Assert.AreEqual ("FName", view.UpdateParameters[1].Name, "UpdateParametersName#2");
 701                         Assert.AreEqual ("LName", view.UpdateParameters[2].Name, "UpdateParametersName#3");
 702                         ObjectDataSourceViewTest.Eventassert ("Update event has not fired");
 703                 }
 704
 705
 706                 //Events
 707                 [Test]
 708                 public void UpdateEvent ()
 709                 {
 710                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
 711                         view.Updating += new ObjectDataSourceMethodEventHandler (Event);
 712                         view.DoOnUpdating (new ObjectDataSourceMethodEventArgs (null));
 713                         Eventassert ("UpdateEvent");
 714                         view.Updated += new ObjectDataSourceStatusEventHandler (view_Status);
 715                         view.DoOnUpdated (new ObjectDataSourceStatusEventArgs (null, null));
 716                         Eventassert ("UpdateEvent");
 717                 }
 718
 719                 [Test]
 720                 public void SelectEvent ()
 721                 {
 722                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
 723                         view.Selecting += new ObjectDataSourceSelectingEventHandler (view_Selecting);
 724                         view.DoOnSelecting (new ObjectDataSourceSelectingEventArgs (null, new DataSourceSelectArguments (), false));
 725                         Eventassert ("SelectingEvent");
 726                         view.Selected += new ObjectDataSourceStatusEventHandler (view_Status);
 727                         view.DoOnSelected (new ObjectDataSourceStatusEventArgs (null, null));
 728                         Eventassert ("SelectedEvent");
 729                 }
 730
 731                 [Test]
 732                 public void InsertEvent ()
 733                 {
 734                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
 735                         view.Inserting += new ObjectDataSourceMethodEventHandler (Event);
 736                         view.DoOnInserting (new ObjectDataSourceMethodEventArgs (null));
 737                         Eventassert ("InsertingEvent");
 738                         view.Inserted += new ObjectDataSourceStatusEventHandler (view_Status);
 739                         view.DoOnInserted (new ObjectDataSourceStatusEventArgs (null, null));
 740                         Eventassert ("InsertedEvent");
 741                 }
 742
 743                 [Test]
 744                 public void DeleteEvent ()
 745                 {
 746                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
 747                         view.Deleting += new ObjectDataSourceMethodEventHandler (Event);
 748                         view.DoOnDeleting (new ObjectDataSourceMethodEventArgs (null));
 749                         Eventassert ("DeletingEvent");
 750                         view.Deleted += new ObjectDataSourceStatusEventHandler (view_Status);
 751                         view.DoOnDeleted (new ObjectDataSourceStatusEventArgs (null, null));
 752                         Eventassert ("DeletedEvent");
 753                 }
 754
 755                 [Test]
 756                 public void FilterEvent ()
 757                 {
 758                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
 759                         view.Filtering += new ObjectDataSourceFilteringEventHandler (view_Filtering);
 760                         view.DoOnFiltering (new ObjectDataSourceFilteringEventArgs (null));
 761                         Eventassert ("FilterEvent");
 762                 }
 763
 764                 [Test]
 765                 public void ObjectCreatingEvent ()
 766                 {
 767                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
 768                         view.ObjectCreating += new ObjectDataSourceObjectEventHandler (view_ObjectCreate);
 769                         view.DoOnObjectCreating (new ObjectDataSourceEventArgs (null));
 770                         Eventassert ("ObjectCreatingEvent");
 771                         view.ObjectCreated += new ObjectDataSourceObjectEventHandler (view_ObjectCreate);
 772                         view.DoOnObjectCreated (new ObjectDataSourceEventArgs (null));
 773                         Eventassert ("ObjectCreatedEvent");
 774                         view.ObjectDisposing += new ObjectDataSourceDisposingEventHandler (view_ObjectDisposing);
 775                 }
 776
 777                 [Test]
 778                 public void ObjectDisposing ()
 779                 {
 780                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
 781                         view.ObjectDisposing += new ObjectDataSourceDisposingEventHandler (view_ObjectDisposing);
 782                         view.DoOnObjectDisposing (new ObjectDataSourceDisposingEventArgs (null));
 783                         Eventassert ("ObjectDisposing");
 784                 }
 785
 786                 IEnumerable returnedData;
 787                 void SelectCallback (IEnumerable data)
 788                 {
 789                         returnedData = data;
 790                 }
 791
 792                 [Test] // bug #471767
 793                 public void SelectReturnsObjectArray ()
 794                 {
 795                         ObjectDataSource ds = new ObjectDataSource ();
 796                         ds.TypeName=typeof(DataSourceObject).AssemblyQualifiedName;
 797                         ds.SelectMethod="SelectObject";
 798
 799                         DataSourceView dsv = ((IDataSource)ds).GetView (String.Empty);
 800                         dsv.Select (DataSourceSelectArguments.Empty, new DataSourceViewSelectCallback (SelectCallback));
 801                         Assert.IsTrue (returnedData != null, "#A1");
 802                         Assert.AreEqual (typeof (object[]), returnedData.GetType (), "#A2");
 803
 804                         object[] data = returnedData as object[];
 805                         Assert.AreEqual (1, data.Length, "#A3");
 806                         Assert.AreEqual (typeof (MyCustomDataObject), data [0].GetType (), "#A4");
 807                 }
 808
 809                 enum InitViewType
 810                 {
 811                         MatchParamsToValues,
 812                         MatchParamsToOldValues,
 813                         DontMatchParams,
 814                 }
 815
 816                 public class DummyDataSourceObject
 817                 {
 818                         public static IEnumerable Select (string filter)
 819                         {
 820                                 if (eventsCalled == null) {
 821                                         eventsCalled = new ArrayList ();
 822                                 }
 823                                 eventsCalled.Add (String.Format ("Select(filter = {0})", filter));
 824                                 return new string [] { "one", "two", "three" };
 825                         }
 826
 827                         public static int Update (string ID)
 828                         {
 829                                 if (eventsCalled == null) {
 830                                         eventsCalled = new ArrayList ();
 831                                 }
 832                                 eventsCalled.Add (String.Format ("Update(ID = {0})", ID));
 833                                 return 1;
 834                         }
 835
 836                         public static int Update (string ID, string oldvalue_ID)
 837                         {
 838                                 if (eventsCalled == null) {
 839                                         eventsCalled = new ArrayList ();
 840                                 }
 841                                 eventsCalled.Add (String.Format ("Update(ID = {0}, oldvalue_ID = {1})", ID, oldvalue_ID));
 842                                 return 1;
 843                         }
 844
 845                         public static int UpdateOther (string ID, string OtherValue, string oldvalue_ID)
 846                         {
 847                                 if (eventsCalled == null) {
 848                                         eventsCalled = new ArrayList ();
 849                                 }
 850                                 eventsCalled.Add (String.Format ("UpdateOther(ID = {0}, OtherValue = {1}, oldvalue_ID = {2})", ID, OtherValue, oldvalue_ID));
 851                                 return 1;
 852                         }
 853
 854                         public static int Insert (string ID)
 855                         {
 856                                 if (eventsCalled == null) {
 857                                         eventsCalled = new ArrayList ();
 858                                 }
 859                                 eventsCalled.Add (String.Format ("Insert(ID = {0})", ID));
 860                                 return 1;
 861                         }
 862
 863                         public static int Insert (string ID, string oldvalue_ID)
 864                         {
 865                                 if (eventsCalled == null) {
 866                                         eventsCalled = new ArrayList ();
 867                                 }
 868                                 eventsCalled.Add (String.Format ("Insert(ID = {0}, oldvalue_ID = {1})", ID, oldvalue_ID));
 869                                 return 1;
 870                         }
 871
 872                         public static int InsertOther (string ID, string OtherValue)
 873                         {
 874                                 if (eventsCalled == null) {
 875                                         eventsCalled = new ArrayList ();
 876                                 }
 877                                 eventsCalled.Add (String.Format ("InsertOther(ID = {0}, OtherValue = {1})", ID, OtherValue));
 878                                 return 1;
 879                         }
 880
 881                         public static int Delete (string ID, string oldvalue_ID)
 882                         {
 883                                 if (eventsCalled == null) {
 884                                         eventsCalled = new ArrayList ();
 885                                 }
 886                                 eventsCalled.Add (String.Format ("Delete(ID = {0}, oldvalue_ID = {1})", ID, oldvalue_ID));
 887                                 return 1;
 888                         }
 889
 890                         public static int Delete (string oldvalue_ID)
 891                         {
 892                                 if (eventsCalled == null) {
 893                                         eventsCalled = new ArrayList ();
 894                                 }
 895                                 eventsCalled.Add (String.Format ("Delete(oldvalue_ID = {0})", oldvalue_ID));
 896                                 return 1;
 897                         }
 898
 899                         public static int DeleteOther (string oldvalue_ID, string OtherValue)
 900                         {
 901                                 if (eventsCalled == null) {
 902                                         eventsCalled = new ArrayList ();
 903                                 }
 904                                 eventsCalled.Add (String.Format ("DeleteOther(oldvalue_ID = {0}, OtherValue = {1})", oldvalue_ID, OtherValue));
 905                                 return 1;
 906                         }
 907                 }
 908
 909                 public class AlwaysChangingParameter : Parameter
 910                 {
 911                         int evaluateCount;
 912
 913                         public AlwaysChangingParameter (string name, TypeCode type, string defaultValue)
 914                                 : base (name, type, defaultValue)
 915                         {
 916                                 evaluateCount = 0;
 917                         }
 918
 919                         protected override object Evaluate (HttpContext context, Control control)
 920                         {
 921                                 evaluateCount++;
 922                                 return String.Format ("{0}{1}", DefaultValue, evaluateCount);
 923                         }
 924                 }
 925
 926                 #region help_results
 927                 class eventAssert
 928                 {
 929                         private static int _testcounter;
 930                         private static bool _eventChecker;
 931                         private eventAssert ()
 932                         {
 933                                 _testcounter = 0;
 934                         }
 935
 936                         public static bool eventChecker
 937                         {
 938                                 get
 939                                 {
 940                                         throw new NotImplementedException ();
 941                                 }
 942                                 set
 943                                 {
 944                                         _eventChecker = value;
 945                                 }
 946                         }
 947
 948                         static private void testAdded ()
 949                         {
 950                                 _testcounter++;
 951                                 _eventChecker = false;
 952                         }
 953
 954                         public static void IsTrue (string msg)
 955                         {
 956                                 Assert.IsTrue (_eventChecker, msg + "#" + _testcounter);
 957                                 testAdded ();
 958
 959                         }
 960
 961                         public static void IsFalse (string msg)
 962                         {
 963                                 Assert.IsFalse (_eventChecker, msg + "#" + _testcounter);
 964                                 testAdded ();
 965                         }
 966                 }
 967                 #endregion
 968
 969                 [Test]
 970                 public void ObjectDataSourceView_DataSourceViewChanged ()
 971                 {
 972                         ObjectDataSource ds = new ObjectDataSource ();
 973                         ObjectViewPoker sql = new ObjectViewPoker (ds, "DefaultView", null);
 974                         sql.DataSourceViewChanged += new EventHandler (sql_DataSourceViewChanged);
 975
 976                         sql.DoOnDataSourceViewChanged ();
 977                         eventAssert.IsTrue ("DataSourceViewChanged");
 978
 979                         sql.ConflictDetection = ConflictOptions.CompareAllValues;
 980                         eventAssert.IsTrue ("DataSourceViewChanged");
 981
 982                         sql.ConvertNullToDBNull = true;
 983                         eventAssert.IsFalse ("DataSourceViewChanged");
 984
 985                         sql.DataObjectTypeName = "test";
 986                         eventAssert.IsTrue ("DataSourceViewChanged");
 987
 988                         sql.DeleteMethod = "test";
 989                         eventAssert.IsFalse ("DataSourceViewChanged");
 990
 991                         sql.EnablePaging = true;
 992                         eventAssert.IsTrue ("DataSourceViewChanged");
 993
 994                         sql.InsertMethod = "test";
 995                         eventAssert.IsFalse ("DataSourceViewChanged");
 996
 997                         sql.FilterExpression = "test";
 998                         eventAssert.IsTrue ("DataSourceViewChanged");
 999
1000                         sql.MaximumRowsParameterName = "test";
1001                         eventAssert.IsTrue ("DataSourceViewChanged");
1002
1003                         sql.SelectCountMethod = "test";
1004                         eventAssert.IsTrue ("DataSourceViewChanged");
1005
1006                         sql.SelectMethod = "test";
1007                         eventAssert.IsTrue ("DataSourceViewChanged");
1008
1009                         sql.OldValuesParameterFormatString = "test";
1010                         eventAssert.IsTrue ("DataSourceViewChanged");
1011
1012                         sql.StartRowIndexParameterName = "test";
1013                         eventAssert.IsTrue ("DataSourceViewChanged");
1014
1015                         sql.TypeName = "test";
1016                         eventAssert.IsTrue ("DataSourceViewChanged");
1017
1018                         sql.UpdateMethod = "test";
1019                         eventAssert.IsFalse ("DataSourceViewChanged");
1020                 }
1021
1022                 void sql_DataSourceViewChanged (object sender, EventArgs e)
1023                 {
1024                         eventAssert.eventChecker = true;
1025                 }
1026
1027                 [Test]
1028                 public void SelectCountMethod_DataSourceViewChanged ()
1029                 {
1030                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1031                         view.DataSourceViewChanged += new EventHandler (view_DataSourceViewChanged);
1032
1033                         Assert.AreEqual ("", view.SelectCountMethod);
1034                         view.SelectCountMethod = null;
1035                         Assert.AreEqual (1, eventsCalled.Count);
1036                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [0]);
1037                         Assert.AreEqual ("", view.SelectCountMethod);
1038
1039                         view.SelectCountMethod = null;
1040                         Assert.AreEqual (2, eventsCalled.Count);
1041                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [1]);
1042                         Assert.AreEqual ("", view.SelectCountMethod);
1043
1044                         view.SelectCountMethod = "";
1045                         Assert.AreEqual (2, eventsCalled.Count);
1046                 }
1047
1048                 [Test]
1049                 public void SelectMethod_DataSourceViewChanged2 ()
1050                 {
1051                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1052                         view.DataSourceViewChanged += new EventHandler (view_DataSourceViewChanged);
1053
1054                         Assert.AreEqual ("", view.SelectMethod);
1055                         view.SelectMethod = null;
1056                         Assert.AreEqual (1, eventsCalled.Count);
1057                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [0]);
1058                         Assert.AreEqual ("", view.SelectMethod);
1059
1060                         view.SelectMethod = null;
1061                         Assert.AreEqual (2, eventsCalled.Count);
1062                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [1]);
1063                         Assert.AreEqual ("", view.SelectMethod);
1064
1065                         view.SelectMethod = "";
1066                         Assert.AreEqual (2, eventsCalled.Count);
1067                 }
1068
1069                 [Test]
1070                 public void SelectMethod_DataSourceViewChanged1 ()
1071                 {
1072                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1073                         view.DataSourceViewChanged+=new EventHandler(view_DataSourceViewChanged);
1074
1075                         view.SelectMethod = "select_1";
1076                         Assert.AreEqual (1, eventsCalled.Count);
1077                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [0]);
1078
1079                         view.SelectMethod = "select_2";
1080                         Assert.AreEqual (2, eventsCalled.Count);
1081                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [1]);
1082
1083                         view.SelectMethod = "select_2";
1084                         Assert.AreEqual (2, eventsCalled.Count);
1085
1086                         view.SelectCountMethod = "selectCount_1";
1087                         Assert.AreEqual (3, eventsCalled.Count);
1088                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2]);
1089
1090                         view.SelectCountMethod = "selectCount_2";
1091                         Assert.AreEqual (4, eventsCalled.Count);
1092                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [3]);
1093
1094                         view.SelectCountMethod = "selectCount_2";
1095                         Assert.AreEqual (4, eventsCalled.Count);
1096                 }
1097
1098                 private static void InitializeView (ObjectViewPoker view, InitViewType initType, out Hashtable keys, out Hashtable old_value, out Hashtable new_value)
1099                 {
1100                         view.TypeName = typeof (DummyDataSourceObject).AssemblyQualifiedName;
1101                         view.OldValuesParameterFormatString = "oldvalue_{0}";
1102                         view.SelectMethod = "Select";
1103                         if (initType == InitViewType.DontMatchParams) {
1104                                 view.UpdateMethod = "UpdateOther";
1105                                 view.InsertMethod = "InsertOther";
1106                                 view.DeleteMethod = "DeleteOther";
1107                         }
1108                         else {
1109                                 view.UpdateMethod = "Update";
1110                                 view.InsertMethod = "Insert";
1111                                 view.DeleteMethod = "Delete";
1112                         }
1113
1114                         Parameter selectParameter = null;
1115                         Parameter insertParameter = null;
1116                         Parameter updateParameter = null;
1117                         Parameter deleteParameter = null;
1118
1119                         selectParameter = new AlwaysChangingParameter ("filter", TypeCode.String, "p_ValueSelect");
1120                         view.SelectParameters.Add (selectParameter);
1121
1122                         switch (initType) {
1123                         case InitViewType.MatchParamsToOldValues:
1124                                 insertParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueInsert");
1125                                 view.InsertParameters.Add (insertParameter);
1126                                 updateParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueUpdate");
1127                                 view.UpdateParameters.Add (updateParameter);
1128                                 deleteParameter = new AlwaysChangingParameter ("oldvalue_ID", TypeCode.String, "p_OldValueDelete");
1129                                 view.DeleteParameters.Add (deleteParameter);
1130                                 break;
1131
1132                         case InitViewType.MatchParamsToValues:
1133                                 insertParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueInsert");
1134                                 view.InsertParameters.Add (insertParameter);
1135                                 updateParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueUpdate");
1136                                 view.UpdateParameters.Add (updateParameter);
1137                                 deleteParameter = new AlwaysChangingParameter ("ID", TypeCode.String, "p_ValueDelete");
1138                                 view.DeleteParameters.Add (deleteParameter);
1139                                 break;
1140
1141                         case InitViewType.DontMatchParams:
1142                                 insertParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueInsert");
1143                                 view.InsertParameters.Add (insertParameter);
1144                                 updateParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueUpdate");
1145                                 view.UpdateParameters.Add (updateParameter);
1146                                 deleteParameter = new AlwaysChangingParameter ("OtherValue", TypeCode.String, "p_OtherValueDelete");
1147                                 view.DeleteParameters.Add (deleteParameter);
1148                                 break;
1149                         }
1150
1151                         view.SelectParameters.ParametersChanged += new EventHandler (SelectParameters_ParametersChanged);
1152                         view.InsertParameters.ParametersChanged += new EventHandler (InsertParameters_ParametersChanged);
1153                         view.UpdateParameters.ParametersChanged += new EventHandler (UpdateParameters_ParametersChanged);
1154                         view.DeleteParameters.ParametersChanged += new EventHandler (DeleteParameters_ParametersChanged);
1155
1156                         keys = new Hashtable ();
1157                         keys.Add ("ID", "k_1001");
1158
1159                         old_value = new Hashtable ();
1160                         old_value.Add ("ID", "ov_1001");
1161
1162                         new_value = new Hashtable ();
1163                         new_value.Add ("ID", "n_1001");
1164
1165                         view.DataSourceViewChanged += new EventHandler (view_DataSourceViewChanged);
1166                 }
1167
1168                 private static IList eventsCalled;
1169
1170                 static void view_DataSourceViewChanged (object sender, EventArgs e)
1171                 {
1172                         if (eventsCalled == null) {
1173                                 eventsCalled = new ArrayList ();
1174                         }
1175                         eventsCalled.Add ("view_DataSourceViewChanged");
1176                 }
1177
1178                 static void SelectParameters_ParametersChanged (object sender, EventArgs e)
1179                 {
1180                         if (eventsCalled == null) {
1181                                 eventsCalled = new ArrayList ();
1182                         }
1183                         eventsCalled.Add ("SelectParameters_ParametersChanged");
1184                 }
1185
1186                 static void InsertParameters_ParametersChanged (object sender, EventArgs e)
1187                 {
1188                         if (eventsCalled == null) {
1189                                 eventsCalled = new ArrayList ();
1190                         }
1191                         eventsCalled.Add ("InsertParameters_ParametersChanged");
1192                 }
1193
1194                 static void UpdateParameters_ParametersChanged (object sender, EventArgs e)
1195                 {
1196                         if (eventsCalled == null) {
1197                                 eventsCalled = new ArrayList ();
1198                         }
1199                         eventsCalled.Add ("UpdateParameters_ParametersChanged");
1200                 }
1201
1202                 static void DeleteParameters_ParametersChanged (object sender, EventArgs e)
1203                 {
1204                         if (eventsCalled == null) {
1205                                 eventsCalled = new ArrayList ();
1206                         }
1207                         eventsCalled.Add ("DeleteParameters_ParametersChanged");
1208                 }
1209
1210                 [Test]
1211                 public void ParametersAndViewChangedEvent_Select ()
1212                 {
1213                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1214                         Hashtable keys = null;
1215                         Hashtable old_values = null;
1216                         Hashtable new_values = null;
1217                         InitializeView (view, InitViewType.MatchParamsToValues, out keys, out old_values, out new_values);
1218
1219                         view.Select (DataSourceSelectArguments.Empty);
1220
1221                         Assert.IsNotNull (eventsCalled, "Events not raized");
1222                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1223                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [0], "view_DataSourceViewChanged");
1224                         Assert.AreEqual ("SelectParameters_ParametersChanged", eventsCalled [1], "SelectParameters_ParametersChanged");
1225                         Assert.AreEqual ("Select(filter = p_ValueSelect1)", eventsCalled [2], "DataSource Method params");
1226                 }
1227
1228                 [Test]
1229                 public void ParametersAndViewChangedEvent_MatchInsert ()
1230                 {
1231                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1232                         Hashtable keys = null;
1233                         Hashtable old_values = null;
1234                         Hashtable new_values = null;
1235                         InitializeView (view, InitViewType.MatchParamsToValues, out keys, out old_values, out new_values);
1236
1237                         view.Insert (new_values);
1238
1239                         Assert.IsNotNull (eventsCalled, "Events not raized");
1240                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1241                         Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
1242                         Assert.AreEqual ("Insert(ID = n_1001)", eventsCalled [1], "DataSource Method params");
1243                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1244                 }
1245
1246                 [Test]
1247                 public void ParametersAndViewChangedEvent_MatchOldInsert ()
1248                 {
1249                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1250                         Hashtable keys = null;
1251                         Hashtable old_values = null;
1252                         Hashtable new_values = null;
1253                         InitializeView (view, InitViewType.MatchParamsToOldValues, out keys, out old_values, out new_values);
1254
1255                         view.Insert (new_values);
1256
1257                         Assert.IsNotNull (eventsCalled, "Events not raized");
1258                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1259                         Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
1260                         Assert.AreEqual ("Insert(ID = n_1001, oldvalue_ID = p_OldValueInsert1)", eventsCalled [1], "DataSource Method params");
1261                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1262                 }
1263
1264                 [Test]
1265                 public void ParametersAndViewChangedEvent_DontMatchInsert ()
1266                 {
1267                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1268                         Hashtable keys = null;
1269                         Hashtable old_values = null;
1270                         Hashtable new_values = null;
1271                         InitializeView (view, InitViewType.DontMatchParams, out keys, out old_values, out new_values);
1272
1273                         view.Insert (new_values);
1274
1275                         Assert.IsNotNull (eventsCalled, "Events not raized");
1276                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1277                         Assert.AreEqual ("InsertParameters_ParametersChanged", eventsCalled [0], "InsertParameters_ParametersChanged");
1278                         Assert.AreEqual ("InsertOther(ID = n_1001, OtherValue = p_OtherValueInsert1)", eventsCalled [1], "DataSource Method params");
1279                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1280                 }
1281
1282                 [Test]
1283                 public void ParametersAndViewChangedEvent_MatchUpdate ()
1284                 {
1285                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1286                         Hashtable keys = null;
1287                         Hashtable old_values = null;
1288                         Hashtable new_values = null;
1289                         InitializeView (view, InitViewType.MatchParamsToValues, out keys, out old_values, out new_values);
1290
1291                         view.Update (keys, new_values, old_values);
1292
1293                         Assert.IsNotNull (eventsCalled, "Events not raized");
1294                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1295                         Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
1296                         Assert.AreEqual ("Update(ID = n_1001, oldvalue_ID = k_1001)", eventsCalled [1], "DataSource Method params");
1297                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1298                 }
1299
1300                 [Test]
1301                 public void ParametersAndViewChangedEvent_MatchOldUpdate ()
1302                 {
1303                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1304                         Hashtable keys = null;
1305                         Hashtable old_values = null;
1306                         Hashtable new_values = null;
1307                         InitializeView (view, InitViewType.MatchParamsToOldValues, out keys, out old_values, out new_values);
1308
1309                         view.Update (keys, new_values, old_values);
1310
1311                         Assert.IsNotNull (eventsCalled, "Events not raized");
1312                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1313                         Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
1314                         Assert.AreEqual ("Update(ID = n_1001, oldvalue_ID = k_1001)", eventsCalled [1], "DataSource Method params");
1315                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1316                 }
1317
1318                 [Test]
1319                 public void ParametersAndViewChangedEvent_DontMatchUpdate ()
1320                 {
1321                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1322                         Hashtable keys = null;
1323                         Hashtable old_values = null;
1324                         Hashtable new_values = null;
1325                         InitializeView (view, InitViewType.DontMatchParams, out keys, out old_values, out new_values);
1326
1327                         view.Update (keys, new_values, old_values);
1328
1329                         Assert.IsNotNull (eventsCalled, "Events not raized");
1330                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1331                         Assert.AreEqual ("UpdateParameters_ParametersChanged", eventsCalled [0], "UpdateParameters_ParametersChanged");
1332                         Assert.AreEqual ("UpdateOther(ID = n_1001, OtherValue = p_OtherValueUpdate1, oldvalue_ID = k_1001)", eventsCalled [1], "DataSource Method params");
1333                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1334                 }
1335
1336                 [Test]
1337                 public void ParametersAndViewChangedEvent_MatchDelete ()
1338                 {
1339                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1340                         Hashtable keys = null;
1341                         Hashtable old_values = null;
1342                         Hashtable new_values = null;
1343                         InitializeView (view, InitViewType.MatchParamsToValues, out keys, out old_values, out new_values);
1344
1345                         view.Delete (keys, old_values);
1346
1347                         Assert.IsNotNull (eventsCalled, "Events not raized");
1348                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1349                         Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
1350                         Assert.AreEqual ("Delete(ID = p_ValueDelete1, oldvalue_ID = k_1001)", eventsCalled [1], "DataSource Method params");
1351                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1352                 }
1353
1354                 [Test]
1355                 public void ParametersAndViewChangedEvent_MatchOldDelete ()
1356                 {
1357                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1358                         Hashtable keys = null;
1359                         Hashtable old_values = null;
1360                         Hashtable new_values = null;
1361                         InitializeView (view, InitViewType.MatchParamsToOldValues, out keys, out old_values, out new_values);
1362
1363                         view.Delete (keys, old_values);
1364
1365                         Assert.IsNotNull (eventsCalled, "Events not raized");
1366                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1367                         Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
1368                         Assert.AreEqual ("Delete(oldvalue_ID = k_1001)", eventsCalled [1], "DataSource Method params");
1369                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1370                 }
1371
1372                 [Test]
1373                 public void ParametersAndViewChangedEvent_DontMatchDelete ()
1374                 {
1375                         ObjectViewPoker view = new ObjectViewPoker (new ObjectDataSource (), "", null);
1376                         Hashtable keys = null;
1377                         Hashtable old_values = null;
1378                         Hashtable new_values = null;
1379                         InitializeView (view, InitViewType.DontMatchParams, out keys, out old_values, out new_values);
1380
1381                         view.Delete (keys, old_values);
1382
1383                         Assert.IsNotNull (eventsCalled, "Events not raized");
1384                         Assert.AreEqual (3, eventsCalled.Count, "Events Count");
1385                         Assert.AreEqual ("DeleteParameters_ParametersChanged", eventsCalled [0], "DeleteParameters_ParametersChanged");
1386                         Assert.AreEqual ("DeleteOther(oldvalue_ID = k_1001, OtherValue = p_OtherValueDelete1)", eventsCalled [1], "DataSource Method params");
1387                         Assert.AreEqual ("view_DataSourceViewChanged", eventsCalled [2], "view_DataSourceViewChanged");
1388                 }
1389
1390                 /// <summary>
1391                 /// Helper methods
1392                 /// </summary>
1393
1394                 private static bool event_checker;
1395
1396                 private static void Eventassert (string message)
1397                 {
1398                         Assert.IsTrue (ObjectDataSourceViewTest.event_checker, message);
1399                         ObjectDataSourceViewTest.event_checker = false;
1400                 }
1401
1402                 static void Event (object sender, ObjectDataSourceMethodEventArgs e)
1403                 {
1404                         ObjectDataSourceViewTest.event_checker = true;
1405                 }
1406
1407                 static void view_Selecting (object sender, ObjectDataSourceSelectingEventArgs e)
1408                 {
1409                         event_checker = true;
1410                 }
1411
1412                 void view_Filtering (object sender, ObjectDataSourceFilteringEventArgs e)
1413                 {
1414                         event_checker = true;
1415                 }
1416
1417                 void view_ObjectCreate (object sender, ObjectDataSourceEventArgs e)
1418                 {
1419                         event_checker = true;
1420                 }
1421
1422                 void view_Status (object sender, ObjectDataSourceStatusEventArgs e)
1423                 {
1424                         event_checker = true;
1425                 }
1426
1427                 void view_ObjectDisposing (object sender, ObjectDataSourceDisposingEventArgs e)
1428                 {
1429                         event_checker = true;
1430                 }
1431
1432                 private class MyDataSource : ObjectDataSource
1433                 {
1434                         public DataSourceView DoGetView (string viewName)
1435                         {
1436                                 return base.GetView (viewName);
1437                         }
1438
1439                         public void DoTrackViewState ()
1440                         {
1441                                 base.TrackViewState ();
1442                         }
1443                 }
1444         }
1445
1446         public class MyCustomDataObject
1447         {
1448         }
1449
1450         public class DataSourceObject
1451         {
1452                 private static int maximumRows;
1453                 public static DataTable ds = CreateDataTable ();
1454                 public static void InitDS ()
1455                 {
1456                         ds = CreateDataTable ();
1457                 }
1458                 public static DataTable Select ()
1459                 {
1460                         return ds;
1461                 }
1462
1463                 public static MyCustomDataObject SelectObject ()
1464                 {
1465                         return new MyCustomDataObject ();
1466                 }
1467
1468                 [Sys.ComponentModel.DataObjectMethod(Sys.ComponentModel.DataObjectMethodType.Select, false)]
1469                 public static DataTable Select (int maximumRows, short startRowIndex) {
1470                         Assert.Fail ("Should not be called since not default Select DataObjectMethod");
1471                         return null;
1472                 }
1473
1474                 [Sys.ComponentModel.DataObjectMethod(Sys.ComponentModel.DataObjectMethodType.Select, true)]
1475                 public static DataTable Select (int maximumRows, int startRowIndex)
1476                 {
1477                         DataSourceObject.maximumRows = maximumRows;
1478                         if (ds.Rows.Count > maximumRows) {
1479                                 DataTable temp = ds.Clone ();
1480                                 int i = 0;
1481                                 while (i < maximumRows && startRowIndex <= ds.Rows.Count) {
1482                                         object[] o = ds.Rows[startRowIndex].ItemArray;
1483                                         temp.Rows.Add (o);
1484                                         i++;
1485                                         startRowIndex++;
1486                                 }
1487                                 return temp;
1488                         }
1489                         return ds;
1490                 }
1491
1492                 public static DataTable Delete (string ID, string FName, string LName)
1493                 {
1494                         DataRow dr = ds.Rows.Find (ID);
1495                         if (dr != null) {
1496                                 ds.Rows.Remove (dr);
1497                         }
1498                         return ds;
1499                 }
1500
1501                 public static DataTable Insert (string ID, string FName, string LName)
1502                 {
1503                         DataRow dr = ds.NewRow ();
1504                         dr["ID"] = ID;
1505                         dr["FName"] = FName;
1506                         dr["LName"] = LName;
1507                         ds.Rows.Add (dr);
1508                         return ds;
1509                 }
1510
1511                 public static DataTable Update (string ID, string FName, string LName)
1512                 {
1513                         foreach (DataRow row in ds.Rows) {
1514                                 if (row["ID"].ToString () == ID) {
1515                                         row["FName"] = FName;
1516                                         row["LName"] = LName;
1517                                 }
1518                         }
1519                         return ds;
1520                 }
1521
1522
1523                 public static int SelectCount ()
1524                 {
1525
1526                         //Note: This is return 5 only for test goal
1527                         return 5;
1528                 }
1529
1530                 public static DataTable CreateDataTable ()
1531                 {
1532                         DataTable aTable = new DataTable ("A");
1533                         DataColumn dtCol;
1534                         DataRow dtRow;
1535
1536                         // Create ID column and add to the DataTable.
1537                         dtCol = new DataColumn ();
1538                         dtCol.DataType = Type.GetType ("System.Int32");
1539                         dtCol.ColumnName = "ID";
1540                         dtCol.AutoIncrement = true;
1541                         dtCol.Caption = "ID";
1542                         dtCol.ReadOnly = true;
1543                         dtCol.Unique = true;
1544                         aTable.Columns.Add (dtCol);
1545
1546                         // Create Name column and add to the table
1547                         dtCol = new DataColumn ();
1548                         dtCol.DataType = Type.GetType ("System.String");
1549                         dtCol.ColumnName = "FName";
1550                         dtCol.AutoIncrement = false;
1551                         dtCol.Caption = "First Name";
1552                         dtCol.ReadOnly = false;
1553                         dtCol.Unique = false;
1554                         aTable.Columns.Add (dtCol);
1555
1556                         // Create Last Name column and add to the table.
1557                         dtCol = new DataColumn ();
1558                         dtCol.DataType = Type.GetType ("System.String");
1559                         dtCol.ColumnName = "LName";
1560                         dtCol.AutoIncrement = false;
1561                         dtCol.Caption = "Last Name";
1562                         dtCol.ReadOnly = false;
1563                         dtCol.Unique = false;
1564                         aTable.Columns.Add (dtCol);
1565
1566                         // Create three rows to the table
1567                         dtRow = aTable.NewRow ();
1568                         dtRow["ID"] = 1001;
1569                         dtRow["FName"] = "Mahesh";
1570                         dtRow["LName"] = "Chand";
1571                         aTable.Rows.Add (dtRow);
1572
1573                         aTable.PrimaryKey = new DataColumn[] { aTable.Columns["ID"] };
1574                         return aTable;
1575                 }
1576         }
1577 }
1578
1579 #endif