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

   1 //
   2 // Tests for System.Web.UI.WebControls.FormView.cs
   3 //
   4 // Author:
   5 //      Chris Toshok (toshok@ximian.com)
   6 //
   7
   8 //
   9 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30
  31 #if NET_2_0
  32
  33 using NUnit.Framework;
  34 using System;
  35 using System.Data;
  36 using System.IO;
  37 using System.Drawing;
  38 using System.Collections;
  39 using System.Collections.Generic;
  40 using System.Collections.Specialized;
  41 using System.Globalization;
  42 using System.Web;
  43 using System.Web.UI;
  44 using System.Web.UI.HtmlControls;
  45 using System.Web.UI.WebControls;
  46 using MonoTests.SystemWeb.Framework;
  47 using MonoTests.stand_alone.WebHarness;
  48 using System.Text.RegularExpressions;
  49 using System.Reflection;
  50 using System.Threading;
  51
  52
  53
  54 namespace MonoTests.System.Web.UI.WebControls
  55 {
  56         [TestFixture]
  57         public class FormViewTest {
  58
  59                 public class DataSourceObject
  60                 {
  61                         public static List<string> GetList (string sortExpression, int startRowIndex, int maximumRows) {
  62                                 return GetList ();
  63                         }
  64
  65                         public static List<string> GetList (int startRowIndex, int maximumRows) {
  66                                 return GetList ();
  67                         }
  68
  69                         public static List<string> GetList (string sortExpression) {
  70                                 return GetList ();
  71                         }
  72
  73                         public static List<string> GetList () {
  74                                 List<string> list = new List<string> ();
  75                                 list.Add ("Norway");
  76                                 list.Add ("Sweden");
  77                                 list.Add ("France");
  78                                 list.Add ("Italy");
  79                                 list.Add ("Israel");
  80                                 list.Add ("Russia");
  81                                 return list;
  82                         }
  83
  84                         public static int GetCount () {
  85                                 return GetList ().Count;
  86                         }
  87                 }
  88
  89                 public class DS : ObjectDataSource
  90                 {
  91                         public static List<string> GetList ()
  92                         {
  93                                 List<string> list = new List<string> ();
  94                                 list.Add ("Norway");
  95                                 list.Add ("Sweden");
  96                                 list.Add ("France");
  97                                 list.Add ("Italy");
  98                                 list.Add ("Israel");
  99                                 list.Add ("Russia");
 100                                 return list;
 101                         }
 102
 103                         public void DoRaiseDataSourceChangedEvent (EventArgs e)
 104                         {
 105                                 RaiseDataSourceChangedEvent (e);
 106                         }
 107                 }
 108
 109                 public class Poker : FormView {
 110                         public bool isInitializePager=false;
 111                         public bool ensureDataBound=false;
 112                         public bool controlHierarchy=false;
 113                         bool _onPageIndexChangingCalled = false;
 114                         bool _onPageIndexChangedCalled = false;
 115
 116                         public Poker () {
 117                                 TrackViewState ();
 118                         }
 119
 120                         public object SaveState () {
 121                                 return SaveViewState ();
 122                         }
 123
 124                         public void LoadState (object state) {
 125                                 LoadViewState (state);
 126
 127                         }
 128
 129                         public HtmlTextWriterTag PokerTagKey
 130                         {
 131                                 get { return base.TagKey; }
 132                         }
 133
 134                         public  int DoCreateChildControls (IEnumerable source,bool dataBind)
 135                         {
 136                                 return CreateChildControls (source, dataBind);
 137
 138                         }
 139
 140                         public Style DoCreateControlStyle ()
 141                         {
 142                                 return base.CreateControlStyle ();
 143                         }
 144
 145                         public DataSourceSelectArguments DoCreateDataSourceSelectArguments ()
 146                         {
 147                                 return CreateDataSourceSelectArguments ();
 148                         }
 149
 150                         public DataSourceView DoGetData ()
 151                         {
 152                                 return GetData ();
 153                         }
 154
 155                         public FormViewRow DoCreateRow (int itemIndex,DataControlRowType rowType,DataControlRowState rowState)
 156                         {
 157                                 return CreateRow( itemIndex, rowType,rowState);
 158                         }
 159
 160                         public Table DoCreateTable ()
 161                         {
 162                                 return CreateTable ();
 163                         }
 164
 165                         protected override void EnsureDataBound ()
 166                         {
 167                                 base.EnsureDataBound ();
 168                                 ensureDataBound = true;
 169                         }
 170
 171                         public void DoExtractRowValues (IOrderedDictionary filedValues, bool includeKeys)
 172                         {
 173                                 base.ExtractRowValues (filedValues, includeKeys);
 174
 175                         }
 176
 177                         public bool IsRequiresDataBinding ()
 178                         {
 179                                 return base.RequiresDataBinding;
 180                         }
 181
 182                         protected override void InitializePager (FormViewRow row, PagedDataSource pageData)
 183                         {
 184                                 base.InitializePager (row, pageData);
 185                                 isInitializePager = true;
 186                         }
 187
 188                         public void DoInitializeRow (FormViewRow row)
 189                         {
 190                                 InitializeRow (row);
 191                         }
 192                         public void DoLoadControlState (object savedState)
 193                         {
 194                                 LoadControlState (savedState);
 195                         }
 196
 197                         public void DoLoadViewState (object savedState)
 198                         {
 199                                 LoadViewState (savedState);
 200                         }
 201
 202                         public bool DoOnBubbleEvent (object source, EventArgs e)
 203                         {
 204                                 return OnBubbleEvent (source, e);
 205                         }
 206
 207                         public void DoOnInit (EventArgs e)
 208                         {
 209                                 OnInit (e);
 210                         }
 211
 212                         public void DoOnItemCommand (FormViewCommandEventArgs e)
 213                         {
 214                                 OnItemCommand (e);
 215                         }
 216
 217                         public void DoOnItemCreated (EventArgs e)
 218                         {
 219                                 OnItemCreated (e);
 220                         }
 221
 222                         public void DoOnItemDeleted (FormViewDeletedEventArgs e)
 223                         {
 224                                 OnItemDeleted (e);
 225                         }
 226
 227                         public void DoOnItemDeleting (FormViewDeleteEventArgs e)
 228                         {
 229                                 OnItemDeleting (e);
 230                         }
 231
 232                         public void DoOnItemInserted (FormViewInsertedEventArgs e)
 233                         {
 234                                 OnItemInserted (e);
 235                         }
 236
 237                         public void DoOnItemInserting (FormViewInsertEventArgs e)
 238                         {
 239                                 OnItemInserting (e);
 240                         }
 241
 242                         public void DoOnItemUpdated (FormViewUpdatedEventArgs e)
 243                         {
 244                                 OnItemUpdated (e);
 245                         }
 246
 247                         public void DoOnItemUpdating (FormViewUpdateEventArgs e)
 248                         {
 249                                 OnItemUpdating (e);
 250                         }
 251
 252                         public void DoOnModeChanged (EventArgs e )
 253                         {
 254                                 OnModeChanged (e);
 255                         }
 256
 257                         public void DoOnModeChanging (FormViewModeEventArgs  e)
 258                         {
 259                                 OnModeChanging (e);
 260                         }
 261
 262                         public void DoOnPageIndexChanged (EventArgs e)
 263                         {
 264                                 OnPageIndexChanged (e);
 265                         }
 266
 267                         public void DoOnPageIndexChanging (FormViewPageEventArgs e)
 268                         {
 269                                 OnPageIndexChanging (e);
 270                         }
 271
 272                         public void DoPerformDataBinding (IEnumerable data)
 273                         {
 274                                 PerformDataBinding (data);
 275                         }
 276
 277                         protected internal override void PrepareControlHierarchy ()
 278                         {
 279
 280                                 base.PrepareControlHierarchy ();
 281                                 controlHierarchy = true;
 282                         }
 283
 284                         public void DoRaisePostBackEvent (string eventArgument)
 285                         {
 286                                 RaisePostBackEvent (eventArgument);
 287                         }
 288
 289                         public string Render ()
 290                         {
 291
 292                                 StringWriter sw = new StringWriter ();
 293                                 HtmlTextWriter tw = new HtmlTextWriter (sw);
 294                                 Render (tw);
 295                                 return sw.ToString ();
 296
 297                         }
 298
 299
 300
 301                         public object DoSaveControlState ()
 302                         {
 303                                 return SaveControlState ();
 304                         }
 305
 306
 307
 308                         public void DoConfirmInitState ()
 309                         {
 310                                 base.ConfirmInitState ();
 311                         }
 312
 313                         public void DoOnPreRender (EventArgs e)
 314                         {
 315                                 base.OnPreRender (e);
 316                         }
 317
 318                         public void DoOnDataBinding (EventArgs e)
 319                         {
 320                                 base.OnDataBinding (e);
 321                         }
 322                         public void DoOnDataBound (EventArgs e)
 323                         {
 324                                 base.OnDataBound (e);
 325                         }
 326
 327                         public bool OnPageIndexChangingCalled {
 328                                 set { _onPageIndexChangingCalled = value; }
 329                                 get { return _onPageIndexChangingCalled; }
 330                         }
 331
 332                         public bool OnPageIndexChangedCalled {
 333                                 set { _onPageIndexChangedCalled = value; }
 334                                 get { return _onPageIndexChangedCalled; }
 335                         }
 336
 337                         protected override void OnPageIndexChanging (FormViewPageEventArgs e) {
 338                                 OnPageIndexChangingCalled = true;
 339                                 base.OnPageIndexChanging (e);
 340                         }
 341
 342                         protected override void OnPageIndexChanged (EventArgs e) {
 343                                 OnPageIndexChangedCalled = true;
 344                                 base.OnPageIndexChanged (e);
 345                         }
 346
 347                         public bool GetRequiresDataBinding () {
 348                                 return RequiresDataBinding;
 349                         }
 350                         public bool GetInitialized () {
 351                                 return Initialized;
 352                         }
 353 #if NET_4_0
 354                         public string CallModifiedOuterTableStylePropertyName ()
 355                         {
 356                                 return ModifiedOuterTableStylePropertyName ();
 357                         }
 358 #endif
 359                 }
 360
 361                 class Template : ITemplate
 362                 {
 363                         bool _instantiated;
 364
 365                         public bool Instantiated {
 366                                get { return _instantiated; }
 367                         }
 368
 369 #region ITemplate Members
 370
 371                         public void InstantiateIn (Control container) {
 372                                _instantiated = true;
 373                         }
 374
 375                         #endregion
 376                 }
 377
 378
 379                 ArrayList myds = new ArrayList ();
 380                 [TestFixtureSetUp]
 381                 public void setup ()
 382                 {
 383                         TestMyData.InitData();
 384                         myds.Add ("Item1");
 385                         myds.Add ("Item2");
 386                         myds.Add ("Item3");
 387                         myds.Add ("Item4");
 388                         myds.Add ("Item5");
 389                         myds.Add ("Item6");
 390
 391                         WebTest.CopyResource (GetType (), "FormView.aspx", "FormView.aspx");
 392                         WebTest.CopyResource (GetType (), "FormViewTest1.aspx", "FormViewTest1.aspx");
 393                         WebTest.CopyResource (GetType (), "FormViewTest1_2.aspx", "FormViewTest1_2.aspx");
 394                         WebTest.CopyResource (GetType (), "FormViewTest1_3.aspx", "FormViewTest1_3.aspx");
 395                         WebTest.CopyResource (GetType (), "FormViewTest1_4.aspx", "FormViewTest1_4.aspx");
 396                         WebTest.CopyResource (GetType (), "FormViewInsertEditDelete.aspx", "FormViewInsertEditDelete.aspx");
 397                         WebTest.CopyResource (GetType (), "FormViewPagerVisibility.aspx", "FormViewPagerVisibility.aspx");
 398                 }
 399
 400                 [Test]
 401                 public void Defaults ()
 402                 {
 403                         Poker p = new Poker ();
 404                         Assert.IsFalse (p.AllowPaging, "A1");
 405                         Assert.AreEqual ("", p.BackImageUrl, "A2");
 406                         Assert.IsNull (p.BottomPagerRow, "A3");
 407                         Assert.AreEqual ("", p.Caption, "A4");
 408                         Assert.AreEqual (TableCaptionAlign.NotSet, p.CaptionAlign, "A5");
 409                         Assert.AreEqual (-1, p.CellPadding, "A6");
 410                         Assert.AreEqual (0, p.CellSpacing, "A7");
 411                         Assert.AreEqual (FormViewMode.ReadOnly, p.CurrentMode, "A8");
 412                         Assert.AreEqual (FormViewMode.ReadOnly, p.DefaultMode, "A9");
 413                         Assert.IsNotNull (p.DataKeyNames, "A10");
 414                         Assert.AreEqual (0, p.DataKeyNames.Length, "A10.1");
 415                         Assert.IsNotNull (p.DataKey, "A11");
 416                         Assert.AreEqual (0, p.DataKey.Values.Count, "A11.1");
 417                         Assert.IsNull (p.EditItemTemplate, "A12");
 418                         Assert.IsNotNull (p.EditRowStyle, "A13");
 419                         Assert.IsNotNull (p.EmptyDataRowStyle, "A14");
 420                         Assert.IsNull (p.EmptyDataTemplate, "A15");
 421                         Assert.AreEqual ("", p.EmptyDataText, "A16");
 422                         Assert.IsNull (p.FooterRow, "A17");
 423                         Assert.IsNull (p.FooterTemplate, "A18");
 424                         Assert.AreEqual ("", p.FooterText, "A19");
 425                         Assert.IsNotNull (p.FooterStyle, "A20");
 426                         Assert.AreEqual (GridLines.None, p.GridLines, "A21");
 427                         Assert.IsNull (p.HeaderRow, "A22");
 428                         Assert.IsNotNull (p.HeaderStyle, "A23");
 429                         Assert.IsNull (p.HeaderTemplate, "A24");
 430                         Assert.AreEqual ("", p.HeaderText, "A25");
 431                         Assert.AreEqual (HorizontalAlign.NotSet, p.HorizontalAlign, "A26");
 432                         Assert.IsNull (p.InsertItemTemplate, "A27");
 433                         Assert.IsNotNull (p.InsertRowStyle, "A28");
 434                         Assert.IsNull (p.ItemTemplate, "A29");
 435                         Assert.AreEqual (0, p.PageCount, "A30");
 436                         Assert.AreEqual (0, p.PageIndex, "A31");
 437                         Assert.IsNull (p.PagerTemplate, "A32");
 438                         Assert.IsNull (p.Row, "A33");
 439                         Assert.IsNotNull (p.RowStyle, "A34");
 440                         Assert.IsNull (p.SelectedValue, "A35");
 441                         Assert.IsNull (p.TopPagerRow, "A36");
 442                         Assert.IsNull (p.DataItem, "A37");
 443                         Assert.AreEqual (0, p.DataItemCount, "A38");
 444                         Assert.AreEqual (0, p.DataItemIndex, "A39");
 445                 }
 446
 447                 [Test]
 448                 public void FormView_AssignToDefaultProperties ()
 449                 {
 450                         Poker p = new Poker ();
 451                         MyTemplate customTemplate = new MyTemplate ();
 452                         TableItemStyle tableStyle = new TableItemStyle ();
 453                         p.AllowPaging = true;
 454                         Assert.AreEqual (true, p.AllowPaging, "A40");
 455                         p.BackImageUrl = "image.jpg";
 456                         Assert.AreEqual ("image.jpg", p.BackImageUrl, "A41");
 457                         // ToDo: p.BottomPagerRow
 458                         p.Caption = "Employee Details";
 459                         Assert.AreEqual ("Employee Details", p.Caption, "A42");
 460                         p.CaptionAlign = TableCaptionAlign.Bottom;
 461                         Assert.AreEqual (TableCaptionAlign.Bottom, p.CaptionAlign, "A43");
 462                         p.CaptionAlign = TableCaptionAlign.Left;
 463                         Assert.AreEqual (TableCaptionAlign.Left, p.CaptionAlign, "A44");
 464                         p.CaptionAlign = TableCaptionAlign.NotSet;
 465                         Assert.AreEqual (TableCaptionAlign.NotSet, p.CaptionAlign, "A45");
 466                         p.CaptionAlign = TableCaptionAlign.Right;
 467                         Assert.AreEqual (TableCaptionAlign.Right, p.CaptionAlign, "A46");
 468                         p.CaptionAlign = TableCaptionAlign.Top;
 469                         Assert.AreEqual (TableCaptionAlign.Top, p.CaptionAlign, "A47");
 470                         p.CellPadding = 10;
 471                         Assert.AreEqual (10, p.CellPadding, "A48");
 472                         p.CellSpacing = 20;
 473                         Assert.AreEqual (20, p.CellSpacing, "A49");
 474                         Assert.AreEqual (FormViewMode.ReadOnly, p.CurrentMode, "A52");
 475                         p.DefaultMode = FormViewMode.Edit;
 476                         Assert.AreEqual (FormViewMode.Edit, p.DefaultMode, "A53");
 477                         p.DefaultMode = FormViewMode.Insert;
 478                         Assert.AreEqual (FormViewMode.Insert, p.DefaultMode, "A54");
 479                         p.DefaultMode = FormViewMode.ReadOnly;
 480                         Assert.AreEqual (FormViewMode.ReadOnly, p.DefaultMode, "A55");
 481                         p.EditRowStyle.BackColor = Color.Red;
 482                         Assert.AreEqual (Color.Red, p.EditRowStyle.BackColor, "A56");
 483                         p.EmptyDataRowStyle.ForeColor = Color.Purple;
 484                         Assert.AreEqual (Color.Purple, p.EmptyDataRowStyle.ForeColor, "A57");
 485                         p.EmptyDataTemplate = customTemplate;
 486                         Assert.AreEqual (customTemplate, p.EmptyDataTemplate, "A58");
 487                         p.EmptyDataText = "No data";
 488                         Assert.AreEqual ("No data", p.EmptyDataText, "A59");
 489                         p.EditItemTemplate = customTemplate;
 490                         Assert.AreEqual (customTemplate, p.EditItemTemplate, "A60");
 491                         p.FooterTemplate = customTemplate;
 492                         Assert.AreEqual (customTemplate, p.FooterTemplate, "A61");
 493                         p.FooterText = "Test Footer";
 494                         Assert.AreEqual ("Test Footer", p.FooterText, "A62");
 495                         p.FooterStyle.BorderStyle = BorderStyle.Double;
 496                         Assert.AreEqual (BorderStyle.Double, p.FooterStyle.BorderStyle, "A63");
 497                         p.GridLines = GridLines.Both;
 498                         Assert.AreEqual (GridLines.Both, p.GridLines, "A64");
 499                         p.GridLines = GridLines.Horizontal;
 500                         Assert.AreEqual (GridLines.Horizontal, p.GridLines, "A65");
 501                         p.GridLines = GridLines.None;
 502                         Assert.AreEqual (GridLines.None, p.GridLines, "A66");
 503                         p.GridLines = GridLines.Vertical;
 504                         Assert.AreEqual (GridLines.Vertical, p.GridLines, "A67");
 505                         p.HeaderStyle.HorizontalAlign = HorizontalAlign.Left;
 506                         Assert.AreEqual (HorizontalAlign.Left, p.HeaderStyle.HorizontalAlign, "A68");
 507                         p.HeaderTemplate = customTemplate;
 508                         Assert.AreEqual (customTemplate, p.HeaderTemplate, "A69");
 509                         p.HeaderText = "Test Header";
 510                         Assert.AreEqual ("Test Header", p.HeaderText, "A70");
 511                         p.HorizontalAlign = HorizontalAlign.Center;
 512                         Assert.AreEqual (HorizontalAlign.Center, p.HorizontalAlign, "A71");
 513                         p.HorizontalAlign = HorizontalAlign.Justify;
 514                         Assert.AreEqual (HorizontalAlign.Justify, p.HorizontalAlign, "A72");
 515                         p.HorizontalAlign = HorizontalAlign.Left;
 516                         Assert.AreEqual (HorizontalAlign.Left, p.HorizontalAlign, "A73");
 517                         p.HorizontalAlign = HorizontalAlign.NotSet;
 518                         Assert.AreEqual (HorizontalAlign.NotSet, p.HorizontalAlign, "A74");
 519                         p.HorizontalAlign = HorizontalAlign.Right;
 520                         Assert.AreEqual (HorizontalAlign.Right, p.HorizontalAlign, "A75");
 521                         p.InsertItemTemplate = customTemplate;
 522                         Assert.AreEqual (customTemplate, p.InsertItemTemplate, "A76");
 523                         p.InsertRowStyle.BorderStyle = BorderStyle.Outset;
 524                         Assert.AreEqual (BorderStyle.Outset, p.InsertRowStyle.BorderStyle, "A77");
 525                         p.ItemTemplate = customTemplate;
 526                         Assert.AreEqual (customTemplate, p.ItemTemplate, "A78");
 527                         p.PagerSettings.FirstPageText = "PagerSettings Test";
 528                         Assert.AreEqual ("PagerSettings Test", p.PagerSettings.FirstPageText, "A79");
 529                         p.PagerStyle.BorderStyle = BorderStyle.Groove;
 530                         Assert.AreEqual (BorderStyle.Groove, p.PagerStyle.BorderStyle, "A80");
 531                         p.PagerTemplate = customTemplate;
 532                         Assert.AreEqual (customTemplate, p.PagerTemplate, "A81");
 533                         p.RowStyle.ForeColor = Color.Plum;
 534                         Assert.AreEqual (Color.Plum, p.RowStyle.ForeColor, "A82");
 535                 }
 536
 537                 [Test]
 538                 public void FormView_PageIndex ()
 539                 {
 540                         Poker p = new Poker ();
 541                         Assert.AreEqual (0, p.PageIndex, "#00");
 542                         Assert.AreEqual (false, p.GetInitialized (), "#01");
 543                         Assert.AreEqual (false, p.GetRequiresDataBinding(), "#02");
 544                         p.PageIndex = 2;
 545                         Assert.AreEqual (2, p.PageIndex, "#03");
 546                         Assert.AreEqual (false, p.GetRequiresDataBinding (), "#04");
 547                         p.PageIndex = -1;
 548                         Assert.AreEqual (2, p.PageIndex, "#05");
 549                         Assert.AreEqual (false, p.GetRequiresDataBinding (), "#06");
 550                 }
 551
 552                 [Test]
 553                 [Category ("NunitWeb")]
 554                 public void FormView_PageIndex2 ()
 555                 {
 556                         PageDelegates delegates = new PageDelegates ();
 557                         delegates.Load = FormView_PageIndex2_load;
 558                         delegates.LoadComplete = FormView_PageIndex2_loadComplete;
 559                         PageInvoker invoker = new PageInvoker (delegates);
 560                         WebTest test = new WebTest (invoker);
 561                         test.Run ();
 562                 }
 563
 564                 public static void FormView_PageIndex2_load (Page p)
 565                 {
 566                         Poker fv = new Poker ();
 567                         p.Form.Controls.Add (fv);
 568                         Assert.AreEqual (0, fv.PageIndex, "#00");
 569                         Assert.AreEqual (false, fv.GetInitialized (), "#01");
 570                         Assert.AreEqual (false, fv.GetRequiresDataBinding (), "#02");
 571                         fv.PageIndex = 2;
 572                         Assert.AreEqual (2, fv.PageIndex, "#03");
 573                         Assert.AreEqual (false, fv.GetRequiresDataBinding (), "#04");
 574                         fv.PageIndex = -1;
 575                         Assert.AreEqual (2, fv.PageIndex, "#05");
 576                         Assert.AreEqual (false, fv.GetRequiresDataBinding (), "#06");
 577                 }
 578
 579                 public static void FormView_PageIndex2_loadComplete (Page p)
 580                 {
 581                         Poker fv = new Poker ();
 582                         p.Form.Controls.Add (fv);
 583                         Assert.AreEqual (0, fv.PageIndex, "#100");
 584                         Assert.AreEqual (true, fv.GetInitialized (), "#101");
 585                         Assert.AreEqual (true, fv.GetRequiresDataBinding (), "#102");
 586                         fv.PageIndex = 2;
 587                         Assert.AreEqual (2, fv.PageIndex, "#103");
 588                         Assert.AreEqual (true, fv.GetRequiresDataBinding (), "#104");
 589                         fv.PageIndex = -1;
 590                         Assert.AreEqual (2, fv.PageIndex, "#105");
 591                         Assert.AreEqual (true, fv.GetRequiresDataBinding (), "#106");
 592                 }
 593
 594                 [Test]
 595                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
 596                 public void FormView_PageIndex_Ex ()
 597                 {
 598                         Poker p = new Poker ();
 599                         p.PageIndex = -2;
 600                 }
 601
 602                 [Test]
 603                 public void FormView_ItemsProperties ()
 604                 {
 605                         Poker p = new Poker ();
 606                         p.Page = new Page ();
 607                         p.AllowPaging = true;
 608                         p.DataSource = myds;
 609                         p.DataBind ();
 610                         //Assert.AreEqual (typeof (FormViewPagerRow), (p.BottomPagerRow).GetType (), "BottomPagerRow1");
 611                         Assert.AreEqual (0, p.BottomPagerRow.ItemIndex, "BottomPagerRow2");
 612                         Assert.AreEqual (DataControlRowType.Pager, p.BottomPagerRow.RowType, "BottomPagerRow2");
 613                         Assert.AreEqual ("Item1", p.DataItem, "DataItem");
 614                         Assert.AreEqual (6, p.DataItemCount, "DataItemCount");
 615                         Assert.AreEqual (0, p.DataItemIndex, "DataItemIndex");
 616                         Assert.AreEqual (0, p.DataItemIndex, "DataItemIndex");
 617                         string[] str = new string[] { "1", "2", "3", "4", "5", "6" };
 618                         Assert.AreEqual (typeof (DataKey), p.DataKey.GetType (), "DataKey");
 619                         p.DataKeyNames = str;
 620                         Assert.AreEqual (str, p.DataKeyNames, "DataKeyNames");
 621                         p.ChangeMode (FormViewMode.Edit);
 622                         Assert.AreEqual (FormViewMode.Edit, p.CurrentMode, "CurrentModeEdit");
 623                         p.ChangeMode (FormViewMode.Insert);
 624                         Assert.AreEqual (FormViewMode.Insert, p.CurrentMode, "CurrentModeInsert");
 625
 626                 }
 627
 628                 [Test]
 629                 public void FormView_DefaultProtectedProperties ()
 630                 {
 631                         Poker fv = new Poker ();
 632                         Assert.AreEqual (HtmlTextWriterTag.Table, fv.PokerTagKey, "TagKey");
 633                 }
 634
 635                 // Protected methods
 636
 637                 [Test]
 638                 public void FormView_CreateChildControls ()
 639                 {
 640                         Poker fv = new Poker ();
 641                         fv.DataSource = myds;
 642                         fv.Page = new Page ();
 643                         Assert.AreEqual (6, fv.DoCreateChildControls (myds, true), "CreateChildControlFromDS");
 644                         myds.Add ("item7");
 645                         Assert.AreEqual (7, fv.DoCreateChildControls (myds, false), "CreateChildControlFromViewState");
 646                         myds.Remove ("item7");
 647
 648                 }
 649
 650                 class MyEnumSource : IEnumerable
 651                 {
 652                         int _count;
 653
 654                         public MyEnumSource (int count) {
 655                                 _count = count;
 656                         }
 657
 658                         #region IEnumerable Members
 659
 660                         public IEnumerator GetEnumerator () {
 661
 662                                 for (int i = 0; i < _count; i++)
 663                                         yield return i;
 664                         }
 665
 666                         #endregion
 667                 }
 668
 669                 [Test]
 670                 public void FormView_CreateChildControls2 ()
 671                 {
 672                         Poker fv = new Poker ();
 673                         fv.Page = new Page ();
 674                         fv.DataSource = new MyEnumSource (20);
 675                         fv.DataBind ();
 676
 677                         Assert.AreEqual (20, fv.PageCount, "CreateChildControls#0");
 678
 679                         Assert.AreEqual (0, fv.DoCreateChildControls (new MyEnumSource (0), true), "CreateChildControls#1");
 680                         Assert.AreEqual (20, fv.DoCreateChildControls (new MyEnumSource (20), true), "CreateChildControls#2");
 681
 682                         Assert.AreEqual (0, fv.DoCreateChildControls (new object [0], false), "CreateChildControls#3");
 683                         Assert.AreEqual (5, fv.DoCreateChildControls (new object [5], false), "CreateChildControls#4");
 684                 }
 685
 686                 [Test]
 687                 public void FormView_CreateDataSourceSelectArguments ()
 688                 {
 689                         //Checks the default DataSourceSelectArgument object returned.
 690                         Poker fv = new Poker ();
 691                         DataSourceSelectArguments selectArgs = fv.DoCreateDataSourceSelectArguments ();
 692                         Assert.AreEqual (0, selectArgs.MaximumRows, "CreateDataSourceSelectArguments1");
 693                         Assert.AreEqual (false, selectArgs.RetrieveTotalRowCount, "CreateDataSourceSelectArguments2");
 694
 695                 }
 696
 697                 [Test]
 698                 public void FormView_CreateControlStyle ()
 699                 {
 700                         Poker fv = new Poker ();
 701                         Style s = fv.DoCreateControlStyle ();
 702                         Assert.AreEqual (typeof (TableStyle), s.GetType (), "CreateControlStyle1");
 703                         Assert.AreEqual (GridLines.None, ((TableStyle) s).GridLines, "CreateControlStyle2");
 704                         Assert.AreEqual ("", ((TableStyle) s).BackImageUrl, "CreateControlStyle3");
 705                         Assert.AreEqual (0, ((TableStyle) s).CellSpacing, "CreateControlStyle4");
 706                         Assert.AreEqual (-1, ((TableStyle) s).CellPadding, "CreateControlStyle5");
 707
 708                 }
 709
 710                 [Test]
 711                 public void FormView_InitializeRow ()
 712                 {
 713                         //not implemented
 714                 }
 715
 716                 [Test]
 717                 public void FormView_InitializePager ()
 718                 {
 719                         Poker fv = new Poker ();
 720                         Page page = new Page ();
 721                         page.Controls.Add (fv);
 722                         fv.AllowPaging = true;
 723                         fv.DataSource = myds;
 724                         Assert.AreEqual (false, fv.isInitializePager, "BeforeInitializePager");
 725                         Assert.AreEqual (0, fv.PageCount, "BeforeInitializePagerPageCount");
 726                         fv.DataBind ();
 727                         Assert.AreEqual (true, fv.isInitializePager, "AfterInitializePager");
 728                         Assert.AreEqual (6, fv.PageCount, "AfterInitializePagerPageCount");
 729                 }
 730
 731                 [Test]
 732                 public void FormView_CreateRow ()
 733                 {
 734                         Poker fv = new Poker ();
 735                         fv.AllowPaging =true;
 736                         fv.DataSource = myds;
 737                         fv.Page = new Page ();
 738                         fv.DataBind ();
 739                         FormViewRow row = fv.DoCreateRow (2,DataControlRowType.DataRow ,DataControlRowState.Normal );
 740                         Assert.AreEqual (2, row.ItemIndex, "CreatedRowItemIndex1");
 741                         Assert.AreEqual (DataControlRowState.Normal , row.RowState, "CreatedRowState1");
 742                         Assert.AreEqual (DataControlRowType.DataRow , row.RowType, "CreatedRowType1");
 743                         row = fv.DoCreateRow (4, DataControlRowType.Footer, DataControlRowState.Edit);
 744                         Assert.AreEqual (4, row.ItemIndex, "CreatedRowItemIndex2");
 745                         Assert.AreEqual (DataControlRowState.Edit , row.RowState, "CreatedRowState2");
 746                         Assert.AreEqual (DataControlRowType.Footer , row.RowType, "CreatedRowType2");
 747                         //FormViewPagerRow pagerRow = (FormViewPagerRow)fv.DoCreateRow (3, DataControlRowType.Pager , DataControlRowState.Insert);
 748                         //Assert.AreEqual (3, pagerRow.ItemIndex, "CreatedPageRowItemIndex");
 749                         //Assert.AreEqual (DataControlRowState.Insert, pagerRow.RowState, "CreatedPageRowState");
 750                         //Assert.AreEqual (DataControlRowType.Pager, pagerRow.RowType, "CreatedPageRowType");
 751
 752                 }
 753
 754                 [Test]
 755                 public void FormView_CreateTable ()
 756                 {
 757                         Poker fv = new Poker ();
 758                         Table tb = fv.DoCreateTable ();
 759                         fv.Page = new Page ();
 760                         Assert.AreEqual ("", tb.BackImageUrl , "CreateTable1");
 761                         Assert.AreEqual (0, tb.Rows.Count, "CreateTable2");
 762                         fv.DataSource = myds;
 763                         fv.DataBind ();
 764                         fv.ID = "TestFormView";
 765                         tb = fv.DoCreateTable ();
 766                         Assert.AreEqual (-1, tb.CellPadding , "CreateTable3");
 767
 768                 }
 769
 770                 [Test]
 771                 public void FormView_EnsureDataBound ()
 772                 {
 773                         Poker fv = new Poker ();
 774                         fv.DataSource = myds;
 775                         fv.DoOnPreRender (EventArgs.Empty);
 776                         Assert.AreEqual (true, fv.ensureDataBound, "EnsureDataBound");
 777
 778                 }
 779
 780                 [Test]
 781                 public void FormView_PerformDataBinding ()
 782                 {
 783                         Poker fv = new Poker ();
 784                         fv.Page = new Page ();
 785                         Assert.AreEqual (0,fv.DataItemCount, "BeforePerformDataBinding");
 786                         fv.DoPerformDataBinding (myds);
 787                         Assert.AreEqual (6, fv.DataItemCount, "AfterPerformDataBinding");
 788                 }
 789
 790                 [Test]
 791                 public void FormView_ExtractRowValues ()
 792                 {
 793                         Poker fv=new Poker ();
 794                         fv.ItemTemplate = new MyTemplate ();
 795                         fv.DataKeyNames = new string[] { "ID", "FName", "LName" };
 796                         //IOrderedDictionary dict = (IOrderedDictionary) new OrderedDictionary (0x19);
 797                         //fv.DoExtractRowValues (dict, true);
 798                         //DataTable ds = CreateDataTable ();
 799                         //fv.DataSource = ds;
 800                         //fv.DataBind ();
 801                         //OrderedDictionary fieldsValues = new OrderedDictionary ();
 802                         //fv.DoExtractRowValues (fieldsValues, true);
 803                         //Assert.AreEqual (3, fieldsValues.Count, "ExtractRowValues1");
 804                         //Assert.AreEqual (3, fieldsValues.Keys.Count, "ExtractRowValues2");
 805                         //Assert.AreEqual (3, fieldsValues.Values.Count, "ExtractRowValues3");
 806                         //Assert.AreEqual (true, fieldsValues.Contains ("ID"), "ExtractRowValues4");
 807                         //IDictionaryEnumerator enumerator = fieldsValues.GetEnumerator ();
 808                         //enumerator.MoveNext ();
 809                         //Assert.AreEqual ("ID", enumerator.Key, "FieldValue1");
 810                         //Assert.AreEqual ("1001", enumerator.Value, "FieldValue2");
 811                         //enumerator.MoveNext ();
 812                         //Assert.AreEqual ("FName", enumerator.Key, "FieldValue3");
 813                         //Assert.AreEqual ("Mahesh", enumerator.Value, "FieldValue4");
 814                         //enumerator.MoveNext ();
 815                         //Assert.AreEqual ("LName", enumerator.Key, "FieldValue5");
 816                         //Assert.AreEqual ("Chand", enumerator.Value, "FieldValue6");
 817
 818                 }
 819
 820                 [Test]
 821                 public void FormView_PrepareControlHierarchy ()
 822                 {
 823                         Poker fv = new Poker ();
 824                         fv.Page = new Page ();
 825                         fv.controlHierarchy = false;
 826                         fv.Render ();
 827                         Assert.AreEqual (0, fv.Controls.Count, "ControlHierarchy1");
 828                         Assert.AreEqual (true, fv.controlHierarchy, "ControlHierarchy2");
 829                         fv.AllowPaging = true;
 830                         fv.DataSource = myds;
 831                         fv.DataBind ();
 832                         fv.controlHierarchy = false;
 833                         fv.Render ();
 834                         Assert.AreEqual (1, fv.Controls.Count, "ControlHierarchy3");
 835                         Assert.AreEqual (true, fv.controlHierarchy, "ControlHierarchy4");
 836
 837
 838                 }
 839
 840                 //Public Methods
 841
 842                 [Test]
 843                 public void FormView_ChangeMode ()
 844                 {
 845                         Poker fv = new Poker ();
 846                         Assert.AreEqual (FormViewMode.ReadOnly, fv.CurrentMode, "ChangeModeDefault");
 847                         fv.ChangeMode (FormViewMode.Insert);
 848                         Assert.AreEqual (FormViewMode.Insert, fv.CurrentMode, "ChangeModeInsert");
 849                         fv.ChangeMode (FormViewMode.Edit);
 850                         Assert.AreEqual (FormViewMode.Edit, fv.CurrentMode, "ChangeModeEdit");
 851                         fv.ChangeMode (FormViewMode.ReadOnly);
 852                         Assert.AreEqual (FormViewMode.ReadOnly, fv.CurrentMode, "ChangeModeReadOnly");
 853                 }
 854
 855                 [Test]
 856                 public void FormView_PageCount () {
 857                         Page p = new Page ();
 858
 859                         Poker fv = new Poker ();
 860                         p.Controls.Add (fv);
 861
 862                         ObjectDataSource data = new ObjectDataSource ();
 863                         data.TypeName = typeof (FormViewDataObject).AssemblyQualifiedName;
 864                         data.SelectMethod = "Select";
 865                         p.Controls.Add (data);
 866
 867                         fv.DataSource = data;
 868
 869                         Assert.AreEqual (0, fv.PageCount, "PageCount before binding");
 870
 871                         fv.DataBind ();
 872
 873                         Assert.AreEqual (3, fv.PageCount, "PageCount after binding");
 874                 }
 875
 876                 [Test]
 877                 public void FormView_DataKey ()
 878                 {
 879                         Page p = new Page ();
 880
 881                         Poker fv = new Poker ();
 882                         p.Controls.Add (fv);
 883
 884                         ObjectDataSource data = new ObjectDataSource ();
 885                         data.TypeName = typeof (FormViewDataObject).AssemblyQualifiedName;
 886                         data.SelectMethod = "Select";
 887                         p.Controls.Add (data);
 888
 889                         fv.DataSource = data;
 890                         fv.DataKeyNames = new string [] { "ID", "FName" };
 891
 892                         DataKey key1 = fv.DataKey;
 893
 894                         Assert.AreEqual (null, key1.Value, "DataKey.Value before binding");
 895                         Assert.AreEqual (0, key1.Values.Count, "DataKey.Values count before binding");
 896
 897                         fv.DataBind ();
 898
 899                         DataKey key2 = fv.DataKey;
 900                         DataKey key3 = fv.DataKey;
 901
 902                         Assert.IsFalse (Object.ReferenceEquals (key1, key2), "DataKey returns the same instans");
 903                         Assert.IsTrue (Object.ReferenceEquals (key2, key3), "DataKey returns the same instans");
 904
 905                         Assert.AreEqual (1001, key1.Value, "DataKey.Value after binding");
 906                         Assert.AreEqual (2, key1.Values.Count, "DataKey.Values count after binding");
 907                         Assert.AreEqual (1001, key1.Values [0], "DataKey.Values[0] after binding");
 908                         Assert.AreEqual ("Mahesh", key1.Values [1], "DataKey.Values[1] after binding");
 909
 910                         Poker copy = new Poker ();
 911                         object state = fv.DoSaveControlState ();
 912                         copy.DoLoadControlState (state);
 913
 914                         DataKey key4 = copy.DataKey;
 915
 916                         Assert.AreEqual (1001, key4.Value, "DataKey.Value from ViewState");
 917                         Assert.AreEqual (2, key4.Values.Count, "DataKey.Values count from ViewState");
 918                         Assert.AreEqual (1001, key4.Values [0], "DataKey.Values[0] from ViewState");
 919                         Assert.AreEqual ("Mahesh", key4.Values [1], "DataKey.Values[1] from ViewState");
 920                 }
 921
 922                 [Test]
 923                 public void FormView_DataBind ()
 924                 {
 925                         Poker fv = new Poker ();
 926                         fv.AllowPaging = true;
 927                         fv.DataSource = myds;
 928                         fv.Page = new Page ();
 929                         Assert.AreEqual (0, fv.PageCount, "BeforeDataBind1");
 930                         Assert.AreEqual (null, fv.DataItem, "BeforeDataBind2");
 931                         fv.DataBind ();
 932                         Assert.AreEqual (6, fv.PageCount, "AfterDataBind1");
 933                         Assert.AreEqual (6, fv.DataItemCount, "AfterDataBind2");
 934                         Assert.AreEqual ("Item1", fv.DataItem, "AfterDataBind3");
 935                 }
 936
 937                 private bool isDeleted = false;
 938
 939                 [Test]
 940                 public void FormView_DeleteItem ()
 941                 {
 942                         Poker fv = new Poker ();
 943                         fv.Page = new Page ();
 944                         fv.DataSource = myds;
 945                         fv.DataBind ();
 946                         Assert.AreEqual (false, isDeleted, "BeforeDeleteItem");
 947                         fv.ItemDeleting += new FormViewDeleteEventHandler (fv_DeleteingHandler);
 948                         fv.DeleteItem ();
 949                         Assert.AreEqual (true, isDeleted, "BeforeDeleteItem");
 950
 951                 }
 952
 953                 public void fv_DeleteingHandler (Object sender, FormViewDeleteEventArgs e)
 954                 {
 955                         isDeleted = true;
 956                 }
 957
 958                 private bool insertItem = false;
 959
 960                 [Test]
 961                 public void FormView_InsertItem ()
 962                 {
 963                         Poker fv = new Poker ();
 964                         fv.Page = new Page ();
 965                         fv.ChangeMode (FormViewMode.Insert);
 966                         fv.ItemInserting += new FormViewInsertEventHandler (insert_item);
 967                         Assert.AreEqual (false, insertItem, "BeforeInsertItem");
 968                         fv.InsertItem (false);
 969                         Assert.AreEqual (true, insertItem, "AfterInsertItem");
 970
 971                 }
 972
 973                 public void insert_item (object sender, FormViewInsertEventArgs e)
 974                 {
 975                         insertItem = true;
 976                 }
 977
 978                 private bool updateItem = false;
 979                 [Test]
 980                 public void FormView_UpdateItem ()
 981                 {
 982                         Poker fv = new Poker ();
 983                         fv.Page = new Page ();
 984                         fv.DataSource = myds;
 985                         fv.DataBind ();
 986                         fv.ChangeMode (FormViewMode.Edit);
 987                         fv.ItemUpdating += new FormViewUpdateEventHandler (update_item);
 988                         Assert.AreEqual (false, updateItem, "BeforeUpdateItem");
 989                         fv.UpdateItem (false);
 990                         Assert.AreEqual (true, updateItem, "AfterUpdateItem");
 991
 992                 }
 993
 994                 public void update_item (object sender, FormViewUpdateEventArgs e)
 995                 {
 996                         updateItem = true;
 997                 }
 998
 999                 [Test]
1000                 public void FormView_IsBindableType ()
1001                 {
1002                         bool isBindable = false;
1003                         Poker fv = new Poker ();
1004                         isBindable = fv.IsBindableType (typeof (Decimal));
1005                         Assert.AreEqual (true, isBindable, "IsBindableTypeDecimal");
1006                         isBindable = fv.IsBindableType (typeof (Int32));
1007                         Assert.AreEqual (true, isBindable, "IsBindableTypeInt32");
1008                         isBindable = fv.IsBindableType (typeof (String));
1009                         Assert.AreEqual (true, isBindable, "IsBindableTypeString");
1010                         isBindable = fv.IsBindableType (typeof (Boolean));
1011                         Assert.AreEqual (true, isBindable, "IsBindableTypeBoolean");
1012                         isBindable = fv.IsBindableType (typeof (DateTime));
1013                         Assert.AreEqual (true, isBindable, "IsBindableTypeDateTime");
1014                         isBindable = fv.IsBindableType (typeof (Byte));
1015                         Assert.AreEqual (true, isBindable, "IsBindableTypeByte");
1016                         isBindable = fv.IsBindableType (typeof (Guid));
1017                         Assert.AreEqual (true, isBindable, "IsBindableTypeGuid");
1018                         isBindable = fv.IsBindableType (typeof (MyTemplate));
1019                         Assert.AreEqual (false, isBindable, "IsBindableTypeMyTemplate");
1020                 }
1021
1022                 [Test]
1023                 public void FormView_ControlState ()            {
1024
1025                         Poker fv = new Poker ();
1026                         Poker copy = new Poker ();
1027                         string[] keys = new String[2];
1028                         keys[0] = "key1";
1029                         keys[1] = "key2";
1030                         fv.DataKeyNames = keys;
1031                         fv.BackImageUrl = "photo.jpg";
1032                         fv.DefaultMode  = FormViewMode.Insert  ;
1033                         fv.ChangeMode (FormViewMode.Edit);
1034                         object state = fv.DoSaveControlState ();
1035                         copy.DoLoadControlState (state);
1036                         Assert.AreEqual (2, copy.DataKeyNames.Length, "DataKeyNames.Length");
1037                         Assert.AreEqual ("key1", copy.DataKeyNames[0], "ControlStateDataKeyValue");
1038                         Assert.AreEqual ("key2", copy.DataKeyNames[1], "ControlStateDataKeyValue2");
1039                         Assert.AreEqual (FormViewMode.Insert, copy.DefaultMode, "ControlStateDefaultMode");
1040                         Assert.AreEqual (FormViewMode.Edit, copy.CurrentMode, "ControlStateCurrentMode");
1041
1042                 }
1043
1044                 //ViewState
1045                 [Test]
1046                 public void FormView_ViewState ()
1047                 {
1048                         Poker fv = new Poker ();
1049                         Poker copy = new Poker ();
1050                         fv.AllowPaging = true;
1051                         fv.HeaderText = "Testing";
1052                         fv.CssClass = "style.css";
1053                         object state = fv.SaveState ();
1054                         copy.LoadState (state);
1055                         Assert.AreEqual (true, copy.AllowPaging, "ViewStateAllowPaging");
1056                         Assert.AreEqual ("Testing", copy.HeaderText, "ViewStateHeaderText");
1057                         Assert.AreEqual ("style.css", copy.CssClass, "ViewStateCssClass");
1058                 }
1059
1060                 //Events
1061                 private bool init;
1062                 private bool itemCommand;
1063                 private bool itemCreated;
1064                 private bool itemDeleted;
1065                 private bool itemDeleting;
1066                 private bool itemInserted;
1067                 private bool itemInserting;
1068                 private bool itemUpdated;
1069                 private bool itemUpdating;
1070                 private bool modeChanged;
1071                 private bool modeChanging;
1072                 private bool pageIndexChanged;
1073                 private bool pageIndexChanging;
1074                 private int newPageIndex;
1075
1076                 public void ResetEvents ()
1077                 {
1078                         init = false;
1079                         itemCommand = false;
1080                         itemCreated = false;
1081                         itemDeleted = false;
1082                         itemDeleting = false;
1083                         itemInserted = false;
1084                         itemInserting = false;
1085                         itemUpdated = false;
1086                         itemUpdating = false;
1087                         modeChanged = false;
1088                         modeChanging = false;
1089                         pageIndexChanged = false;
1090                         pageIndexChanging = false;
1091                 }
1092
1093                 [Test]
1094                 public void FormView_BubbleEvent ()
1095                 {
1096                         FormViewCommandEventArgs com;
1097                         Poker fv = new Poker ();
1098                         Page page = new Page ();
1099                         Button bt = new Button ();
1100                         fv.AllowPaging = true;
1101                         fv.DataSource = myds;
1102                         page.Controls.Add (fv);
1103                         fv.DataBind ();
1104                         ResetEvents ();
1105                         fv.ItemCommand += new FormViewCommandEventHandler (fv_ItemCommand);
1106                         fv.ItemDeleted += new FormViewDeletedEventHandler (fv_ItemDeleted);
1107                         //Delete
1108                         fv.ItemDeleting += new FormViewDeleteEventHandler (fv_ItemDeleting);
1109                         com = new FormViewCommandEventArgs (bt, new CommandEventArgs ("Delete", null));
1110                         Assert.AreEqual (false, itemDeleting, "BeforeDeleteCommandBubbleEvent");
1111                         Assert.AreEqual (false, itemCommand, "BeforeDeleteBubbleEvent");
1112                         Assert.IsTrue (fv.DoOnBubbleEvent (bt, com), "OnBubbleEvent - Delete");
1113                         Assert.AreEqual (true, itemDeleting, "AfterDeleteBubbleEvent");
1114                         Assert.AreEqual (true, itemCommand, "AfterDeleteCommandBubbleEvent");
1115
1116
1117                         //Insert
1118                         itemCommand = false;
1119                         fv.ItemInserting += new FormViewInsertEventHandler (fv_ItemInserting);
1120                         fv.ChangeMode (FormViewMode.Insert);
1121                         com = new FormViewCommandEventArgs (bt, new CommandEventArgs ("Insert", null));
1122                         Assert.AreEqual (false, itemCommand, "BeforeInsertCommandBubbleEvent");
1123                         Assert.AreEqual (false, itemInserting, "BeforeInsertBubbleEvent");
1124                         Assert.IsTrue (fv.DoOnBubbleEvent (bt, com), "OnBubbleEvent - Insert");
1125                         Assert.AreEqual (true, itemCommand, "AfterInsertCommandBubbleEvent");
1126                         Assert.AreEqual (true, itemInserting, "AfterInsertBubbleEvent");
1127
1128
1129                         //Update
1130                         itemCommand = false;
1131                         fv.ItemUpdating += new FormViewUpdateEventHandler (fv_ItemUpdating);
1132                         fv.ChangeMode (FormViewMode.Edit);
1133                         com = new FormViewCommandEventArgs (bt, new CommandEventArgs ("Update", null));
1134                         Assert.AreEqual (false, itemUpdating, "BeforeUpdateEvent");
1135                         Assert.AreEqual (false, itemCommand, "BeforeUpdateCommandEvent");
1136                         Assert.IsTrue (fv.DoOnBubbleEvent (bt, com), "OnBubbleEvent - Update");
1137                         Assert.AreEqual (true, itemCommand, "AfterUpdateCommandBubbleEvent");
1138                         Assert.AreEqual (true, itemUpdating, "AfterUpdateBubbleEvent");
1139
1140
1141                         //Cancel
1142                         itemCommand = false;
1143                         fv.ModeChanging += new FormViewModeEventHandler (fv_ModeChanging);
1144                         com = new FormViewCommandEventArgs (bt, new CommandEventArgs ("Cancel", null));
1145                         Assert.AreEqual (false, itemCommand, "BeforeCancelCommandBubbleEvent");
1146                         Assert.AreEqual (false, modeChanging, "BeforeCancelBubbleEvent");
1147                         Assert.IsTrue (fv.DoOnBubbleEvent (bt, com), "OnBubbleEvent - Cancel");
1148                         Assert.AreEqual (true, itemCommand, "AfterCancelCommandBubbleEvent");
1149                         Assert.AreEqual (true, modeChanging, "AfterCancelBubbleEvent");
1150
1151                         //Edit
1152                         itemCommand = false;
1153                         modeChanging = false;
1154                         com = new FormViewCommandEventArgs (bt, new CommandEventArgs ("Edit", null));
1155                         Assert.AreEqual (false, itemCommand, "BeforeEditCommandBubbleEvent");
1156                         Assert.AreEqual (false, modeChanging, "BeforeEditBubbleEvent");
1157                         Assert.IsTrue (fv.DoOnBubbleEvent (bt, com), "OnBubbleEvent - Edit");
1158                         Assert.AreEqual (true, itemCommand, "AfterEditCommandBubbleEvent");
1159                         Assert.AreEqual (true, modeChanging, "AfterEditBubbleEvent");
1160
1161                         //New
1162                         itemCommand = false;
1163                         modeChanging = false;
1164                         com = new FormViewCommandEventArgs (bt, new CommandEventArgs ("New", null));
1165                         Assert.AreEqual (false, itemCommand, "BeforeNewCommandBubbleEvent");
1166                         Assert.AreEqual (false, modeChanging, "BeforeNewBubbleEvent");
1167                         Assert.IsTrue (fv.DoOnBubbleEvent (bt, com), "OnBubbleEvent - New");
1168                         Assert.AreEqual (true, itemCommand, "AfterNewCommandBubbleEvent");
1169                         Assert.AreEqual (true, modeChanging, "AfterNewBubbleEvent");
1170
1171                         //Page Index default
1172                         itemCommand = false;
1173                         fv.PageIndexChanging += new FormViewPageEventHandler (fv_PageIndexChanging);
1174                         com = new FormViewCommandEventArgs (bt, new CommandEventArgs ("Page", null));
1175                         Assert.AreEqual (false, itemCommand, "BeforePageCommandBubbleEvent");
1176                         Assert.AreEqual (false, pageIndexChanging, "BeforePageBubbleEvent");
1177                         Assert.IsTrue (fv.DoOnBubbleEvent (bt, com), "OnBubbleEvent - Page Index default");
1178                         Assert.AreEqual (true, itemCommand, "AfterPageCommandBubbleEvent");
1179                         Assert.AreEqual (true, pageIndexChanging, "AfterPageBubbleEvent");
1180                         Assert.AreEqual (-1, newPageIndex, "PageIndex");
1181
1182                         //Next Page
1183                         itemCommand = false;
1184                         pageIndexChanging = false;
1185                         com = new FormViewCommandEventArgs (bt, new CommandEventArgs ("Page", "Next"));
1186                         Assert.AreEqual (false, itemCommand, "BeforeNextPageCommandBubbleEvent");
1187                         Assert.AreEqual (false, pageIndexChanging, "BeforeNextPageBubbleEvent");
1188                         Assert.IsTrue (fv.DoOnBubbleEvent (bt, com), "OnBubbleEvent - Next Page");
1189                         Assert.AreEqual (true, itemCommand, "AfterNextPageCommandBubbleEvent");
1190                         Assert.AreEqual (true, pageIndexChanging, "AfterNextPageBubbleEvent");
1191                         Assert.AreEqual (1, newPageIndex, "NextPageIndex");
1192
1193                         //Prev Page
1194                         itemCommand = false;
1195                         pageIndexChanging = false;
1196                         com = new FormViewCommandEventArgs (bt, new CommandEventArgs ("Page", "Prev"));
1197                         Assert.AreEqual (false, itemCommand, "BeforePrevPageCommandBubbleEvent");
1198                         Assert.AreEqual (false, pageIndexChanging, "BeforePrevPageBubbleEvent");
1199                         Assert.IsTrue (fv.DoOnBubbleEvent (bt, com), "OnBubbleEvent - Prev Page");
1200                         Assert.AreEqual (true, itemCommand, "AfterPrevPageCommandBubbleEvent");
1201                         Assert.AreEqual (true, pageIndexChanging, "AfterPrevPageBubbleEvent");
1202                         Assert.AreEqual (-1, newPageIndex, "PrevPageIndex");
1203
1204                         //First Page
1205                         itemCommand = false;
1206                         pageIndexChanging = false;
1207                         com = new FormViewCommandEventArgs (bt, new CommandEventArgs ("Page", "First"));
1208                         Assert.AreEqual (false, itemCommand, "BeforeFirstPageCommandBubbleEvent");
1209                         Assert.AreEqual (false, pageIndexChanging, "BeforeFirstPageBubbleEvent");
1210                         Assert.IsTrue (fv.DoOnBubbleEvent (bt, com), "OnBubbleEvent - First Page");
1211                         Assert.AreEqual (true, itemCommand, "AfterFirstPageCommandBubbleEvent");
1212                         Assert.AreEqual (true, pageIndexChanging, "AfterFirstPageBubbleEvent");
1213                         Assert.AreEqual (0, newPageIndex, "FirstPageIndex");
1214
1215                         //Last Page
1216                         itemCommand = false;
1217                         pageIndexChanging = false;
1218                         com = new FormViewCommandEventArgs (bt, new CommandEventArgs ("Page", "Last"));
1219                         Assert.AreEqual (false, itemCommand, "BeforeLastPageCommandBubbleEvent");
1220                         Assert.AreEqual (false, pageIndexChanging, "BeforeLastPageBubbleEvent");
1221                         Assert.IsTrue (fv.DoOnBubbleEvent (bt, com), "OnBubbleEvent - Last Page");
1222                         Assert.AreEqual (true, itemCommand, "AfterLastPageCommandBubbleEvent");
1223                         Assert.AreEqual (true, pageIndexChanging, "AfterLastPageBubbleEvent");
1224                         Assert.AreEqual (5, newPageIndex, "FirstPageIndex");
1225
1226                 }
1227
1228                 [Test]
1229                 [Category("NunitWeb")]
1230                 public void FormView_DataSourceChangedEvent ()
1231                 {
1232                         WebTest t = new WebTest();
1233                         PageDelegates pd = new PageDelegates ();
1234                         pd.Load = FormView_Init;
1235                         pd.PreRenderComplete = FormView_Load;
1236                         t.Invoker = new PageInvoker (pd);
1237                         t.Run ();
1238                         FormRequest fr = new FormRequest (t.Response, "form1");
1239                         fr.Controls.Add ("__EVENTTARGET");
1240                         fr.Controls.Add ("__EVENTARGUMENT");
1241                         fr.Controls["__EVENTTARGET"].Value = "";
1242                         fr.Controls["__EVENTARGUMENT"].Value = "";
1243                         t.Request = fr;
1244                         t.Run ();
1245                         if (t.UserData == null)
1246                                 Assert.Fail ("DataSourceChangedEvent#1");
1247                         Assert.AreEqual ("Data_rebounded", t.UserData.ToString (), "DataSourceChangedEvent#2");
1248                 }
1249
1250                 #region FormView_DataSourceChangedEvent
1251                 public static void FormView_Init(Page p)
1252                 {
1253                         Poker fv = new Poker ();
1254                         DS data = new DS ();
1255                         p.Controls.Add (fv);
1256                         p.Controls.Add (data);
1257                         data.TypeName = typeof (DS).AssemblyQualifiedName;
1258                         data.SelectMethod = "GetList";
1259                         data.ID = "Data";
1260                         fv.DataBinding += new EventHandler (data_DataBinding);
1261                         fv.DataSourceID = "Data";
1262                 }
1263
1264                 public static void FormView_Load (Page p)
1265                 {
1266                         if (p.IsPostBack) {
1267                                 DS data = (DS) p.FindControl ("Data") ;
1268                                 if (data == null)
1269                                         Assert.Fail ("Data soource control not created#1");
1270                                 data.DoRaiseDataSourceChangedEvent (new EventArgs ());
1271                         }
1272                 }
1273
1274                 public static void data_DataBinding (object sender, EventArgs e)
1275                 {
1276                         if (((WebControl) sender).Page.IsPostBack)
1277                                 WebTest.CurrentTest.UserData = "Data_rebounded";
1278                 }
1279                 #endregion
1280
1281                 [Test]
1282                 public void FormView_Events ()
1283                 {
1284                         ResetEvents ();
1285                         Poker fv = new Poker ();
1286                         fv.Page = new Page ();
1287                         fv.Init += new EventHandler (fv_Init);
1288                         fv.ItemCommand += new FormViewCommandEventHandler (fv_ItemCommand);
1289                         fv.ItemCreated += new EventHandler (fv_ItemCreated);
1290                         fv.ItemDeleted += new FormViewDeletedEventHandler (fv_ItemDeleted);
1291                         fv.ItemDeleting += new FormViewDeleteEventHandler (fv_ItemDeleting);
1292                         fv.ItemInserted += new FormViewInsertedEventHandler (fv_ItemInserted);
1293                         fv.ItemInserting += new FormViewInsertEventHandler (fv_ItemInserting);
1294                         fv.ItemUpdated += new FormViewUpdatedEventHandler (fv_ItemUpdated);
1295                         fv.ItemUpdating += new FormViewUpdateEventHandler (fv_ItemUpdating);
1296                         fv.ModeChanged += new EventHandler (fv_ModeChanged);
1297                         fv.ModeChanging += new FormViewModeEventHandler (fv_ModeChanging);
1298                         fv.PageIndexChanged += new EventHandler (fv_PageIndexChanged);
1299                         fv.PageIndexChanging += new FormViewPageEventHandler (fv_PageIndexChanging);
1300
1301                         Assert.AreEqual (false, init, "BeforeInit");
1302                         fv.DoOnInit (new EventArgs ());
1303                         Assert.AreEqual (true, init, "AfterInit");
1304                         Assert.AreEqual (false, itemCommand, "BeforeItemCommandEvent");
1305                         Button bt = new Button ();
1306                         fv.DoOnItemCommand (new FormViewCommandEventArgs (bt, new CommandEventArgs ("", null)));
1307                         Assert.AreEqual (true, itemCommand, "AfterItemCommandEvent");
1308                         Assert.AreEqual (false, itemCreated, "BeforeItemCreatedEvent");
1309                         fv.DoOnItemCreated (new EventArgs ());
1310                         Assert.AreEqual (true, itemCreated, "AfterItemCreatedEvent");
1311                         Assert.AreEqual (false, itemDeleted, "BeforeItemDeletedEvent");
1312                         fv.DoOnItemDeleted (new FormViewDeletedEventArgs (3, new Exception ()));
1313                         Assert.AreEqual (true, itemDeleted, "AfterItemDeletedEvent");
1314                         Assert.AreEqual (false, itemDeleting, "BeforeItemDeletingEvent");
1315                         fv.DoOnItemDeleting (new FormViewDeleteEventArgs (1));
1316                         Assert.AreEqual (true, itemDeleting, "AfterItemDeletingEvent");
1317                         Assert.AreEqual (false, itemInserted, "BeforeItemInsertedEvent");
1318                         fv.DoOnItemInserted (new FormViewInsertedEventArgs (2, new Exception ()));
1319                         Assert.AreEqual (true, itemInserted, "AfterItemInsetedEvent");
1320                         Assert.AreEqual (false, itemInserting, "BeforeItemInsertingEvent");
1321                         fv.DoOnItemInserting (new FormViewInsertEventArgs (bt));
1322                         Assert.AreEqual (true, itemInserting, "AfterItemInsetingEvent");
1323                         Assert.AreEqual (false, itemUpdated, "BeforeItemUpdatedEvent");
1324                         fv.DoOnItemUpdated (new FormViewUpdatedEventArgs (1, new Exception ()));
1325                         Assert.AreEqual (true, itemUpdated, "AfterItemUpdatedEvent");
1326                         Assert.AreEqual (false, itemUpdating, "BeforeItemUpdatingEvent");
1327                         fv.DoOnItemUpdating (new FormViewUpdateEventArgs (bt));
1328                         Assert.AreEqual (true, itemUpdating, "AfterItemUpdatingEvent");
1329                         Assert.AreEqual (false, modeChanged, "BeforeModeChangedEvent");
1330                         fv.DoOnModeChanged (new EventArgs ());
1331                         Assert.AreEqual (true, modeChanged, "AfterModeChangedEvent");
1332                         Assert.AreEqual (false, modeChanging, "BeforeModeChangingEvent");
1333                         fv.DoOnModeChanging (new FormViewModeEventArgs (FormViewMode.Edit, true));
1334                         Assert.AreEqual (true, modeChanging, "AfterModeChangingEvent");
1335                         Assert.AreEqual (false, pageIndexChanged, "BeforePageIndexChangedEvent");
1336                         fv.DoOnPageIndexChanged (new EventArgs ());
1337                         Assert.AreEqual (true, pageIndexChanged, "AfterPageIndexChangedEvent");
1338                         Assert.AreEqual (false, pageIndexChanging, "BeforePageIndexChangingEvent");
1339                         fv.DoOnPageIndexChanging (new FormViewPageEventArgs (1));
1340                         Assert.AreEqual (true, pageIndexChanging, "AfterPageIndexChangingEvent");
1341                 }
1342                 private void fv_Init (object sender, EventArgs e)
1343                 {
1344                         init = true;
1345                 }
1346
1347                 private void fv_ItemCommand (object sender, FormViewCommandEventArgs e)
1348                 {
1349                         itemCommand = true;
1350                 }
1351
1352                 private void fv_ItemCreated (object sender, EventArgs e)
1353                 {
1354                         itemCreated = true;
1355                 }
1356
1357                 private void fv_ItemDeleted (object sender, FormViewDeletedEventArgs e)
1358                 {
1359                         itemDeleted = true;
1360                 }
1361
1362                 private void fv_ItemDeleting (object sender, FormViewDeleteEventArgs e)
1363                 {
1364                         itemDeleting = true;
1365                 }
1366
1367                 private void fv_ItemInserted (object sender, FormViewInsertedEventArgs e)
1368                 {
1369                         itemInserted = true;
1370                 }
1371
1372                 private void fv_ItemInserting (object sender, FormViewInsertEventArgs e)
1373                 {
1374                         itemInserting = true;
1375                 }
1376
1377                 private void fv_ItemUpdated (object sender, FormViewUpdatedEventArgs e)
1378                 {
1379                         itemUpdated = true;
1380                 }
1381
1382                 private void fv_ItemUpdating (object sender, FormViewUpdateEventArgs e)
1383                 {
1384                         itemUpdating = true;
1385                 }
1386
1387                 private void fv_ModeChanged (object sender, EventArgs e)
1388                 {
1389                         modeChanged = true;
1390                 }
1391
1392                 private void fv_ModeChanging (object sender, FormViewModeEventArgs e)
1393                 {
1394                         modeChanging = true;
1395                 }
1396
1397                 private void fv_PageIndexChanged (object sender, EventArgs e)
1398                 {
1399                         pageIndexChanged = true;
1400                 }
1401                 private void fv_PageIndexChanging (object sender, FormViewPageEventArgs e)
1402                 {
1403                         pageIndexChanging = true;
1404                         newPageIndex = e.NewPageIndex;
1405                         e.NewPageIndex = -1;
1406                 }
1407
1408                 //Exceptions
1409                 [Test]
1410                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1411                 public void CellPaddingException ()
1412                 {
1413                        Poker p = new Poker ();
1414                         p.CellPadding = -2;
1415                 }
1416
1417                 [Test]
1418                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1419                 public void CellSpacingException ()
1420                 {
1421                         Poker p = new Poker ();
1422                         p.CellSpacing = -5;
1423                 }
1424
1425                 [Test]
1426                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1427                 public void PageIndexException ()
1428                 {
1429                         Poker p = new Poker ();
1430                         p.PageIndex = -5;
1431                 }
1432
1433                 [Test]
1434                 [ExpectedException (typeof (HttpException))]
1435                 public void InsertItemException ()
1436                 {
1437                         Poker p = new Poker ();
1438                         p.InsertItem (true);
1439                 }
1440
1441                 [Test]
1442                 [ExpectedException (typeof (HttpException))]
1443                 public void UpdateItemException ()
1444                 {
1445                         Poker p = new Poker ();
1446                         p.UpdateItem (true);
1447                 }
1448
1449
1450                 [Test]
1451                 [Category ("NotDotNet")] //TODO
1452                 public void PageIndex ()
1453                 {
1454                         ObjectDataSource ds = new ObjectDataSource ();
1455                         ds.ID = "ObjectDataSource1";
1456                         ds.TypeName = "System.Guid";
1457                         ds.SelectMethod = "ToByteArray";
1458                         Page p = new Page ();
1459                         Poker f = new Poker ();
1460                         f.Page = p;
1461                         ds.Page = p;
1462                         p.Controls.Add (f);
1463                         p.Controls.Add (ds);
1464                         f.DataSourceID = "ObjectDataSource1";
1465                         f.DoConfirmInitState ();
1466                         f.DoOnPreRender (EventArgs.Empty);
1467                         object cur = f.DataItem;
1468                         f.PageIndex = 1;
1469                         Assert.IsTrue (cur != f.DataItem, "#01");
1470
1471 CommandEventArgs cargs = new CommandEventArgs ("Page", "Prev");
1472                         FormViewCommandEventArgs fvargs = new FormViewCommandEventArgs (f, cargs);
1473                         f.DoOnBubbleEvent (f, fvargs);
1474                         Assert.IsTrue (f.OnPageIndexChangingCalled, "#02");
1475                         Assert.IsTrue (f.OnPageIndexChangedCalled, "#03");
1476                         f.OnPageIndexChangingCalled = false;
1477                         f.OnPageIndexChangedCalled = false;
1478
1479                         f.DoOnBubbleEvent (f, fvargs);
1480                         Assert.IsTrue (f.OnPageIndexChangingCalled, "#04");
1481                         Assert.IsFalse (f.OnPageIndexChangedCalled, "#05");
1482                         f.OnPageIndexChangingCalled = false;
1483                         f.OnPageIndexChangedCalled = false;
1484
1485                         f.PageIndex = f.PageCount - 1;
1486                         cargs = new CommandEventArgs ("Page", "Next");
1487                         fvargs = new FormViewCommandEventArgs (f, cargs);
1488                         f.DoOnBubbleEvent (f, fvargs);
1489                         Assert.IsTrue (f.OnPageIndexChangingCalled, "#06");
1490                         Assert.IsFalse (f.OnPageIndexChangedCalled, "#07");
1491                         f.OnPageIndexChangingCalled = false;
1492                         f.OnPageIndexChangedCalled = false;
1493                 }
1494
1495                 [Test]
1496                 public void PageCount ()
1497                 {
1498                         ObjectDataSource ds = new ObjectDataSource ();
1499                         ds.ID = "ObjectDataSource1";
1500                         ds.TypeName = "System.Guid";
1501                         ds.SelectMethod = "ToByteArray";
1502                         Page p = new Page ();
1503                         Poker f = new Poker ();
1504                         f.Page = p;
1505                         ds.Page = p;
1506                         p.Controls.Add (f);
1507                         p.Controls.Add (ds);
1508                         f.DataSourceID = "ObjectDataSource1";
1509                         f.DoConfirmInitState ();
1510                         f.DoOnPreRender (EventArgs.Empty);
1511                         f.PageIndex = 1;
1512                         Assert.AreEqual (16, f.PageCount, "#01");
1513                 }
1514
1515                 [Test]
1516                 public void InsertTemplate () {
1517                         ObjectDataSource ds = new ObjectDataSource ();
1518                         ds.ID = "ObjectDataSource1";
1519                         ds.TypeName = "System.Collections.ArrayList";
1520                         ds.SelectMethod = "ToArray";
1521                         Page p = new Page ();
1522                         Poker f = new Poker ();
1523                         Template itemTemplate = new Template ();
1524                         Template emptyTemplate = new Template ();
1525                         Template insertTemplate = new Template ();
1526                         f.ItemTemplate = itemTemplate;
1527                         f.EmptyDataTemplate = emptyTemplate;
1528                         f.InsertItemTemplate = insertTemplate;
1529                         f.DefaultMode = FormViewMode.Insert;
1530                         f.Page = p;
1531                         ds.Page = p;
1532                         p.Controls.Add (f);
1533                         p.Controls.Add (ds);
1534                         f.DataSourceID = "ObjectDataSource1";
1535                         f.DoConfirmInitState ();
1536                         f.DoOnPreRender (EventArgs.Empty);
1537
1538                         f.AllowPaging = true;
1539                         Assert.IsFalse(itemTemplate.Instantiated, "#01");
1540                         Assert.IsFalse(emptyTemplate.Instantiated, "#02");
1541                         Assert.IsTrue(insertTemplate.Instantiated, "#03");
1542                 }
1543
1544                 [TestFixtureTearDown]
1545                 public void TearDown ()
1546                 {
1547                         WebTest.Unload ();
1548                 }
1549
1550                 [Test]
1551                 [Category("NunitWeb")]
1552                 public void FormViewCssClass ()
1553                 {
1554                         string res = new WebTest ("FormView.aspx").Run ();
1555                         Assert.IsTrue (Regex.IsMatch (
1556                                 res, ".*<table[^>]*class=\"[^\"]*test1[^\"]*\"[^>]*>.*",
1557                                 RegexOptions.IgnoreCase|RegexOptions.Singleline),
1558                                 "check that <table class=\"test1\"> is found. Actual: "+res);
1559                         Assert.IsFalse (Regex.IsMatch (
1560                                 res, ".*<table[^>]*class=\"\"[^>]*>.*",
1561                                 RegexOptions.IgnoreCase|RegexOptions.Singleline),
1562                                 "check that <table class=\"\"> is not found. Actual: "+res);
1563                 }
1564
1565
1566
1567
1568                 [Test]
1569                 [Category ("NunitWeb")]
1570                 public void FormView_RenderSimpleTemplate()
1571                 {
1572                         string renderedPageHtml = new WebTest ("FormViewTest1.aspx").Run ();
1573                         string newHtmlValue = HtmlDiff.GetControlFromPageHtml (renderedPageHtml);
1574 #if NET_4_0
1575                         string origHtmlValue = "<table cellspacing=\"2\" cellpadding=\"3\" rules=\"all\" id=\"FormView1\" style=\"background-color:#DEBA84;border-color:#DEBA84;border-width:1px;border-style:None;\">\r\n\t<tr style=\"color:#8C4510;background-color:#FFF7E7;\">\r\n\t\t<td colspan=\"2\">\n                <span id=\"FormView1_Label1\">1</span>\n            </td>\r\n\t</tr><tr align=\"center\" style=\"color:#8C4510;\">\r\n\t\t<td colspan=\"2\"><table>\r\n\t\t\t<tr>\r\n\t\t\t\t<td><span>1</span></td><td><a href=\"javascript:__doPostBack(&#39;FormView1&#39;,&#39;Page$2&#39;)\" style=\"color:#8C4510;\">2</a></td><td><a href=\"javascript:__doPostBack(&#39;FormView1&#39;,&#39;Page$3&#39;)\" style=\"color:#8C4510;\">3</a></td><td><a href=\"javascript:__doPostBack(&#39;FormView1&#39;,&#39;Page$4&#39;)\" style=\"color:#8C4510;\">4</a></td><td><a href=\"javascript:__doPostBack(&#39;FormView1&#39;,&#39;Page$5&#39;)\" style=\"color:#8C4510;\">5</a></td><td><a href=\"javascript:__doPostBack(&#39;FormView1&#39;,&#39;Page$6&#39;)\" style=\"color:#8C4510;\">6</a></td>\r\n\t\t\t</tr>\r\n\t\t</table></td>\r\n\t</tr>\r\n</table>";
1576 #else
1577                         string origHtmlValue = "<table cellspacing=\"2\" cellpadding=\"3\" rules=\"all\" border=\"1\" id=\"FormView1\" style=\"background-color:#DEBA84;border-color:#DEBA84;border-width:1px;border-style:None;\">\r\n\t<tr style=\"color:#8C4510;background-color:#FFF7E7;\">\r\n\t\t<td colspan=\"2\">\n                <span id=\"FormView1_Label1\">1</span>\n            </td>\r\n\t</tr><tr align=\"center\" style=\"color:#8C4510;\">\r\n\t\t<td colspan=\"2\"><table border=\"0\">\r\n\t\t\t<tr>\r\n\t\t\t\t<td><span>1</span></td><td><a href=\"javascript:__doPostBack('FormView1','Page$2')\" style=\"color:#8C4510;\">2</a></td><td><a href=\"javascript:__doPostBack('FormView1','Page$3')\" style=\"color:#8C4510;\">3</a></td><td><a href=\"javascript:__doPostBack('FormView1','Page$4')\" style=\"color:#8C4510;\">4</a></td><td><a href=\"javascript:__doPostBack('FormView1','Page$5')\" style=\"color:#8C4510;\">5</a></td><td><a href=\"javascript:__doPostBack('FormView1','Page$6')\" style=\"color:#8C4510;\">6</a></td>\r\n\t\t\t</tr>\r\n\t\t</table></td>\r\n\t</tr>\r\n</table>";
1578 #endif
1579
1580                         HtmlDiff.AssertAreEqual (origHtmlValue, newHtmlValue, "RenderSimpleTemplate");
1581                 }
1582
1583                 [Test]
1584                 [Category ("NunitWeb")]
1585                 public void FormView_RenderFooterAndPager()
1586                 {
1587                         string renderedPageHtml = new WebTest ("FormViewTest1_2.aspx").Run ();
1588                         string newHtmlValue = HtmlDiff.GetControlFromPageHtml (renderedPageHtml);
1589 #if NET_4_0
1590                         string origHtmlValue = "<table cellspacing=\"0\" cellpadding=\"4\" id=\"FormView2\" style=\"color:#333333;border-collapse:collapse;\">\r\n\t<tr style=\"color:#333333;background-color:#F7F6F3;\">\r\n\t\t<td colspan=\"2\">\n                <span id=\"FormView2_Label2\">1</span>\n            </td>\r\n\t</tr><tr style=\"color:White;background-color:#5D7B9D;font-weight:bold;\">\r\n\t\t<td colspan=\"2\">\n                <span id=\"FormView2_Label3\">Footer Template Test</span>\n            </td>\r\n\t</tr><tr align=\"center\" style=\"color:White;background-color:#284775;\">\r\n\t\t<td colspan=\"2\">\n                <input type=\"submit\" name=\"FormView2$ctl01$Button1\" value=\"Prev Item\" id=\"FormView2_ctl01_Button1\" />\n                <input type=\"submit\" name=\"FormView2$ctl01$Button2\" value=\"Next Item\" id=\"FormView2_ctl01_Button2\" />\n                <input type=\"submit\" name=\"FormView2$ctl01$Button3\" value=\"First Item\" id=\"FormView2_ctl01_Button3\" />\n                <input type=\"submit\" name=\"FormView2$ctl01$Button4\" value=\"Last Item\" id=\"FormView2_ctl01_Button4\" />\n            </td>\r\n\t</tr>\r\n</table>";
1591 #else
1592                         string origHtmlValue = "<table cellspacing=\"0\" cellpadding=\"4\" border=\"0\" id=\"FormView2\" style=\"color:#333333;border-collapse:collapse;\">\r\n\t<tr style=\"color:#333333;background-color:#F7F6F3;\">\r\n\t\t<td colspan=\"2\">\n                <span id=\"FormView2_Label2\">1</span>\n            </td>\r\n\t</tr><tr style=\"color:White;background-color:#5D7B9D;font-weight:bold;\">\r\n\t\t<td colspan=\"2\">\n                <span id=\"FormView2_Label3\">Footer Template Test</span>\n            </td>\r\n\t</tr><tr align=\"center\" style=\"color:White;background-color:#284775;\">\r\n\t\t<td colspan=\"2\">\n                <input type=\"submit\" name=\"FormView2$ctl01$Button1\" value=\"Prev Item\" id=\"FormView2_ctl01_Button1\" />\n                <input type=\"submit\" name=\"FormView2$ctl01$Button2\" value=\"Next Item\" id=\"FormView2_ctl01_Button2\" />\n                <input type=\"submit\" name=\"FormView2$ctl01$Button3\" value=\"First Item\" id=\"FormView2_ctl01_Button3\" />\n                <input type=\"submit\" name=\"FormView2$ctl01$Button4\" value=\"Last Item\" id=\"FormView2_ctl01_Button4\" />\n            </td>\r\n\t</tr>\r\n</table>";
1593 #endif
1594                         HtmlDiff.AssertAreEqual (origHtmlValue, newHtmlValue, "FormView_RenderFooterAndPager");
1595                 }
1596
1597                 [Test]
1598                 [Category ("NunitWeb")]
1599                 public void FormView_RenderWithHeader()
1600                 {
1601                         string renderedPageHtml = new WebTest ("FormViewTest1_4.aspx").Run ();
1602                         string newHtmlValue = HtmlDiff.GetControlFromPageHtml (renderedPageHtml);
1603 #if NET_4_0
1604                         string origHtmlValue = "<table cellspacing=\"10\" cellpadding=\"3\" align=\"Right\" rules=\"all\" id=\"FormView4\" style=\"background-color:White;border-color:#CCCCCC;border-width:1px;border-style:None;\">\r\n\t<tr align=\"left\" style=\"color:White;background-color:#006699;font-weight:bold;\">\r\n\t\t<td colspan=\"2\">Using Header Text property</td>\r\n\t</tr><tr align=\"center\" style=\"color:#000066;background-color:Maroon;\">\r\n\t\t<td colspan=\"2\">Using Footer Text property</td>\r\n\t</tr><tr align=\"left\" style=\"color:#000066;background-color:LightGrey;\">\r\n\t\t<td colspan=\"2\">\n                <a id=\"FormView4_ctl01_LinkButton1\" href=\"javascript:__doPostBack(&#39;FormView4$ctl01$LinkButton1&#39;,&#39;&#39;)\">Next</a>\n                <a id=\"FormView4_ctl01_LinkButton2\" href=\"javascript:__doPostBack(&#39;FormView4$ctl01$LinkButton2&#39;,&#39;&#39;)\">Prev</a>\n                <span id=\"FormView4_ctl01_Label7\">Page Index: 0</span>\n            </td>\r\n\t</tr>\r\n</table>";
1605 #else
1606                         string origHtmlValue = "<table cellspacing=\"10\" cellpadding=\"3\" align=\"Right\" rules=\"all\" border=\"1\" id=\"FormView4\" style=\"background-color:White;border-color:#CCCCCC;border-width:1px;border-style:None;\">\r\n\t<tr align=\"left\" style=\"color:White;background-color:#006699;font-weight:bold;\">\r\n\t\t<td colspan=\"2\">Using Header Text property</td>\r\n\t</tr><tr align=\"center\" style=\"color:#000066;background-color:Maroon;\">\r\n\t\t<td colspan=\"2\">Using Footer Text property</td>\r\n\t</tr><tr align=\"left\" style=\"color:#000066;background-color:LightGrey;\">\r\n\t\t<td colspan=\"2\">\n                <a id=\"FormView4_ctl01_LinkButton1\" href=\"javascript:__doPostBack('FormView4$ctl01$LinkButton1','')\">Next</a>\n                <a id=\"FormView4_ctl01_LinkButton2\" href=\"javascript:__doPostBack('FormView4$ctl01$LinkButton2','')\">Prev</a>\n                <span id=\"FormView4_ctl01_Label7\">Page Index: 0</span>\n            </td>\r\n\t</tr>\r\n</table>";
1607 #endif
1608                         HtmlDiff.AssertAreEqual (origHtmlValue, newHtmlValue, "RenderingDefaultPaging");
1609                 }
1610
1611
1612                 [Test]
1613                 [Category ("NunitWeb")]
1614                 public void FormView_Render ()
1615                 {
1616                         string RenderedPageHtml = new WebTest ("FormViewTest1_3.aspx").Run ();
1617                         string newHtmlValue = HtmlDiff.GetControlFromPageHtml (RenderedPageHtml);
1618 #if NET_4_0
1619                         string origHtmlValue = "<table cellspacing=\"0\" cellpadding=\"2\" id=\"FormView3\" style=\"color:Black;background-color:LightGoldenrodYellow;border-color:Tan;border-width:1px;border-style:solid;border-collapse:collapse;\">\r\n\t<tr align=\"center\" valign=\"top\" style=\"color:#C00000;background-color:Tan;font-weight:bold;\">\r\n\t\t<td colspan=\"2\">\n                <span id=\"FormView3_Label5\">Header Template Test</span>\n            </td>\r\n\t</tr><tr>\r\n\t\t<td colspan=\"2\">\n                <span id=\"FormView3_Label4\">1</span>\n            </td>\r\n\t</tr><tr align=\"right\" style=\"color:#FFC0FF;background-color:Tan;\">\r\n\t\t<td colspan=\"2\">\n                <span id=\"FormView3_Label6\">FormView Footer</span>\n            </td>\r\n\t</tr><tr align=\"center\" style=\"color:DarkSlateBlue;background-color:PaleGoldenrod;\">\r\n\t\t<td colspan=\"2\"><table>\r\n\t\t\t<tr>\r\n\t\t\t\t<td><span>1</span></td><td><a href=\"javascript:__doPostBack(&#39;FormView3&#39;,&#39;Page$2&#39;)\" style=\"color:DarkSlateBlue;\">2</a></td><td><a href=\"javascript:__doPostBack(&#39;FormView3&#39;,&#39;Page$3&#39;)\" style=\"color:DarkSlateBlue;\">3</a></td><td><a href=\"javascript:__doPostBack(&#39;FormView3&#39;,&#39;Page$4&#39;)\" style=\"color:DarkSlateBlue;\">4</a></td><td><a href=\"javascript:__doPostBack(&#39;FormView3&#39;,&#39;Page$5&#39;)\" style=\"color:DarkSlateBlue;\">5</a></td><td><a href=\"javascript:__doPostBack(&#39;FormView3&#39;,&#39;Page$6&#39;)\" style=\"color:DarkSlateBlue;\">6</a></td>\r\n\t\t\t</tr>\r\n\t\t</table></td>\r\n\t</tr>\r\n</table>";
1620 #else
1621                         string origHtmlValue = "<table cellspacing=\"0\" cellpadding=\"2\" border=\"0\" id=\"FormView3\" style=\"color:Black;background-color:LightGoldenrodYellow;border-color:Tan;border-width:1px;border-style:solid;border-collapse:collapse;\">\r\n\t<tr align=\"center\" valign=\"top\" style=\"color:#C00000;background-color:Tan;font-weight:bold;\">\r\n\t\t<td colspan=\"2\">\n                <span id=\"FormView3_Label5\">Header Template Test</span>\n            </td>\r\n\t</tr><tr>\r\n\t\t<td colspan=\"2\">\n                <span id=\"FormView3_Label4\">1</span>\n            </td>\r\n\t</tr><tr align=\"right\" style=\"color:#FFC0FF;background-color:Tan;\">\r\n\t\t<td colspan=\"2\">\n                <span id=\"FormView3_Label6\">FormView Footer</span>\n            </td>\r\n\t</tr><tr align=\"center\" style=\"color:DarkSlateBlue;background-color:PaleGoldenrod;\">\r\n\t\t<td colspan=\"2\"><table border=\"0\">\r\n\t\t\t<tr>\r\n\t\t\t\t<td><span>1</span></td><td><a href=\"javascript:__doPostBack('FormView3','Page$2')\" style=\"color:DarkSlateBlue;\">2</a></td><td><a href=\"javascript:__doPostBack('FormView3','Page$3')\" style=\"color:DarkSlateBlue;\">3</a></td><td><a href=\"javascript:__doPostBack('FormView3','Page$4')\" style=\"color:DarkSlateBlue;\">4</a></td><td><a href=\"javascript:__doPostBack('FormView3','Page$5')\" style=\"color:DarkSlateBlue;\">5</a></td><td><a href=\"javascript:__doPostBack('FormView3','Page$6')\" style=\"color:DarkSlateBlue;\">6</a></td>\r\n\t\t\t</tr>\r\n\t\t</table></td>\r\n\t</tr>\r\n</table>";
1622 #endif
1623                         HtmlDiff.AssertAreEqual (origHtmlValue, newHtmlValue, "RenderingDefaultPaging");
1624                 }
1625
1626
1627                 [Test]
1628                 [Category ("NunitWeb")]
1629                 public void FormView_EditPostback ()
1630                 {
1631                         WebTest t = new WebTest ("FormViewInsertEditDelete.aspx");
1632                         string pageHTML = t.Run ();
1633                         string newHtml = HtmlDiff.GetControlFromPageHtml (pageHTML);
1634 #if NET_4_0
1635                         string origHtml = "<table cellspacing=\"0\" id=\"FormView1\" style=\"border-collapse:collapse;\">\r\n\t<tr>\r\n\t\t<td colspan=\"2\">\n                    <span id=\"FormView1_ID\">1001</span>&nbsp;\n                    <span id=\"FormView1_LName\">Chand</span>\n                    <span id=\"FormView1_FName\">Mahesh</span>&nbsp;\n                    <a id=\"FormView1_EditButton\" href=\"javascript:__doPostBack(&#39;FormView1$EditButton&#39;,&#39;&#39;)\">Edit</a>\n                    <a id=\"FormView1_NewButton\" href=\"javascript:__doPostBack(&#39;FormView1$NewButton&#39;,&#39;&#39;)\">New</a>\n                    <a id=\"FormView1_DeleteButton\" href=\"javascript:__doPostBack(&#39;FormView1$DeleteButton&#39;,&#39;&#39;)\">Delete</a>\n                </td>\r\n\t</tr><tr>\r\n\t\t<td colspan=\"2\"><table>\r\n\t\t\t<tr>\r\n\t\t\t\t<td><span>1</span></td><td><a href=\"javascript:__doPostBack(&#39;FormView1&#39;,&#39;Page$2&#39;)\">2</a></td><td><a href=\"javascript:__doPostBack(&#39;FormView1&#39;,&#39;Page$3&#39;)\">3</a></td>\r\n\t\t\t</tr>\r\n\t\t</table></td>\r\n\t</tr>\r\n</table>";
1636 #else
1637                         string origHtml = "<table cellspacing=\"0\" border=\"0\" id=\"FormView1\" style=\"border-collapse:collapse;\">\r\n\t<tr>\r\n\t\t<td colspan=\"2\">\n                    <span id=\"FormView1_ID\">1001</span>&nbsp;\n                    <span id=\"FormView1_LName\">Chand</span>\n                    <span id=\"FormView1_FName\">Mahesh</span>&nbsp;\n                    <a id=\"FormView1_EditButton\" href=\"javascript:__doPostBack('FormView1$EditButton','')\">Edit</a>\n                    <a id=\"FormView1_NewButton\" href=\"javascript:__doPostBack('FormView1$NewButton','')\">New</a>\n                    <a id=\"FormView1_DeleteButton\" href=\"javascript:__doPostBack('FormView1$DeleteButton','')\">Delete</a>\n                </td>\r\n\t</tr><tr>\r\n\t\t<td colspan=\"2\"><table border=\"0\">\r\n\t\t\t<tr>\r\n\t\t\t\t<td><span>1</span></td><td><a href=\"javascript:__doPostBack('FormView1','Page$2')\">2</a></td><td><a href=\"javascript:__doPostBack('FormView1','Page$3')\">3</a></td>\r\n\t\t\t</tr>\r\n\t\t</table></td>\r\n\t</tr>\r\n</table>";
1638 #endif
1639                         HtmlDiff.AssertAreEqual (origHtml, newHtml, "BeforeEditPostback");
1640
1641                         //Edit button postback (change to edit mode - buttons "Update" and "Cancel" should appear.
1642
1643                         FormRequest fr = new FormRequest (t.Response, "form1");
1644                         fr.Controls.Add ("__EVENTTARGET");
1645                         fr.Controls.Add ("__EVENTARGUMENT");
1646                         fr.Controls["__EVENTTARGET"].Value = "FormView1$EditButton";
1647                         fr.Controls["__EVENTARGUMENT"].Value = "";
1648                         t.Request = fr;
1649                         pageHTML = t.Run ();
1650                         newHtml = HtmlDiff.GetControlFromPageHtml (pageHTML);
1651 #if NET_4_0
1652                         origHtml = "<table cellspacing=\"0\" id=\"FormView1\" style=\"border-collapse:collapse;\">\r\n\t<tr>\r\n\t\t<td colspan=\"2\">\n                    Enter First Name:<input name=\"FormView1$FNameEdit\" type=\"text\" value=\"Mahesh\" id=\"FormView1_FNameEdit\" /><br />\n                    Enter Last Name:<input name=\"FormView1$LNameEdit\" type=\"text\" value=\"Chand\" id=\"FormView1_LNameEdit\" /><br />\n                    <a id=\"FormView1_UpdateButton\" href=\"javascript:__doPostBack(&#39;FormView1$UpdateButton&#39;,&#39;&#39;)\">Update</a>\n                    <a id=\"FormView1_CancelUpdateButton\" href=\"javascript:__doPostBack(&#39;FormView1$CancelUpdateButton&#39;,&#39;&#39;)\">Cancel</a>\n                </td>\r\n\t</tr><tr>\r\n\t\t<td colspan=\"2\"><table>\r\n\t\t\t<tr>\r\n\t\t\t\t<td><span>1</span></td><td><a href=\"javascript:__doPostBack(&#39;FormView1&#39;,&#39;Page$2&#39;)\">2</a></td><td><a href=\"javascript:__doPostBack(&#39;FormView1&#39;,&#39;Page$3&#39;)\">3</a></td>\r\n\t\t\t</tr>\r\n\t\t</table></td>\r\n\t</tr>\r\n</table>";
1653 #else
1654                         origHtml = "<table cellspacing=\"0\" border=\"0\" id=\"FormView1\" style=\"border-collapse:collapse;\">\r\n\t<tr>\r\n\t\t<td colspan=\"2\">\n                    Enter First Name:<input name=\"FormView1$FNameEdit\" type=\"text\" value=\"Mahesh\" id=\"FormView1_FNameEdit\" /><br />\n                    Enter Last Name:<input name=\"FormView1$LNameEdit\" type=\"text\" value=\"Chand\" id=\"FormView1_LNameEdit\" /><br />\n                    <a id=\"FormView1_UpdateButton\" href=\"javascript:__doPostBack('FormView1$UpdateButton','')\">Update</a>\n                    <a id=\"FormView1_CancelUpdateButton\" href=\"javascript:__doPostBack('FormView1$CancelUpdateButton','')\">Cancel</a>\n                </td>\r\n\t</tr><tr>\r\n\t\t<td colspan=\"2\"><table border=\"0\">\r\n\t\t\t<tr>\r\n\t\t\t\t<td><span>1</span></td><td><a href=\"javascript:__doPostBack('FormView1','Page$2')\">2</a></td><td><a href=\"javascript:__doPostBack('FormView1','Page$3')\">3</a></td>\r\n\t\t\t</tr>\r\n\t\t</table></td>\r\n\t</tr>\r\n</table>";
1655 #endif
1656                         HtmlDiff.AssertAreEqual (origHtml, newHtml, "AfterEditPostback");
1657
1658                         //Update record postback
1659
1660                         fr = new FormRequest (t.Response, "form1");
1661                         fr.Controls.Add ("__EVENTTARGET");
1662                         fr.Controls.Add ("__EVENTARGUMENT");
1663                         fr.Controls.Add ("FormView1$FNameEdit");
1664                         fr.Controls.Add ("FormView1$LNameEdit");
1665                         fr.Controls["__EVENTTARGET"].Value = "FormView1$UpdateButton";
1666                         fr.Controls["__EVENTARGUMENT"].Value = "";
1667                         fr.Controls["FormView1$FNameEdit"].Value = "Merav";
1668                         fr.Controls["FormView1$LNameEdit"].Value = "Test";
1669                         t.Request = fr;
1670                         pageHTML = t.Run ();
1671                         newHtml = HtmlDiff.GetControlFromPageHtml (pageHTML);
1672 #if NET_4_0
1673                         origHtml = "<table cellspacing=\"0\" id=\"FormView1\" style=\"border-collapse:collapse;\">\r\n\t<tr>\r\n\t\t<td colspan=\"2\">\n                    <span id=\"FormView1_ID\">1001</span>&nbsp;\n                    <span id=\"FormView1_LName\">Test</span>\n                    <span id=\"FormView1_FName\">Merav</span>&nbsp;\n                    <a id=\"FormView1_EditButton\" href=\"javascript:__doPostBack(&#39;FormView1$EditButton&#39;,&#39;&#39;)\">Edit</a>\n                    <a id=\"FormView1_NewButton\" href=\"javascript:__doPostBack(&#39;FormView1$NewButton&#39;,&#39;&#39;)\">New</a>\n                    <a id=\"FormView1_DeleteButton\" href=\"javascript:__doPostBack(&#39;FormView1$DeleteButton&#39;,&#39;&#39;)\">Delete</a>\n                </td>\r\n\t</tr><tr>\r\n\t\t<td colspan=\"2\"><table>\r\n\t\t\t<tr>\r\n\t\t\t\t<td><span>1</span></td><td><a href=\"javascript:__doPostBack(&#39;FormView1&#39;,&#39;Page$2&#39;)\">2</a></td><td><a href=\"javascript:__doPostBack(&#39;FormView1&#39;,&#39;Page$3&#39;)\">3</a></td>\r\n\t\t\t</tr>\r\n\t\t</table></td>\r\n\t</tr>\r\n</table>";
1674 #else
1675                         origHtml = "<table cellspacing=\"0\" border=\"0\" id=\"FormView1\" style=\"border-collapse:collapse;\">\r\n\t<tr>\r\n\t\t<td colspan=\"2\">\n                    <span id=\"FormView1_ID\">1001</span>&nbsp;\n                    <span id=\"FormView1_LName\">Test</span>\n                    <span id=\"FormView1_FName\">Merav</span>&nbsp;\n                    <a id=\"FormView1_EditButton\" href=\"javascript:__doPostBack('FormView1$EditButton','')\">Edit</a>\n                    <a id=\"FormView1_NewButton\" href=\"javascript:__doPostBack('FormView1$NewButton','')\">New</a>\n                    <a id=\"FormView1_DeleteButton\" href=\"javascript:__doPostBack('FormView1$DeleteButton','')\">Delete</a>\n                </td>\r\n\t</tr><tr>\r\n\t\t<td colspan=\"2\"><table border=\"0\">\r\n\t\t\t<tr>\r\n\t\t\t\t<td><span>1</span></td><td><a href=\"javascript:__doPostBack('FormView1','Page$2')\">2</a></td><td><a href=\"javascript:__doPostBack('FormView1','Page$3')\">3</a></td>\r\n\t\t\t</tr>\r\n\t\t</table></td>\r\n\t</tr>\r\n</table>";
1676 #endif
1677                         HtmlDiff.AssertAreEqual (origHtml, newHtml, "AfterUpdatePostback");
1678
1679                         //Postback to return to Edit mode
1680                         fr = new FormRequest (t.Response, "form1");
1681                         fr.Controls.Add ("__EVENTTARGET");
1682                         fr.Controls.Add ("__EVENTARGUMENT");
1683                         fr.Controls["__EVENTTARGET"].Value = "FormView1$EditButton";
1684                         fr.Controls["__EVENTARGUMENT"].Value = "";
1685                         t.Request = fr;
1686                         pageHTML = t.Run ();
1687                         newHtml = pageHTML.Substring (pageHTML.IndexOf ("start") + 5, pageHTML.IndexOf ("end") - pageHTML.IndexOf ("start") - 5);
1688                         Assert.AreEqual (true, pageHTML.Contains ("Merav"), "EditModePostback1");
1689                         Assert.AreEqual (true, pageHTML.Contains ("CancelUpdateButton"), "EditModePostback2");
1690
1691                         // Cancel edited record postback
1692                         fr = new FormRequest (t.Response, "form1");
1693                         fr.Controls.Add ("__EVENTTARGET");
1694                         fr.Controls.Add ("__EVENTARGUMENT");
1695                         fr.Controls.Add ("FormView1$FNameEdit");
1696                         fr.Controls.Add ("FormView1$LNameEdit");
1697                         fr.Controls["FormView1$FNameEdit"].Value = "EditFirstName";
1698                         fr.Controls["FormView1$LNameEdit"].Value = "EditLastName";
1699                         fr.Controls["__EVENTTARGET"].Value = "FormView1$CancelUpdateButton";
1700                         fr.Controls["__EVENTARGUMENT"].Value = "";
1701                         t.Request = fr;
1702                         pageHTML = t.Run ();
1703                         newHtml = HtmlDiff.GetControlFromPageHtml (pageHTML);
1704 #if NET_4_0
1705                         origHtml = "<table cellspacing=\"0\" id=\"FormView1\" style=\"border-collapse:collapse;\">\r\n\t<tr>\r\n\t\t<td colspan=\"2\">\n                    <span id=\"FormView1_ID\">1001</span>&nbsp;\n                    <span id=\"FormView1_LName\">Test</span>\n                    <span id=\"FormView1_FName\">Merav</span>&nbsp;\n                    <a id=\"FormView1_EditButton\" href=\"javascript:__doPostBack(&#39;FormView1$EditButton&#39;,&#39;&#39;)\">Edit</a>\n                    <a id=\"FormView1_NewButton\" href=\"javascript:__doPostBack(&#39;FormView1$NewButton&#39;,&#39;&#39;)\">New</a>\n                    <a id=\"FormView1_DeleteButton\" href=\"javascript:__doPostBack(&#39;FormView1$DeleteButton&#39;,&#39;&#39;)\">Delete</a>\n                </td>\r\n\t</tr><tr>\r\n\t\t<td colspan=\"2\"><table>\r\n\t\t\t<tr>\r\n\t\t\t\t<td><span>1</span></td><td><a href=\"javascript:__doPostBack(&#39;FormView1&#39;,&#39;Page$2&#39;)\">2</a></td><td><a href=\"javascript:__doPostBack(&#39;FormView1&#39;,&#39;Page$3&#39;)\">3</a></td>\r\n\t\t\t</tr>\r\n\t\t</table></td>\r\n\t</tr>\r\n</table>";
1706 #else
1707                         origHtml = "<table cellspacing=\"0\" border=\"0\" id=\"FormView1\" style=\"border-collapse:collapse;\">\r\n\t<tr>\r\n\t\t<td colspan=\"2\">\n                    <span id=\"FormView1_ID\">1001</span>&nbsp;\n                    <span id=\"FormView1_LName\">Test</span>\n                    <span id=\"FormView1_FName\">Merav</span>&nbsp;\n                    <a id=\"FormView1_EditButton\" href=\"javascript:__doPostBack('FormView1$EditButton','')\">Edit</a>\n                    <a id=\"FormView1_NewButton\" href=\"javascript:__doPostBack('FormView1$NewButton','')\">New</a>\n                    <a id=\"FormView1_DeleteButton\" href=\"javascript:__doPostBack('FormView1$DeleteButton','')\">Delete</a>\n                </td>\r\n\t</tr><tr>\r\n\t\t<td colspan=\"2\"><table border=\"0\">\r\n\t\t\t<tr>\r\n\t\t\t\t<td><span>1</span></td><td><a href=\"javascript:__doPostBack('FormView1','Page$2')\">2</a></td><td><a href=\"javascript:__doPostBack('FormView1','Page$3')\">3</a></td>\r\n\t\t\t</tr>\r\n\t\t</table></td>\r\n\t</tr>\r\n</table>";
1708 #endif
1709                         HtmlDiff.AssertAreEqual (origHtml, newHtml, "CancelEditedRecordPostback");
1710                 }
1711
1712                 [Test (Description="Bug #578863")]
1713                 public void FormView_PagerSettings_Visibility ()
1714                 {
1715 #if NET_4_0
1716                         string origHtml = "<table cellspacing=\"2\" cellpadding=\"3\" rules=\"all\" id=\"FormView1\" style=\"background-color:#DEBA84;border-color:#DEBA84;border-width:1px;border-style:None;\">\r\n\t<tr style=\"color:#8C4510;background-color:#FFF7E7;\">\r\n\t\t<td colspan=\"2\">\n          <span id=\"FormView1_Label1\">1</span>\n\t</td>\r\n\t</tr>\r\n</table>";
1717 #else
1718                         string origHtml = "<table cellspacing=\"2\" cellpadding=\"3\" rules=\"all\" border=\"1\" id=\"FormView1\" style=\"background-color:#DEBA84;border-color:#DEBA84;border-width:1px;border-style:None;\">\r\n\t<tr style=\"color:#8C4510;background-color:#FFF7E7;\">\r\n\t\t<td colspan=\"2\">\n          <span id=\"FormView1_Label1\">1</span>\n\t</td>\r\n\t</tr>\r\n</table>";
1719 #endif
1720                         WebTest t = new WebTest ("FormViewPagerVisibility.aspx");
1721                         string pageHtml = t.Run ();
1722                         string renderedHtml = HtmlDiff.GetControlFromPageHtml (pageHtml);
1723
1724                         HtmlDiff.AssertAreEqual (origHtml, renderedHtml, "#A1");
1725                 }
1726
1727                 [Test]
1728                 [Category ("NunitWeb")]
1729                 public void FormView_FireEvent_1 ()
1730                 {
1731                         WebTest t = new WebTest ("FormViewInsertEditDelete.aspx");
1732                         t.Invoker = PageInvoker.CreateOnInit (EditPostbackFireEvent_Init);
1733                         string html = t.Run ();
1734                         //Edit button postback (change to edit mode - buttons "Update" and "Cancel" should appear.
1735
1736                         FormRequest fr = new FormRequest (t.Response, "form1");
1737                         fr.Controls.Add ("__EVENTTARGET");
1738                         fr.Controls.Add ("__EVENTARGUMENT");
1739                         fr.Controls["__EVENTTARGET"].Value = "FormView1$EditButton";
1740                         fr.Controls["__EVENTARGUMENT"].Value = "";
1741                         t.Request = fr;
1742                         html = t.Run ();
1743
1744                         ArrayList eventlist = t.UserData as ArrayList;
1745                         if (eventlist == null)
1746                                 Assert.Fail ("User data does not been created fail");
1747
1748                         Assert.AreEqual ("ItemCommand", eventlist[0], "#1");
1749                         Assert.AreEqual ("ModeChanging", eventlist[1], "#2");
1750                         Assert.AreEqual ("ModeChanged", eventlist[2], "#3");
1751                         t.UserData = null;
1752
1753                         //Update record postback
1754
1755                         fr = new FormRequest (t.Response, "form1");
1756                         fr.Controls.Add ("__EVENTTARGET");
1757                         fr.Controls.Add ("__EVENTARGUMENT");
1758                         fr.Controls.Add ("FormView1$FNameEdit");
1759                         fr.Controls.Add ("FormView1$LNameEdit");
1760                         fr.Controls["__EVENTTARGET"].Value = "FormView1$UpdateButton";
1761                         fr.Controls["__EVENTARGUMENT"].Value = "";
1762                         fr.Controls["FormView1$FNameEdit"].Value = "Merav";
1763                         fr.Controls["FormView1$LNameEdit"].Value = "Test";
1764                         t.Request = fr;
1765                         html = t.Run ();
1766
1767                         eventlist = t.UserData as ArrayList;
1768                         if (eventlist == null)
1769                                 Assert.Fail ("User data does not been created fail");
1770
1771                         Assert.AreEqual ("ItemCommand", eventlist[0], "#1");
1772                         Assert.AreEqual ("ItemUpdating", eventlist[1], "#2");
1773                         Assert.AreEqual ("ItemUpdated", eventlist[2], "#3");
1774                         Assert.AreEqual ("ModeChanging", eventlist[3], "#4");
1775                         Assert.AreEqual ("ModeChanged", eventlist[4], "#5");
1776                 }
1777
1778                 #region FireEvents_1
1779                 public static void EditPostbackFireEvent_Init (Page p)
1780                 {
1781
1782                         FormView d = p.FindControl ("FormView1") as FormView;
1783                         if (d != null) {
1784                                 d.ModeChanged +=new EventHandler(d_ModeChanged);
1785                                 d.ModeChanging+=new FormViewModeEventHandler(d_ModeChanging);
1786                                 d.ItemCommand += new FormViewCommandEventHandler (d_ItemCommand);
1787                                 d.ItemUpdating += new FormViewUpdateEventHandler (d_ItemUpdating);
1788                                 d.ItemUpdated += new FormViewUpdatedEventHandler (d_ItemUpdated);
1789                         }
1790                 }
1791
1792                 static void d_ItemUpdated (object sender, FormViewUpdatedEventArgs e)
1793                 {
1794                         if (WebTest.CurrentTest.UserData == null) {
1795                                 ArrayList list = new ArrayList ();
1796                                 list.Add ("ItemUpdated");
1797                                 WebTest.CurrentTest.UserData = list;
1798                         }
1799                         else {
1800                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
1801                                 if (list == null)
1802                                         throw new NullReferenceException ();
1803                                 list.Add ("ItemUpdated");
1804                                 WebTest.CurrentTest.UserData = list;
1805                         }
1806                 }
1807
1808                 static void d_ItemUpdating (object sender, FormViewUpdateEventArgs e)
1809                 {
1810                         if (WebTest.CurrentTest.UserData == null) {
1811                                 ArrayList list = new ArrayList ();
1812                                 list.Add ("ItemUpdating");
1813                                 WebTest.CurrentTest.UserData = list;
1814                         }
1815                         else {
1816                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
1817                                 if (list == null)
1818                                         throw new NullReferenceException ();
1819                                 list.Add ("ItemUpdating");
1820                                 WebTest.CurrentTest.UserData = list;
1821                         }
1822                 }
1823
1824                 static void d_ItemCommand (object sender, FormViewCommandEventArgs e)
1825                 {
1826                         if (WebTest.CurrentTest.UserData == null) {
1827                                 ArrayList list = new ArrayList ();
1828                                 list.Add ("ItemCommand");
1829                                 WebTest.CurrentTest.UserData = list;
1830                         }
1831                         else {
1832                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
1833                                 if (list == null)
1834                                         throw new NullReferenceException ();
1835                                 list.Add ("ItemCommand");
1836                                 WebTest.CurrentTest.UserData = list;
1837                         }
1838                 }
1839
1840                 static void  d_ModeChanging(object sender, FormViewModeEventArgs e)
1841                 {
1842                         if (WebTest.CurrentTest.UserData == null)
1843                         {
1844                                 ArrayList list = new ArrayList ();
1845                                 list.Add ("ModeChanging");
1846                                 WebTest.CurrentTest.UserData = list;
1847                         }
1848                         else {
1849                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
1850                                 if (list == null)
1851                                         throw new NullReferenceException ();
1852                                 list.Add ("ModeChanging");
1853                                 WebTest.CurrentTest.UserData = list;
1854                         }
1855                 }
1856
1857                 static void  d_ModeChanged(object sender, EventArgs e)
1858                 {
1859                         if (WebTest.CurrentTest.UserData == null)
1860                                         {
1861                                 ArrayList list = new ArrayList ();
1862                                 list.Add ("ModeChanged");
1863                                 WebTest.CurrentTest.UserData = list;
1864                         }
1865                         else {
1866                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
1867                                 if (list == null)
1868                                         throw new NullReferenceException ();
1869                                 list.Add ("ModeChanged");
1870                                 WebTest.CurrentTest.UserData = list;
1871                         }
1872                 }
1873                 #endregion
1874
1875                 [Test]
1876                 [Category ("NunitWeb")]
1877                 public void FormView_FireEvent_2 ()
1878                 {
1879                         WebTest t = new WebTest ("FormViewInsertEditDelete.aspx");
1880                         t.Invoker = PageInvoker.CreateOnInit (FireEvent_2_Init);
1881                         t.Run ();
1882
1883                         // Checking for itemcreated event fired.
1884                         ArrayList eventlist = t.UserData as ArrayList;
1885                         if (eventlist == null)
1886                                 Assert.Fail ("User data does not been created fail");
1887
1888                         Assert.AreEqual ("ItemCreated", eventlist[0], "#1");
1889                 }
1890
1891                 #region FireEvent_2
1892                 public static void FireEvent_2_Init (Page p)
1893                 {
1894                         FormView d = p.FindControl ("FormView1") as FormView;
1895                         if (d != null) {
1896                                 d.ItemCreated += new EventHandler (d_ItemCreated);
1897                         }
1898                 }
1899
1900                 static void d_ItemCreated (object sender, EventArgs e)
1901                 {
1902                         if (WebTest.CurrentTest.UserData == null) {
1903                                 ArrayList list = new ArrayList ();
1904                                 list.Add ("ItemCreated");
1905                                 WebTest.CurrentTest.UserData = list;
1906                         }
1907                         else {
1908                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
1909                                 if (list == null)
1910                                         throw new NullReferenceException ();
1911                                 list.Add ("ItemCreated");
1912                                 WebTest.CurrentTest.UserData = list;
1913                         }
1914                 }
1915                 #endregion
1916
1917                 [Test]
1918                 [Category ("NunitWeb")]
1919                 public void FormView_FireEvent_3 ()
1920                 {
1921                         WebTest t = new WebTest ("FormViewInsertEditDelete.aspx");
1922                         t.Invoker = PageInvoker.CreateOnInit (FireEvent_3_Init);
1923                         t.Run ();
1924
1925                         FormRequest fr = new FormRequest (t.Response, "form1");
1926                         fr.Controls.Add ("__EVENTTARGET");
1927                         fr.Controls.Add ("__EVENTARGUMENT");
1928                         fr.Controls["__EVENTTARGET"].Value = "FormView1$NewButton";
1929                         fr.Controls["__EVENTARGUMENT"].Value = "";
1930                         t.Request = fr;
1931                         t.Run ();
1932
1933                         //Insert new record
1934
1935                         fr = new FormRequest (t.Response, "form1");
1936                         fr.Controls.Add ("__EVENTTARGET");
1937                         fr.Controls.Add ("__EVENTARGUMENT");
1938                         fr.Controls.Add ("FormView1$IDInsert");
1939                         fr.Controls.Add ("FormView1$FNameInsert");
1940                         fr.Controls.Add ("FormView1$LNameInsert");
1941                         fr.Controls["FormView1$IDInsert"].Value = "33";
1942                         fr.Controls["FormView1$FNameInsert"].Value = "InsertFirstName";
1943                         fr.Controls["FormView1$LNameInsert"].Value = "InsertLastName";
1944                         fr.Controls["__EVENTTARGET"].Value = "FormView1$InsertButton";
1945                         fr.Controls["__EVENTARGUMENT"].Value = "";
1946                         t.Request = fr;
1947                         t.Run ();
1948
1949                         ArrayList eventlist = t.UserData as ArrayList;
1950                         if (eventlist == null)
1951                                 Assert.Fail ("User data does not been created fail");
1952
1953                         Assert.AreEqual ("ItemInserting", eventlist[0], "#1");
1954                         Assert.AreEqual ("ItemInserted", eventlist[1], "#2");
1955                 }
1956
1957                 #region FireEvent_3
1958                 public static void FireEvent_3_Init (Page p)
1959                 {
1960                         FormView d = p.FindControl ("FormView1") as FormView;
1961                         if (d != null) {
1962                                 d.ItemInserted += new FormViewInsertedEventHandler (d_ItemInserted);
1963                                 d.ItemInserting += new FormViewInsertEventHandler (d_ItemInserting);
1964                         }
1965                 }
1966
1967                 static void d_ItemInserting (object sender, FormViewInsertEventArgs e)
1968                 {
1969                         if (WebTest.CurrentTest.UserData == null) {
1970                                 ArrayList list = new ArrayList ();
1971                                 list.Add ("ItemInserting");
1972                                 WebTest.CurrentTest.UserData = list;
1973                         }
1974                         else {
1975                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
1976                                 if (list == null)
1977                                         throw new NullReferenceException ();
1978                                 list.Add ("ItemInserting");
1979                                 WebTest.CurrentTest.UserData = list;
1980                         }
1981                 }
1982
1983                 static void d_ItemInserted (object sender, FormViewInsertedEventArgs e)
1984                 {
1985                         if (WebTest.CurrentTest.UserData == null) {
1986                                 ArrayList list = new ArrayList ();
1987                                 list.Add ("ItemInserted");
1988                                 WebTest.CurrentTest.UserData = list;
1989                         }
1990                         else {
1991                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
1992                                 if (list == null)
1993                                         throw new NullReferenceException ();
1994                                 list.Add ("ItemInserted");
1995                                 WebTest.CurrentTest.UserData = list;
1996                         }
1997                 }
1998                 #endregion
1999
2000                 [Test]
2001                 [Category ("NunitWeb")]
2002                 public void FormView_FireEvent_4 ()
2003                 {
2004                         WebTest t = new WebTest ("FormViewInsertEditDelete.aspx");
2005                         t.Invoker = PageInvoker.CreateOnInit (FireEvent_4_Init);
2006                         t.Run ();
2007
2008                         //Delete Item
2009                         FormRequest fr = new FormRequest (t.Response, "form1");
2010                         fr.Controls.Add ("__EVENTTARGET");
2011                         fr.Controls.Add ("__EVENTARGUMENT");
2012                         fr.Controls["__EVENTTARGET"].Value = "FormView1$DeleteButton";
2013                         fr.Controls["__EVENTARGUMENT"].Value = "";
2014                         t.Request = fr;
2015                         t.Run ();
2016
2017                         ArrayList eventlist = t.UserData as ArrayList;
2018                         if (eventlist == null)
2019                                 Assert.Fail ("User data does not been created fail");
2020
2021                         Assert.AreEqual ("ItemDeleting", eventlist[0], "#1");
2022                         Assert.AreEqual ("ItemDeleted", eventlist[1], "#2");
2023
2024                 }
2025
2026                 #region FireEvent_4
2027                 public static void FireEvent_4_Init (Page p)
2028                 {
2029                         FormView d = p.FindControl ("FormView1") as FormView;
2030                         if (d != null) {
2031                                 d.ItemDeleting += new FormViewDeleteEventHandler (d_ItemDeleting);
2032                                 d.ItemDeleted += new FormViewDeletedEventHandler (d_ItemDeleted);
2033                         }
2034                 }
2035
2036                 static void d_ItemDeleted (object sender, FormViewDeletedEventArgs e)
2037                 {
2038                         if (WebTest.CurrentTest.UserData == null) {
2039                                 ArrayList list = new ArrayList ();
2040                                 list.Add ("ItemDeleted");
2041                                 WebTest.CurrentTest.UserData = list;
2042                         }
2043                         else {
2044                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
2045                                 if (list == null)
2046                                         throw new NullReferenceException ();
2047                                 list.Add ("ItemDeleted");
2048                                 WebTest.CurrentTest.UserData = list;
2049                         }
2050                 }
2051
2052                 static void d_ItemDeleting (object sender, FormViewDeleteEventArgs e)
2053                 {
2054                         if (WebTest.CurrentTest.UserData == null) {
2055                                 ArrayList list = new ArrayList ();
2056                                 list.Add ("ItemDeleting");
2057                                 WebTest.CurrentTest.UserData = list;
2058                         }
2059                         else {
2060                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
2061                                 if (list == null)
2062                                         throw new NullReferenceException ();
2063                                 list.Add ("ItemDeleting");
2064                                 WebTest.CurrentTest.UserData = list;
2065                         }
2066                 }
2067                 #endregion
2068
2069                 [Test]
2070                 [Category ("NunitWeb")]
2071                 public void FormView_FireEvent_5 ()
2072                 {
2073                         WebTest t = new WebTest ("FormViewInsertEditDelete.aspx");
2074                         t.Invoker = PageInvoker.CreateOnInit (FireEvent_5_Init);
2075                         t.Run ();
2076
2077                         //Delete Item
2078                         FormRequest fr = new FormRequest (t.Response, "form1");
2079                         fr.Controls.Add ("__EVENTTARGET");
2080                         fr.Controls.Add ("__EVENTARGUMENT");
2081                         fr.Controls["__EVENTTARGET"].Value = "FormView1";
2082                         fr.Controls["__EVENTARGUMENT"].Value = "Page$2";
2083                         t.Request = fr;
2084                         t.Run ();
2085
2086                         ArrayList eventlist = t.UserData as ArrayList;
2087                         if (eventlist == null)
2088                                 Assert.Fail ("User data does not been created fail");
2089
2090                         Assert.AreEqual ("PageIndexChanging", eventlist[0], "#1");
2091                         Assert.AreEqual ("PageIndexChanged", eventlist[1], "#2");
2092                 }
2093
2094                 #region FireEvent_5
2095                 public static void FireEvent_5_Init (Page p)
2096                 {
2097                         FormView d = p.FindControl ("FormView1") as FormView;
2098                         if (d != null) {
2099                                 d.PageIndexChanged+=new EventHandler(d_PageIndexChanged);
2100                                 d.PageIndexChanging+=new FormViewPageEventHandler(d_PageIndexChanging);
2101                         }
2102                 }
2103
2104                 static void d_PageIndexChanging (object sender, FormViewPageEventArgs e)
2105                 {
2106                         if (WebTest.CurrentTest.UserData == null) {
2107                                 ArrayList list = new ArrayList ();
2108                                 list.Add ("PageIndexChanging");
2109                                 WebTest.CurrentTest.UserData = list;
2110                         }
2111                         else {
2112                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
2113                                 if (list == null)
2114                                         throw new NullReferenceException ();
2115                                 list.Add ("PageIndexChanging");
2116                                 WebTest.CurrentTest.UserData = list;
2117                         }
2118                 }
2119
2120                 static void d_PageIndexChanged (object sender, EventArgs e)
2121                 {
2122                         if (WebTest.CurrentTest.UserData == null) {
2123                                 ArrayList list = new ArrayList ();
2124                                 list.Add ("PageIndexChanged");
2125                                 WebTest.CurrentTest.UserData = list;
2126                         }
2127                         else {
2128                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
2129                                 if (list == null)
2130                                         throw new NullReferenceException ();
2131                                 list.Add ("PageIndexChanged");
2132                                 WebTest.CurrentTest.UserData = list;
2133                         }
2134                 }
2135                 #endregion
2136
2137                 [Test]
2138                 [Category ("NunitWeb")]
2139                 public void FormView_InsertPostback ()
2140                 {
2141                         WebTest t = new WebTest ("FormViewInsertEditDelete.aspx");
2142                         string pageHTML = t.Run ();
2143                         Assert.AreEqual (true, pageHTML.Contains ("1001"), "BeforeInsert1");
2144                         Assert.AreEqual (true, pageHTML.Contains ("Mahesh"), "BeforeInsert2");
2145                         Assert.AreEqual (true, pageHTML.Contains ("Chand"), "BeforeInsert3");
2146                         Assert.AreEqual (false, pageHTML.Contains ("Page$4"), "BeforeInsert4");
2147                         FormRequest fr = new FormRequest (t.Response, "form1");
2148                         fr.Controls.Add ("__EVENTTARGET");
2149                         fr.Controls.Add ("__EVENTARGUMENT");
2150                         fr.Controls["__EVENTTARGET"].Value = "FormView1$NewButton";
2151                         fr.Controls["__EVENTARGUMENT"].Value = "";
2152                         t.Request = fr;
2153                         pageHTML = t.Run ();
2154                         string newHtml = HtmlDiff.GetControlFromPageHtml (pageHTML);
2155 #if NET_4_0
2156                         string origHtml = "<table cellspacing=\"0\" id=\"FormView1\" style=\"border-collapse:collapse;\">\r\n\t<tr>\r\n\t\t<td colspan=\"2\">\n                    Insert ID:\n                    <input name=\"FormView1$IDInsert\" type=\"text\" id=\"FormView1_IDInsert\" /><br />\n                    Insert First Name:\n                    <input name=\"FormView1$FNameInsert\" type=\"text\" id=\"FormView1_FNameInsert\" />\n                    <br />\n                    Insert Last Name:&nbsp;\n                    <input name=\"FormView1$LNameInsert\" type=\"text\" id=\"FormView1_LNameInsert\" />\n                    <a id=\"FormView1_InsertButton\" href=\"javascript:__doPostBack(&#39;FormView1$InsertButton&#39;,&#39;&#39;)\">Insert</a>\n                    <a id=\"FormView1_CancelInsertButton\" href=\"javascript:__doPostBack(&#39;FormView1$CancelInsertButton&#39;,&#39;&#39;)\">Cancel</a>\n                </td>\r\n\t</tr>\r\n</table>";
2157 #else
2158                         string origHtml = "<table cellspacing=\"0\" border=\"0\" id=\"FormView1\" style=\"border-collapse:collapse;\">\r\n\t<tr>\r\n\t\t<td colspan=\"2\">\n                    Insert ID:\n                    <input name=\"FormView1$IDInsert\" type=\"text\" id=\"FormView1_IDInsert\" /><br />\n                    Insert First Name:\n                    <input name=\"FormView1$FNameInsert\" type=\"text\" id=\"FormView1_FNameInsert\" />\n                    <br />\n                    Insert Last Name:&nbsp;\n                    <input name=\"FormView1$LNameInsert\" type=\"text\" id=\"FormView1_LNameInsert\" />\n                    <a id=\"FormView1_InsertButton\" href=\"javascript:__doPostBack('FormView1$InsertButton','')\">Insert</a>\n                    <a id=\"FormView1_CancelInsertButton\" href=\"javascript:__doPostBack('FormView1$CancelInsertButton','')\">Cancel</a>\n                </td>\r\n\t</tr>\r\n</table>";
2159 #endif
2160                         HtmlDiff.AssertAreEqual (origHtml, newHtml, "InsertPostback");
2161
2162                         //Insert new record
2163
2164                         fr = new FormRequest (t.Response, "form1");
2165                         fr.Controls.Add ("__EVENTTARGET");
2166                         fr.Controls.Add ("__EVENTARGUMENT");
2167                         fr.Controls.Add ("FormView1$IDInsert");
2168                         fr.Controls.Add ("FormView1$FNameInsert");
2169                         fr.Controls.Add ("FormView1$LNameInsert");
2170                         fr.Controls["FormView1$IDInsert"].Value = "33";
2171                         fr.Controls["FormView1$FNameInsert"].Value = "InsertFirstName";
2172                         fr.Controls["FormView1$LNameInsert"].Value ="InsertLastName";
2173                         fr.Controls["__EVENTTARGET"].Value = "FormView1$InsertButton";
2174                         fr.Controls["__EVENTARGUMENT"].Value = "";
2175                         t.Request = fr;
2176                         pageHTML = t.Run ();
2177                         Assert.AreEqual (true, pageHTML.Contains ("1001"), "AfterInsert1");
2178                         Assert.AreEqual (true, pageHTML.Contains ("Mahesh"), "AfterInsert2");
2179                         Assert.AreEqual (true, pageHTML.Contains ("Chand"), "AfterInsert3");
2180                         Assert.AreEqual (true, pageHTML.Contains ("Page$4"), "AfterInsert4");
2181
2182                         //Checking that the inserted record appears on page 4.
2183
2184                         fr = new FormRequest (t.Response, "form1");
2185                         fr.Controls.Add ("__EVENTTARGET");
2186                         fr.Controls.Add ("__EVENTARGUMENT");
2187                         fr.Controls["__EVENTTARGET"].Value = "FormView1";
2188                         fr.Controls["__EVENTARGUMENT"].Value = "Page$4";
2189                         t.Request = fr;
2190                         pageHTML = t.Run ();
2191                         Assert.AreEqual (true, pageHTML.Contains ("33"), "AfterInsert1");
2192                         Assert.AreEqual (true, pageHTML.Contains ("InsertLastName"), "AfterInsert2");
2193                         Assert.AreEqual (true, pageHTML.Contains ("InsertFirstName"), "AfterInsert3");
2194
2195                 }
2196
2197                 [Test]
2198                 [Category ("NunitWeb")]
2199                 public void FormView_DeleteAndEmptyTemplatePostback ()
2200                 {
2201                         WebTest t = new WebTest ("FormViewInsertEditDelete.aspx");
2202                         string pageHTML = t.Run ();
2203
2204                         Assert.AreEqual (true, pageHTML.Contains ("1001"), "BeforeDelete1");
2205                         Assert.AreEqual (true, pageHTML.Contains ("Mahesh"), "BeforeDelete2");
2206                         Assert.AreEqual (true, pageHTML.Contains ("Chand"), "BeforeDelete3");
2207                         Assert.AreEqual (true, pageHTML.Contains ("Page$3"), "BeforeDelete4");
2208                         //Delete First Item
2209                         FormRequest fr = new FormRequest (t.Response, "form1");
2210                         fr.Controls.Add ("__EVENTTARGET");
2211                         fr.Controls.Add ("__EVENTARGUMENT");
2212                         fr.Controls["__EVENTTARGET"].Value = "FormView1$DeleteButton";
2213                         fr.Controls["__EVENTARGUMENT"].Value = "";
2214                         t.Request = fr;
2215                         pageHTML = t.Run ();
2216                         Assert.AreEqual (true, pageHTML.Contains ("1002"), "AfterFirstDelete1");
2217                         Assert.AreEqual (true, pageHTML.Contains ("Talmadge"), "AfterFirstDelete2");
2218                         Assert.AreEqual (true, pageHTML.Contains ("Melanie"), "AfterFirstDelete3");
2219                         Assert.AreEqual (true, pageHTML.Contains ("Page$2"), "AfterFirstDelete4");
2220                         Assert.AreEqual (false, pageHTML.Contains ("Page$3"), "AfterFirstDelete5");
2221
2222                         //Delete second item
2223
2224                         fr = new FormRequest (t.Response, "form1");
2225                         fr.Controls.Add ("__EVENTTARGET");
2226                         fr.Controls.Add ("__EVENTARGUMENT");
2227                         fr.Controls["__EVENTTARGET"].Value = "FormView1$DeleteButton";
2228                         fr.Controls["__EVENTARGUMENT"].Value = "";
2229                         t.Request = fr;
2230                         pageHTML = t.Run ();
2231                         Assert.AreEqual (true, pageHTML.Contains ("1003"), "AfterSecondDelete1");
2232                         Assert.AreEqual (true, pageHTML.Contains ("Bansal"), "AfterSecondDelete2");
2233                         Assert.AreEqual (true, pageHTML.Contains ("Vinay"), "AfterSecondDelete3");
2234                         Assert.AreEqual (false, pageHTML.Contains ("Page$2"), "AfterSecondDelete4");
2235
2236                         //Delete last item and checking that the EmptyDataTemplate appears.
2237
2238                         fr = new FormRequest (t.Response, "form1");
2239                         fr.Controls.Add ("__EVENTTARGET");
2240                         fr.Controls.Add ("__EVENTARGUMENT");
2241                         fr.Controls["__EVENTTARGET"].Value = "FormView1$DeleteButton";
2242                         fr.Controls["__EVENTARGUMENT"].Value = "";
2243                         t.Request = fr;
2244                         pageHTML = t.Run ();
2245                         Assert.AreEqual (true, pageHTML.Contains ("FormView1_Label1"), "EmptyTemplateTest1");
2246                         Assert.AreEqual (true, pageHTML.Contains ("The Database is empty"), "EmptyTemplateTest2");
2247                 }
2248
2249                 [Test]
2250                 public void FormView_CurrentMode () {
2251                         FormView view = new FormView ();
2252                         view.DefaultMode = FormViewMode.Insert;
2253                         Assert.AreEqual (FormViewMode.Insert, view.CurrentMode, "FormView_CurrentMode#1");
2254                         view.ChangeMode (FormViewMode.Edit);
2255                         Assert.AreEqual (FormViewMode.Edit, view.CurrentMode, "FormView_CurrentMode#2");
2256                 }
2257
2258                 [Test]
2259                 public void FormView_CreateDataSourceSelectArguments2 () {
2260                         DataSourceView view;
2261                         Page p = new Page ();
2262
2263                         Poker dv = new Poker ();
2264                         p.Controls.Add (dv);
2265
2266                         ObjectDataSource data = new ObjectDataSource ();
2267                         data.TypeName = typeof (DataSourceObject).AssemblyQualifiedName;
2268                         data.SelectMethod = "GetList";
2269                         data.SortParameterName = "sortExpression";
2270                         DataSourceSelectArguments arg;
2271                         p.Controls.Add (data);
2272
2273                         dv.DataSource = data;
2274                         dv.DataBind ();
2275
2276                         arg = dv.DoCreateDataSourceSelectArguments ();
2277                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "Default");
2278
2279                         dv.AllowPaging = true;
2280                         dv.PageIndex = 2;
2281                         arg = dv.DoCreateDataSourceSelectArguments ();
2282                         view = dv.DoGetData ();
2283                         Assert.IsFalse (view.CanPage);
2284                         Assert.IsTrue (view.CanRetrieveTotalRowCount);
2285                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "AllowPaging = true, CanPage = false, CanRetrieveTotalRowCount = true");
2286
2287                         // make DataSourceView.CanPage = true
2288                         data.EnablePaging = true;
2289
2290                         arg = dv.DoCreateDataSourceSelectArguments ();
2291                         view = dv.DoGetData ();
2292                         Assert.IsTrue (view.CanPage);
2293                         Assert.IsFalse (view.CanRetrieveTotalRowCount);
2294                         Assert.IsTrue (arg.Equals (new DataSourceSelectArguments (2, -1)), "AllowPaging = true, CanPage = true, CanRetrieveTotalRowCount = false");
2295
2296                         dv.AllowPaging = false;
2297                         arg = dv.DoCreateDataSourceSelectArguments ();
2298                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "AllowPaging = false, CanPage = true, CanRetrieveTotalRowCount = false");
2299
2300                         // make DataSourceView.CanRetrieveTotalRowCount = true
2301                         data.SelectCountMethod = "GetCount";
2302
2303                         arg = dv.DoCreateDataSourceSelectArguments ();
2304                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "AllowPaging = false, CanPage = true, CanRetrieveTotalRowCount = true");
2305
2306                         dv.AllowPaging = true;
2307                         arg = dv.DoCreateDataSourceSelectArguments ();
2308                         DataSourceSelectArguments arg1 = new DataSourceSelectArguments (2, 1);
2309                         arg1.RetrieveTotalRowCount = true;
2310                         view = dv.DoGetData ();
2311                         Assert.IsTrue (view.CanPage);
2312                         Assert.IsTrue (view.CanRetrieveTotalRowCount);
2313                         Assert.IsTrue (arg.Equals (arg1), "AllowPaging = true, CanPage = true, CanRetrieveTotalRowCount = true");
2314                 }
2315
2316                 [Test]
2317                 public void FormView_GetPostBackOptions () {
2318                         FormView fv = new FormView ();
2319                         fv.Page = new Page ();
2320                         IButtonControl btn = new Button ();
2321                         btn.CausesValidation = false;
2322                         Assert.IsFalse (btn.CausesValidation);
2323                         Assert.AreEqual (String.Empty, btn.CommandName);
2324                         Assert.AreEqual (String.Empty, btn.CommandArgument);
2325                         Assert.AreEqual (String.Empty, btn.PostBackUrl);
2326                         Assert.AreEqual (String.Empty, btn.ValidationGroup);
2327                         PostBackOptions options = ((IPostBackContainer) fv).GetPostBackOptions (btn);
2328                         Assert.IsFalse (options.PerformValidation);
2329                         Assert.IsFalse (options.AutoPostBack);
2330                         Assert.IsFalse (options.TrackFocus);
2331                         Assert.IsTrue (options.ClientSubmit);
2332                         Assert.IsTrue (options.RequiresJavaScriptProtocol);
2333                         Assert.AreEqual ("$", options.Argument);
2334                         Assert.AreEqual (null, options.ActionUrl);
2335                         Assert.AreEqual (null, options.ValidationGroup);
2336                         Assert.IsTrue (object.ReferenceEquals (options.TargetControl, fv));
2337
2338                         btn.ValidationGroup = "VG";
2339                         btn.CommandName = "CMD";
2340                         btn.CommandArgument = "ARG";
2341                         btn.PostBackUrl = "Page.aspx";
2342                         Assert.IsFalse (btn.CausesValidation);
2343                         Assert.AreEqual ("CMD", btn.CommandName);
2344                         Assert.AreEqual ("ARG", btn.CommandArgument);
2345                         Assert.AreEqual ("Page.aspx", btn.PostBackUrl);
2346                         Assert.AreEqual ("VG", btn.ValidationGroup);
2347                         options = ((IPostBackContainer) fv).GetPostBackOptions (btn);
2348                         Assert.IsFalse (options.PerformValidation);
2349                         Assert.IsFalse (options.AutoPostBack);
2350                         Assert.IsFalse (options.TrackFocus);
2351                         Assert.IsTrue (options.ClientSubmit);
2352                         Assert.IsTrue (options.RequiresJavaScriptProtocol);
2353                         Assert.AreEqual ("CMD$ARG", options.Argument);
2354                         Assert.AreEqual (null, options.ActionUrl);
2355                         Assert.AreEqual (null, options.ValidationGroup);
2356                 }
2357
2358                 [Test]
2359                 [ExpectedException (typeof (InvalidOperationException))]
2360                 public void FormView_GetPostBackOptions_CausesValidation () {
2361                         FormView fv = new FormView ();
2362                         fv.Page = new Page ();
2363                         IButtonControl btn = new Button ();
2364                         Assert.IsTrue (btn.CausesValidation);
2365                         Assert.AreEqual (String.Empty, btn.CommandName);
2366                         Assert.AreEqual (String.Empty, btn.CommandArgument);
2367                         Assert.AreEqual (String.Empty, btn.PostBackUrl);
2368                         Assert.AreEqual (String.Empty, btn.ValidationGroup);
2369                         PostBackOptions options = ((IPostBackContainer) fv).GetPostBackOptions (btn);
2370                 }
2371
2372                 [Test]
2373                 [ExpectedException (typeof (ArgumentNullException))]
2374                 public void FormView_GetPostBackOptions_Null_Argument () {
2375                         FormView fv = new FormView ();
2376                         fv.Page = new Page ();
2377                         PostBackOptions options = ((IPostBackContainer) fv).GetPostBackOptions (null);
2378                 }
2379
2380                 [Test]
2381                 [Category ("NunitWeb")]
2382                 public void FormView_RequiresDataBinding () {
2383                         PageDelegates delegates = new PageDelegates ();
2384                         delegates.LoadComplete = FormView_RequiresDataBinding_LoadComplete;
2385                         PageInvoker invoker = new PageInvoker (delegates);
2386                         WebTest t = new WebTest (invoker);
2387                         t.Run ();
2388                 }
2389
2390                 public static void FormView_RequiresDataBinding_LoadComplete (Page p) {
2391                         Poker view = new Poker ();
2392                         p.Form.Controls.Add (view);
2393
2394                         view.DataSource = new string [] { "A", "B", "C" };
2395                         view.DataBind ();
2396
2397                         Assert.AreEqual (false, view.GetRequiresDataBinding ());
2398
2399                         view.PagerTemplate = new CompiledTemplateBuilder (BuildTemplateMethod);
2400                         Assert.AreEqual (false, view.GetRequiresDataBinding (), "PagerTemplate was set");
2401
2402                         view.EmptyDataTemplate = new CompiledTemplateBuilder (BuildTemplateMethod);
2403                         Assert.AreEqual (false, view.GetRequiresDataBinding (), "EmptyDataTemplate was set");
2404
2405                         view.HeaderTemplate = new CompiledTemplateBuilder (BuildTemplateMethod);
2406                         Assert.AreEqual (false, view.GetRequiresDataBinding (), "HeaderTemplate was set");
2407
2408                         view.FooterTemplate = new CompiledTemplateBuilder (BuildTemplateMethod);
2409                         Assert.AreEqual (false, view.GetRequiresDataBinding (), "FooterTemplate was set");
2410
2411                         view.EditItemTemplate = new CompiledTemplateBuilder (BuildTemplateMethod);
2412                         Assert.AreEqual (false, view.GetRequiresDataBinding (), "EditItemTemplate was set");
2413
2414                         view.InsertItemTemplate = new CompiledTemplateBuilder (BuildTemplateMethod);
2415                         Assert.AreEqual (false, view.GetRequiresDataBinding (), "InsertItemTemplate was set");
2416
2417                         view.ItemTemplate = new CompiledTemplateBuilder (BuildTemplateMethod);
2418                         Assert.AreEqual (false, view.GetRequiresDataBinding (), "ItemTemplate was set");
2419                 }
2420
2421                 public static void BuildTemplateMethod (Control c) { }
2422 #if NET_4_0
2423                 [Test]
2424                 public void ModifiedOuterTableStylePropertyName ()
2425                 {
2426                         var fv = new Poker ();
2427                         string props;
2428
2429                         props = fv.CallModifiedOuterTableStylePropertyName ();
2430                         Assert.AreEqual (String.Empty, props, "#A1");
2431
2432                         fv.BackImageUrl = "http://example.com/image.png";
2433                         props = fv.CallModifiedOuterTableStylePropertyName ();
2434                         Assert.IsNotNull (props, "#A2-1");
2435                         Assert.AreEqual ("BackImageUrl", props, "#A2-2");
2436
2437                         fv = new Poker ();
2438                         fv.CellPadding = 10;
2439                         props = fv.CallModifiedOuterTableStylePropertyName ();
2440                         Assert.IsNotNull (props, "#A3-1");
2441                         Assert.AreEqual ("CellPadding", props, "#A3-2");
2442
2443                         fv = new Poker ();
2444                         fv.CellSpacing = 10;
2445                         props = fv.CallModifiedOuterTableStylePropertyName ();
2446                         Assert.IsNotNull (props, "#A4-1");
2447                         Assert.AreEqual ("CellSpacing", props, "#A4-2");
2448
2449                         fv = new Poker ();
2450                         fv.GridLines = GridLines.Both;
2451                         props = fv.CallModifiedOuterTableStylePropertyName ();
2452                         Assert.IsNotNull (props, "#A5-1");
2453                         Assert.AreEqual ("GridLines", props, "#A5-2");
2454
2455                         fv = new Poker ();
2456                         fv.HorizontalAlign = HorizontalAlign.Justify;
2457                         props = fv.CallModifiedOuterTableStylePropertyName ();
2458                         Assert.IsNotNull (props, "#A6-1");
2459                         Assert.AreEqual ("HorizontalAlign", props, "#A6-2");
2460
2461                         fv = new Poker ();
2462                         fv.Font.Bold = true;
2463                         props = fv.CallModifiedOuterTableStylePropertyName ();
2464                         Assert.IsNotNull (props, "#A6-1");
2465                         Assert.AreEqual ("Font", props, "#A6-2");
2466
2467                         // Just one property is reported at a time
2468                         fv = new Poker ();
2469                         fv.BackImageUrl = "http://example.com/image.png";
2470                         fv.CellPadding = 10;
2471                         props = fv.CallModifiedOuterTableStylePropertyName ();
2472                         Assert.IsNotNull (props, "#B1-1");
2473                         Assert.AreEqual ("BackImageUrl", props, "#B1-2");
2474                 }
2475 #endif
2476         }
2477
2478         public class TestMyData
2479         {
2480                 static IList<int> str;
2481                 //str.(new int[] { 1, 2, 3, 4, 5, 6 });
2482
2483                 static TestMyData ()
2484                 {
2485                         InitData ();
2486                 }
2487
2488                 public static void InitData()
2489                 {
2490                         str = new List<int> ();
2491                         for (int i=1;i<7;i++)
2492                                 str.Add (i);
2493                 }
2494                 public static IList<int> GetMyList()
2495                 {
2496                         return str;
2497                 }
2498
2499                 public static int UpdateList(int index, int value)
2500                 {
2501                         str[index] = value;
2502                         return str[index];
2503                 }
2504
2505                 public static int InsertList(int value)
2506                 {
2507                         str.Add(value);
2508                         return value;
2509                 }
2510
2511                 public static void DeleteList(int value)
2512                 {
2513                         str.Remove(value);
2514                 }
2515
2516         }
2517
2518         public class MyTemplate : ITemplate
2519         {
2520
2521                 Label l = new Label ();
2522 #region ITemplate Members
2523
2524                 public void InstantiateIn (Control container)
2525                 {
2526                         container.Controls.Add (l);
2527
2528                 }
2529
2530                 public void SetDataItem (object value)
2531                 {
2532                         l.Text = value.ToString ();
2533                 }
2534
2535 #endregion
2536         }
2537
2538 public class FormViewDataObject
2539         {
2540
2541                 public static DataTable ds = CreateDataTable();
2542
2543                 public static DataTable Select()
2544                 {
2545
2546                         return ds;
2547
2548                 }
2549
2550
2551
2552                 public static DataTable Delete(string ID, string FName, string LName)
2553                 {
2554
2555                         DataRow dr = ds.Rows.Find(ID);
2556
2557                         if (dr != null)
2558                         {
2559
2560                                 ds.Rows.Remove(dr);
2561
2562                         }
2563
2564                         return ds;
2565
2566                 }
2567
2568
2569
2570                 public static DataTable Insert(string ID, string FName, string LName)
2571                 {
2572
2573                         DataRow dr = ds.NewRow();
2574                         dr["ID"] = ID;
2575                         dr["FName"] = FName;
2576                         dr["LName"] = LName;
2577                         ds.Rows.Add(dr);
2578                         return ds;
2579                 }
2580
2581
2582
2583                 public static DataTable Update(string ID, string FName, string LName)
2584                 {
2585                         DataRow dr = ds.Rows.Find(ID);
2586                         if (dr == null)
2587                         {
2588                                 Label lbl = new Label();
2589                                 lbl.Text = "ID doesn't exist ";
2590                                 return ds;
2591                         }
2592                         dr["FName"] = FName;
2593                         dr["LName"] = LName;
2594                         return ds;
2595
2596                 }
2597
2598
2599
2600                 public static DataTable CreateDataTable()
2601                 {
2602
2603                         DataTable aTable = new DataTable("A");
2604                         DataColumn dtCol;
2605                         DataRow dtRow;
2606
2607                         // Create ID column and add to the DataTable.
2608
2609                         dtCol = new DataColumn();
2610                         dtCol.DataType = Type.GetType("System.Int32");
2611                         dtCol.ColumnName = "ID";
2612                         dtCol.AutoIncrement = true;
2613                         dtCol.Caption = "ID";
2614                         dtCol.ReadOnly = true;
2615                         dtCol.Unique = true;
2616                         aTable.Columns.Add(dtCol);
2617
2618
2619
2620                         // Create Name column and add to the table
2621
2622                         dtCol = new DataColumn();
2623                         dtCol.DataType = Type.GetType("System.String");
2624                         dtCol.ColumnName = "FName";
2625                         dtCol.AutoIncrement = false;
2626                         dtCol.Caption = "First Name";
2627                         dtCol.ReadOnly = false;
2628                         dtCol.Unique = false;
2629                         aTable.Columns.Add(dtCol);
2630
2631
2632
2633                         // Create Last Name column and add to the table.
2634
2635                         dtCol = new DataColumn();
2636                         dtCol.DataType = Type.GetType("System.String");
2637                         dtCol.ColumnName = "LName";
2638                         dtCol.AutoIncrement = false;
2639                         dtCol.Caption = "Last Name";
2640                         dtCol.ReadOnly = false;
2641                         dtCol.Unique = false;
2642                         aTable.Columns.Add(dtCol);
2643
2644
2645
2646                         // Create three rows to the table
2647
2648                         dtRow = aTable.NewRow();
2649                         dtRow["ID"] = 1001;
2650                         dtRow["FName"] = "Mahesh";
2651                         dtRow["LName"] = "Chand";
2652                         aTable.Rows.Add(dtRow);
2653
2654                         dtRow = aTable.NewRow();
2655                         dtRow["ID"] = 1002;
2656                         dtRow["FName"] = "Melanie";
2657                         dtRow["LName"] = "Talmadge";
2658                         aTable.Rows.Add(dtRow);
2659
2660                         dtRow = aTable.NewRow();
2661                         dtRow["ID"] = 1003;
2662                         dtRow["FName"] = "Vinay";
2663                         dtRow["LName"] = "Bansal";
2664                         aTable.Rows.Add(dtRow);
2665
2666                         aTable.PrimaryKey = new DataColumn[] { aTable.Columns["ID"] };
2667                         return aTable;
2668
2669                 }
2670         }
2671 }
2672
2673
2674 #endif