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 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                 }
 354
 355                 class Template : ITemplate
 356                 {
 357                         bool _instantiated;
 358
 359                         public bool Instantiated {
 360                                get { return _instantiated; }
 361                         }
 362
 363 #region ITemplate Members
 364
 365                         public void InstantiateIn (Control container) {
 366                                _instantiated = true;
 367                         }
 368
 369                         #endregion
 370                 }
 371
 372
 373                 ArrayList myds = new ArrayList ();
 374                 [TestFixtureSetUp]
 375                 public void setup ()
 376                 {
 377                         TestMyData.InitData();
 378                         myds.Add ("Item1");
 379                         myds.Add ("Item2");
 380                         myds.Add ("Item3");
 381                         myds.Add ("Item4");
 382                         myds.Add ("Item5");
 383                         myds.Add ("Item6");
 384 #if VISUAL_STUDIO
 385                         WebTest.CopyResource (GetType (), "MonoTests.System.Web.UI.WebControls.Resources.FormView.aspx",
 386                                 "FormView.aspx");
 387                         WebTest.CopyResource (GetType (), "MonoTests.System.Web.UI.WebControls.Resources.FormViewTest1.aspx",
 388                                 "FormViewTest1.aspx");
 389                         WebTest.CopyResource (GetType (), "MonoTests.System.Web.UI.WebControls.Resources.FormViewInsertEditDelete.aspx",
 390                                 "FormViewInsertEditDelete.aspx");
 391 #else
 392                         WebTest.CopyResource (GetType (), "FormView.aspx", "FormView.aspx");
 393                         WebTest.CopyResource (GetType (), "FormViewTest1.aspx", "FormViewTest1.aspx");
 394                         WebTest.CopyResource (GetType (), "FormViewInsertEditDelete.aspx", "FormViewInsertEditDelete.aspx");
 395 #endif
 396
 397                }
 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_PrepareControlHierarcy ()
 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 //#if TARGET_JVM //BUG #6518
1571 //                [Category ("NotWorking")]
1572 //#endif
1573                 public void FormView_RenderSimpleTemplate()
1574                 {
1575                         string RenderedPageHtml = new WebTest ("FormViewTest1.aspx").Run ();
1576                         string newHtmlValue = RenderedPageHtml.Substring (RenderedPageHtml.IndexOf ("test1") + 5, RenderedPageHtml.IndexOf ("test2") - RenderedPageHtml.IndexOf ("test1") - 5);
1577                         string origHtmlValue = @" &nbsp;<table cellspacing=""2"" cellpadding=""3"" rules=""all"" border=""1"" id=""FormView1"" style=""background-color:#DEBA84;border-color:#DEBA84;border-width:1px;border-style:None;"">
1578                                                 <tr style=""color:#8C4510;background-color:#FFF7E7;"">
1579                                                 <td colspan=""2"">
1580                                                  <span id=""FormView1_Label1"">1</span>
1581                                                  </td>
1582                                                 </tr><tr align=""center"" style=""color:#8C4510;"">
1583                                                 <td colspan=""2""><table border=""0"">
1584                                                 <tr>
1585                                                 <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>
1586                                                 </tr>
1587                                                 </table></td>
1588                                                 </tr>
1589                                                 </table>";
1590
1591                         HtmlDiff.AssertAreEqual (origHtmlValue, newHtmlValue, "RenderSimpleTemplate");
1592
1593                 }
1594
1595                 [Test]
1596                 [Category ("NunitWeb")]
1597 //#if TARGET_JVM //BUG #6518
1598 //                [Category ("NotWorking")]
1599 //#endif
1600                 public void FormView_RenderFooterAndPager()
1601                 {
1602                         string RenderedPageHtml = new WebTest ("FormViewTest1.aspx").Run ();
1603                         string newHtmlValue = RenderedPageHtml.Substring (RenderedPageHtml.IndexOf ("test2") + 5, RenderedPageHtml.IndexOf ("test3") - RenderedPageHtml.IndexOf ("test2") - 5);
1604                         string origHtmlValue = @" <table cellspacing=""0"" cellpadding=""4"" border=""0"" id=""FormView2"" style=""color:#333333;border-collapse:collapse;"">
1605                                                 <tr style=""color:#333333;background-color:#F7F6F3;"">
1606                                                 <td colspan=""2"">
1607                                                  <span id=""FormView2_Label2"">1</span>
1608                                                  </td>
1609                                                 </tr><tr style=""color:White;background-color:#5D7B9D;font-weight:bold;"">
1610                                                 <td colspan=""2"">
1611                                                 <span id=""FormView2_Label3"">Footer Template Test</span>
1612                                                  </td>
1613                                                 </tr><tr align=""center"" style=""color:White;background-color:#284775;"">
1614                                                 <td colspan=""2"">
1615                                                 <input type=""submit"" name=""FormView2$ctl01$Button1"" value=""Prev Item"" id=""FormView2_ctl01_Button1"" />
1616                                                 <input type=""submit"" name=""FormView2$ctl01$Button2"" value=""Next Item"" id=""FormView2_ctl01_Button2"" />
1617                                                  <input type=""submit"" name=""FormView2$ctl01$Button3"" value=""First Item"" id=""FormView2_ctl01_Button3"" />
1618                                                  <input type=""submit"" name=""FormView2$ctl01$Button4"" value=""Last Item"" id=""FormView2_ctl01_Button4"" />
1619                                                  </td>
1620                                                 </tr>
1621                                                 </table>
1622                                                 </div>";
1623                         HtmlDiff.AssertAreEqual (origHtmlValue, newHtmlValue, "FormView_RenderFooterAndPager");
1624                 }
1625
1626                 [Test]
1627                 [Category ("NunitWeb")]
1628 //#if TARGET_JVM //BUG #6518
1629 //                [Category ("NotWorking")]
1630 //#endif
1631                 public void FormView_RenderWithHeader()
1632                 {
1633                         string RenderedPageHtml = new WebTest ("FormViewTest1.aspx").Run ();
1634                         string newHtmlValue = RenderedPageHtml.Substring (RenderedPageHtml.IndexOf ("test4") + 5, RenderedPageHtml.IndexOf ("endtest") - RenderedPageHtml.IndexOf ("test4") - 5);
1635                         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;"">
1636                                                 <tr align=""left"" style=""color:White;background-color:#006699;font-weight:bold;"">
1637                                                 <td colspan=""2"">Using Header Text property</td>
1638                                                 </tr><tr align=""center"" style=""color:#000066;background-color:Maroon;"">
1639                                                 <td colspan=""2"">Using Footer Text property</td>
1640                                                 </tr><tr align=""left"" style=""color:#000066;background-color:LightGrey;"">
1641                                                 <td colspan=""2"">
1642                                                 <a id=""FormView4_ctl01_LinkButton1"" href=""javascript:__doPostBack('FormView4$ctl01$LinkButton1','')"">Next</a>
1643                                                  <a id=""FormView4_ctl01_LinkButton2"" href=""javascript:__doPostBack('FormView4$ctl01$LinkButton2','')"">Prev</a>
1644                                                 <span id=""FormView4_ctl01_Label7"">Page Index: 0</span>
1645                                                 </td>
1646                                                 </tr>
1647                                                 </table>";
1648                         HtmlDiff.AssertAreEqual (origHtmlValue, newHtmlValue, "RenderingDefaultPaging");
1649                 }
1650
1651
1652                 [Test]
1653                 [Category ("NunitWeb")]
1654 //#if TARGET_JVM //BUG #6518
1655 //                [Category ("NotWorking")]
1656 //#endif
1657                 public void FormView_Render ()
1658                 {
1659                         string RenderedPageHtml = new WebTest ("FormViewTest1.aspx").Run ();
1660                         string newHtmlValue = RenderedPageHtml.Substring (RenderedPageHtml.IndexOf ("test3") + 5, RenderedPageHtml.IndexOf ("test4") - RenderedPageHtml.IndexOf ("test3") - 5);
1661                         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;"">
1662         <tr align=""center"" valign=""top"" style=""color:#C00000;background-color:Tan;font-weight:bold;"">
1663                 <td colspan=""2"">
1664                 <span id=""FormView3_Label5"">Header Template Test</span>
1665             </td>
1666         </tr><tr>
1667                 <td colspan=""2"">
1668                 <span id=""FormView3_Label4"">1</span>
1669             </td>
1670         </tr><tr align=""right"" style=""color:#FFC0FF;background-color:Tan;"">
1671                 <td colspan=""2"">
1672                 <span id=""FormView3_Label6"">FormView Footer</span>
1673             </td>
1674         </tr><tr align=""center"" style=""color:DarkSlateBlue;background-color:PaleGoldenrod;"">
1675                 <td colspan=""2""><table border=""0"">
1676                         <tr>
1677                                 <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>
1678                         </tr>
1679                 </table></td>
1680         </tr>
1681 </table>";
1682                         HtmlDiff.AssertAreEqual (origHtmlValue, newHtmlValue, "RenderingDefaultPaging");
1683                 }
1684
1685
1686                 [Test]
1687                 [Category ("NunitWeb")]
1688                 public void FormView_EditPostback ()
1689                 {
1690                         WebTest t = new WebTest ("FormViewInsertEditDelete.aspx");
1691                         string pageHTML = t.Run ();
1692                         string newHtml = pageHTML.Substring (pageHTML.IndexOf ("start") + 5, pageHTML.IndexOf ("end") - pageHTML.IndexOf ("start") - 5);
1693                         string origHtml = @" <div>
1694                                         &nbsp;
1695                                         <table cellspacing=""0"" border=""0"" id=""FormView1"" style=""border-collapse:collapse;"">
1696                                         <tr>
1697                                         <td colspan=""2"">
1698                                         <span id=""FormView1_ID"">1001</span>&nbsp;
1699                                          <span id=""FormView1_LName"">Chand</span>
1700                                          <span id=""FormView1_FName"">Mahesh</span>&nbsp;
1701                                         <a id=""FormView1_EditButton"" href=""javascript:__doPostBack('FormView1$EditButton','')"">Edit</a>
1702                                          <a id=""FormView1_NewButton"" href=""javascript:__doPostBack('FormView1$NewButton','')"">New</a>
1703                                         <a id=""FormView1_DeleteButton"" href=""javascript:__doPostBack('FormView1$DeleteButton','')"">Delete</a>
1704                                         </td>
1705                                         </tr><tr>
1706                                         <td colspan=""2""><table border=""0"">
1707                                         <tr>
1708                                         <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>
1709                                         </tr>
1710                                         </table></td>
1711                                         </tr>
1712                                         </table>
1713                                          </div>";
1714                         HtmlDiff.AssertAreEqual (origHtml, newHtml, "BeforeEditPostback");
1715
1716                         //Edit button postback (change to edit mode - buttons "Update" and "Cancel" should appear.
1717
1718                         FormRequest fr = new FormRequest (t.Response, "form1");
1719                         fr.Controls.Add ("__EVENTTARGET");
1720                         fr.Controls.Add ("__EVENTARGUMENT");
1721                         fr.Controls["__EVENTTARGET"].Value = "FormView1$EditButton";
1722                         fr.Controls["__EVENTARGUMENT"].Value = "";
1723                         t.Request = fr;
1724                         pageHTML = t.Run ();
1725                         newHtml = pageHTML.Substring (pageHTML.IndexOf ("start") + 5, pageHTML.IndexOf ("end") - pageHTML.IndexOf ("start") - 5);
1726                         origHtml = @" <div>
1727                                         &nbsp;
1728                                         <table cellspacing=""0"" border=""0"" id=""FormView1"" style=""border-collapse:collapse;"">
1729                                         <tr>
1730                                         <td colspan=""2"">
1731                                          Enter First Name:<input name=""FormView1$FNameEdit"" type=""text"" value=""Mahesh"" id=""FormView1_FNameEdit"" /><br />
1732                                          Enter Last Name:<input name=""FormView1$LNameEdit"" type=""text"" value=""Chand"" id=""FormView1_LNameEdit"" /><br />
1733                                          <a id=""FormView1_UpdateButton"" href=""javascript:__doPostBack('FormView1$UpdateButton','')"">Update</a>
1734                                         <a id=""FormView1_CancelUpdateButton"" href=""javascript:__doPostBack('FormView1$CancelUpdateButton','')"">Cancel</a>
1735                                          </td>
1736                                         </tr><tr>
1737                                         <td colspan=""2""><table border=""0"">
1738                                         <tr>
1739                                         <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>
1740                                         </tr>
1741                                         </table></td>
1742                                         </tr>
1743                                         </table>
1744                                         </div>";
1745                         HtmlDiff.AssertAreEqual (origHtml, newHtml, "AfterEditPostback");
1746
1747                         //Update record postback
1748
1749                         fr = new FormRequest (t.Response, "form1");
1750                         fr.Controls.Add ("__EVENTTARGET");
1751                         fr.Controls.Add ("__EVENTARGUMENT");
1752                         fr.Controls.Add ("FormView1$FNameEdit");
1753                         fr.Controls.Add ("FormView1$LNameEdit");
1754                         fr.Controls["__EVENTTARGET"].Value = "FormView1$UpdateButton";
1755                         fr.Controls["__EVENTARGUMENT"].Value = "";
1756                         fr.Controls["FormView1$FNameEdit"].Value = "Merav";
1757                         fr.Controls["FormView1$LNameEdit"].Value = "Test";
1758                         t.Request = fr;
1759                         pageHTML = t.Run ();
1760                         newHtml = pageHTML.Substring (pageHTML.IndexOf ("start") + 5, pageHTML.IndexOf ("end") - pageHTML.IndexOf ("start") - 5);
1761                         origHtml=@"  <div>
1762                                 &nbsp;
1763                                  <table cellspacing=""0"" border=""0"" id=""FormView1"" style=""border-collapse:collapse;"">
1764                                 <tr>
1765                                 <td colspan=""2"">
1766                                 <span id=""FormView1_ID"">1001</span>&nbsp;
1767                                  <span id=""FormView1_LName"">Test</span>
1768                                 <span id=""FormView1_FName"">Merav</span>&nbsp;
1769                                 <a id=""FormView1_EditButton"" href=""javascript:__doPostBack('FormView1$EditButton','')"">Edit</a>
1770                                 <a id=""FormView1_NewButton"" href=""javascript:__doPostBack('FormView1$NewButton','')"">New</a>
1771                                 <a id=""FormView1_DeleteButton"" href=""javascript:__doPostBack('FormView1$DeleteButton','')"">Delete</a>
1772                                 </td>
1773                                 </tr><tr>
1774                                 <td colspan=""2""><table border=""0"">
1775                                 <tr>
1776                                 <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>
1777                                 </tr>
1778                                 </table></td>
1779                                 </tr>
1780                                 </table>
1781                                 </div>";
1782                         HtmlDiff.AssertAreEqual (origHtml, newHtml, "AfterUpdatePostback");
1783
1784                         //Postback to return to Edit mode
1785                         fr = new FormRequest (t.Response, "form1");
1786                         fr.Controls.Add ("__EVENTTARGET");
1787                         fr.Controls.Add ("__EVENTARGUMENT");
1788                         fr.Controls["__EVENTTARGET"].Value = "FormView1$EditButton";
1789                         fr.Controls["__EVENTARGUMENT"].Value = "";
1790                         t.Request = fr;
1791                         pageHTML = t.Run ();
1792                         newHtml = pageHTML.Substring (pageHTML.IndexOf ("start") + 5, pageHTML.IndexOf ("end") - pageHTML.IndexOf ("start") - 5);
1793                         Assert.AreEqual (true, pageHTML.Contains ("Merav"), "EditModePostback1");
1794                         Assert.AreEqual (true, pageHTML.Contains ("CancelUpdateButton"), "EditModePostback2");
1795
1796                         // Cancel edited record postback
1797                         fr = new FormRequest (t.Response, "form1");
1798                         fr.Controls.Add ("__EVENTTARGET");
1799                         fr.Controls.Add ("__EVENTARGUMENT");
1800                         fr.Controls.Add ("FormView1$FNameEdit");
1801                         fr.Controls.Add ("FormView1$LNameEdit");
1802                         fr.Controls["FormView1$FNameEdit"].Value = "EditFirstName";
1803                         fr.Controls["FormView1$LNameEdit"].Value = "EditLastName";
1804                         fr.Controls["__EVENTTARGET"].Value = "FormView1$CancelUpdateButton";
1805                         fr.Controls["__EVENTARGUMENT"].Value = "";
1806                         t.Request = fr;
1807                         pageHTML = t.Run ();
1808                         newHtml = pageHTML.Substring (pageHTML.IndexOf ("start") + 5, pageHTML.IndexOf ("end") - pageHTML.IndexOf ("start") - 5);
1809                         origHtml = @" <div>
1810                                         &nbsp;
1811                                          <table cellspacing=""0"" border=""0"" id=""FormView1"" style=""border-collapse:collapse;"">
1812                                         <tr>
1813                                         <td colspan=""2"">
1814                                         <span id=""FormView1_ID"">1001</span>&nbsp;
1815                                         <span id=""FormView1_LName"">Test</span>
1816                                         <span id=""FormView1_FName"">Merav</span>&nbsp;
1817                                          <a id=""FormView1_EditButton"" href=""javascript:__doPostBack('FormView1$EditButton','')"">Edit</a>
1818                                         <a id=""FormView1_NewButton"" href=""javascript:__doPostBack('FormView1$NewButton','')"">New</a>
1819                                          <a id=""FormView1_DeleteButton"" href=""javascript:__doPostBack('FormView1$DeleteButton','')"">Delete</a>
1820                                          </td>
1821                                         </tr><tr>
1822                                         <td colspan=""2""><table border=""0"">
1823                                         <tr>
1824                                         <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>
1825                                         </tr>
1826                                         </table></td>
1827                                         </tr>
1828                                         </table>
1829                                         </div>";
1830                         HtmlDiff.AssertAreEqual (origHtml, newHtml, "CancelEditedRecordPostback");
1831
1832                 }
1833
1834                 [Test]
1835                 [Category ("NunitWeb")]
1836                 public void FormView_FireEvent_1 ()
1837                 {
1838                         WebTest t = new WebTest ("FormViewInsertEditDelete.aspx");
1839                         t.Invoker = PageInvoker.CreateOnInit (EditPostbackFireEvent_Init);
1840                         string html = t.Run ();
1841                         //Edit button postback (change to edit mode - buttons "Update" and "Cancel" should appear.
1842
1843                         FormRequest fr = new FormRequest (t.Response, "form1");
1844                         fr.Controls.Add ("__EVENTTARGET");
1845                         fr.Controls.Add ("__EVENTARGUMENT");
1846                         fr.Controls["__EVENTTARGET"].Value = "FormView1$EditButton";
1847                         fr.Controls["__EVENTARGUMENT"].Value = "";
1848                         t.Request = fr;
1849                         html = t.Run ();
1850
1851                         ArrayList eventlist = t.UserData as ArrayList;
1852                         if (eventlist == null)
1853                                 Assert.Fail ("User data does not been created fail");
1854
1855                         Assert.AreEqual ("ItemCommand", eventlist[0], "#1");
1856                         Assert.AreEqual ("ModeChanging", eventlist[1], "#2");
1857                         Assert.AreEqual ("ModeChanged", eventlist[2], "#3");
1858                         t.UserData = null;
1859
1860                         //Update record postback
1861
1862                         fr = new FormRequest (t.Response, "form1");
1863                         fr.Controls.Add ("__EVENTTARGET");
1864                         fr.Controls.Add ("__EVENTARGUMENT");
1865                         fr.Controls.Add ("FormView1$FNameEdit");
1866                         fr.Controls.Add ("FormView1$LNameEdit");
1867                         fr.Controls["__EVENTTARGET"].Value = "FormView1$UpdateButton";
1868                         fr.Controls["__EVENTARGUMENT"].Value = "";
1869                         fr.Controls["FormView1$FNameEdit"].Value = "Merav";
1870                         fr.Controls["FormView1$LNameEdit"].Value = "Test";
1871                         t.Request = fr;
1872                         html = t.Run ();
1873
1874                         eventlist = t.UserData as ArrayList;
1875                         if (eventlist == null)
1876                                 Assert.Fail ("User data does not been created fail");
1877
1878                         Assert.AreEqual ("ItemCommand", eventlist[0], "#1");
1879                         Assert.AreEqual ("ItemUpdating", eventlist[1], "#2");
1880                         Assert.AreEqual ("ItemUpdated", eventlist[2], "#3");
1881                         Assert.AreEqual ("ModeChanging", eventlist[3], "#4");
1882                         Assert.AreEqual ("ModeChanged", eventlist[4], "#5");
1883                 }
1884
1885                 #region FireEvents_1
1886                 public static void EditPostbackFireEvent_Init (Page p)
1887                 {
1888
1889                         FormView d = p.FindControl ("FormView1") as FormView;
1890                         if (d != null) {
1891                                 d.ModeChanged +=new EventHandler(d_ModeChanged);
1892                                 d.ModeChanging+=new FormViewModeEventHandler(d_ModeChanging);
1893                                 d.ItemCommand += new FormViewCommandEventHandler (d_ItemCommand);
1894                                 d.ItemUpdating += new FormViewUpdateEventHandler (d_ItemUpdating);
1895                                 d.ItemUpdated += new FormViewUpdatedEventHandler (d_ItemUpdated);
1896                         }
1897                 }
1898
1899                 static void d_ItemUpdated (object sender, FormViewUpdatedEventArgs e)
1900                 {
1901                         if (WebTest.CurrentTest.UserData == null) {
1902                                 ArrayList list = new ArrayList ();
1903                                 list.Add ("ItemUpdated");
1904                                 WebTest.CurrentTest.UserData = list;
1905                         }
1906                         else {
1907                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
1908                                 if (list == null)
1909                                         throw new NullReferenceException ();
1910                                 list.Add ("ItemUpdated");
1911                                 WebTest.CurrentTest.UserData = list;
1912                         }
1913                 }
1914
1915                 static void d_ItemUpdating (object sender, FormViewUpdateEventArgs e)
1916                 {
1917                         if (WebTest.CurrentTest.UserData == null) {
1918                                 ArrayList list = new ArrayList ();
1919                                 list.Add ("ItemUpdating");
1920                                 WebTest.CurrentTest.UserData = list;
1921                         }
1922                         else {
1923                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
1924                                 if (list == null)
1925                                         throw new NullReferenceException ();
1926                                 list.Add ("ItemUpdating");
1927                                 WebTest.CurrentTest.UserData = list;
1928                         }
1929                 }
1930
1931                 static void d_ItemCommand (object sender, FormViewCommandEventArgs e)
1932                 {
1933                         if (WebTest.CurrentTest.UserData == null) {
1934                                 ArrayList list = new ArrayList ();
1935                                 list.Add ("ItemCommand");
1936                                 WebTest.CurrentTest.UserData = list;
1937                         }
1938                         else {
1939                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
1940                                 if (list == null)
1941                                         throw new NullReferenceException ();
1942                                 list.Add ("ItemCommand");
1943                                 WebTest.CurrentTest.UserData = list;
1944                         }
1945                 }
1946
1947                 static void  d_ModeChanging(object sender, FormViewModeEventArgs e)
1948                 {
1949                         if (WebTest.CurrentTest.UserData == null)
1950                         {
1951                                 ArrayList list = new ArrayList ();
1952                                 list.Add ("ModeChanging");
1953                                 WebTest.CurrentTest.UserData = list;
1954                         }
1955                         else {
1956                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
1957                                 if (list == null)
1958                                         throw new NullReferenceException ();
1959                                 list.Add ("ModeChanging");
1960                                 WebTest.CurrentTest.UserData = list;
1961                         }
1962                 }
1963
1964                 static void  d_ModeChanged(object sender, EventArgs e)
1965                 {
1966                         if (WebTest.CurrentTest.UserData == null)
1967                                         {
1968                                 ArrayList list = new ArrayList ();
1969                                 list.Add ("ModeChanged");
1970                                 WebTest.CurrentTest.UserData = list;
1971                         }
1972                         else {
1973                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
1974                                 if (list == null)
1975                                         throw new NullReferenceException ();
1976                                 list.Add ("ModeChanged");
1977                                 WebTest.CurrentTest.UserData = list;
1978                         }
1979                 }
1980                 #endregion
1981
1982                 [Test]
1983                 [Category ("NunitWeb")]
1984                 public void FormView_FireEvent_2 ()
1985                 {
1986                         WebTest t = new WebTest ("FormViewInsertEditDelete.aspx");
1987                         t.Invoker = PageInvoker.CreateOnInit (FireEvent_2_Init);
1988                         t.Run ();
1989
1990                         // Checking for itemcreated event fired.
1991                         ArrayList eventlist = t.UserData as ArrayList;
1992                         if (eventlist == null)
1993                                 Assert.Fail ("User data does not been created fail");
1994
1995                         Assert.AreEqual ("ItemCreated", eventlist[0], "#1");
1996                 }
1997
1998                 #region FireEvent_2
1999                 public static void FireEvent_2_Init (Page p)
2000                 {
2001                         FormView d = p.FindControl ("FormView1") as FormView;
2002                         if (d != null) {
2003                                 d.ItemCreated += new EventHandler (d_ItemCreated);
2004                         }
2005                 }
2006
2007                 static void d_ItemCreated (object sender, EventArgs e)
2008                 {
2009                         if (WebTest.CurrentTest.UserData == null) {
2010                                 ArrayList list = new ArrayList ();
2011                                 list.Add ("ItemCreated");
2012                                 WebTest.CurrentTest.UserData = list;
2013                         }
2014                         else {
2015                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
2016                                 if (list == null)
2017                                         throw new NullReferenceException ();
2018                                 list.Add ("ItemCreated");
2019                                 WebTest.CurrentTest.UserData = list;
2020                         }
2021                 }
2022                 #endregion
2023
2024                 [Test]
2025                 [Category ("NunitWeb")]
2026                 public void FormView_FireEvent_3 ()
2027                 {
2028                         WebTest t = new WebTest ("FormViewInsertEditDelete.aspx");
2029                         t.Invoker = PageInvoker.CreateOnInit (FireEvent_3_Init);
2030                         t.Run ();
2031
2032                         FormRequest fr = new FormRequest (t.Response, "form1");
2033                         fr.Controls.Add ("__EVENTTARGET");
2034                         fr.Controls.Add ("__EVENTARGUMENT");
2035                         fr.Controls["__EVENTTARGET"].Value = "FormView1$NewButton";
2036                         fr.Controls["__EVENTARGUMENT"].Value = "";
2037                         t.Request = fr;
2038                         t.Run ();
2039
2040                         //Insert new record
2041
2042                         fr = new FormRequest (t.Response, "form1");
2043                         fr.Controls.Add ("__EVENTTARGET");
2044                         fr.Controls.Add ("__EVENTARGUMENT");
2045                         fr.Controls.Add ("FormView1$IDInsert");
2046                         fr.Controls.Add ("FormView1$FNameInsert");
2047                         fr.Controls.Add ("FormView1$LNameInsert");
2048                         fr.Controls["FormView1$IDInsert"].Value = "33";
2049                         fr.Controls["FormView1$FNameInsert"].Value = "InsertFirstName";
2050                         fr.Controls["FormView1$LNameInsert"].Value = "InsertLastName";
2051                         fr.Controls["__EVENTTARGET"].Value = "FormView1$InsertButton";
2052                         fr.Controls["__EVENTARGUMENT"].Value = "";
2053                         t.Request = fr;
2054                         t.Run ();
2055
2056                         ArrayList eventlist = t.UserData as ArrayList;
2057                         if (eventlist == null)
2058                                 Assert.Fail ("User data does not been created fail");
2059
2060                         Assert.AreEqual ("ItemInserting", eventlist[0], "#1");
2061                         Assert.AreEqual ("ItemInserted", eventlist[1], "#2");
2062                 }
2063
2064                 #region FireEvent_3
2065                 public static void FireEvent_3_Init (Page p)
2066                 {
2067                         FormView d = p.FindControl ("FormView1") as FormView;
2068                         if (d != null) {
2069                                 d.ItemInserted += new FormViewInsertedEventHandler (d_ItemInserted);
2070                                 d.ItemInserting += new FormViewInsertEventHandler (d_ItemInserting);
2071                         }
2072                 }
2073
2074                 static void d_ItemInserting (object sender, FormViewInsertEventArgs e)
2075                 {
2076                         if (WebTest.CurrentTest.UserData == null) {
2077                                 ArrayList list = new ArrayList ();
2078                                 list.Add ("ItemInserting");
2079                                 WebTest.CurrentTest.UserData = list;
2080                         }
2081                         else {
2082                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
2083                                 if (list == null)
2084                                         throw new NullReferenceException ();
2085                                 list.Add ("ItemInserting");
2086                                 WebTest.CurrentTest.UserData = list;
2087                         }
2088                 }
2089
2090                 static void d_ItemInserted (object sender, FormViewInsertedEventArgs e)
2091                 {
2092                         if (WebTest.CurrentTest.UserData == null) {
2093                                 ArrayList list = new ArrayList ();
2094                                 list.Add ("ItemInserted");
2095                                 WebTest.CurrentTest.UserData = list;
2096                         }
2097                         else {
2098                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
2099                                 if (list == null)
2100                                         throw new NullReferenceException ();
2101                                 list.Add ("ItemInserted");
2102                                 WebTest.CurrentTest.UserData = list;
2103                         }
2104                 }
2105                 #endregion
2106
2107                 [Test]
2108                 [Category ("NunitWeb")]
2109                 public void FormView_FireEvent_4 ()
2110                 {
2111                         WebTest t = new WebTest ("FormViewInsertEditDelete.aspx");
2112                         t.Invoker = PageInvoker.CreateOnInit (FireEvent_4_Init);
2113                         t.Run ();
2114
2115                         //Delete Item
2116                         FormRequest fr = new FormRequest (t.Response, "form1");
2117                         fr.Controls.Add ("__EVENTTARGET");
2118                         fr.Controls.Add ("__EVENTARGUMENT");
2119                         fr.Controls["__EVENTTARGET"].Value = "FormView1$DeleteButton";
2120                         fr.Controls["__EVENTARGUMENT"].Value = "";
2121                         t.Request = fr;
2122                         t.Run ();
2123
2124                         ArrayList eventlist = t.UserData as ArrayList;
2125                         if (eventlist == null)
2126                                 Assert.Fail ("User data does not been created fail");
2127
2128                         Assert.AreEqual ("ItemDeleting", eventlist[0], "#1");
2129                         Assert.AreEqual ("ItemDeleted", eventlist[1], "#2");
2130
2131                 }
2132
2133                 #region FireEvent_4
2134                 public static void FireEvent_4_Init (Page p)
2135                 {
2136                         FormView d = p.FindControl ("FormView1") as FormView;
2137                         if (d != null) {
2138                                 d.ItemDeleting += new FormViewDeleteEventHandler (d_ItemDeleting);
2139                                 d.ItemDeleted += new FormViewDeletedEventHandler (d_ItemDeleted);
2140                         }
2141                 }
2142
2143                 static void d_ItemDeleted (object sender, FormViewDeletedEventArgs e)
2144                 {
2145                         if (WebTest.CurrentTest.UserData == null) {
2146                                 ArrayList list = new ArrayList ();
2147                                 list.Add ("ItemDeleted");
2148                                 WebTest.CurrentTest.UserData = list;
2149                         }
2150                         else {
2151                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
2152                                 if (list == null)
2153                                         throw new NullReferenceException ();
2154                                 list.Add ("ItemDeleted");
2155                                 WebTest.CurrentTest.UserData = list;
2156                         }
2157                 }
2158
2159                 static void d_ItemDeleting (object sender, FormViewDeleteEventArgs e)
2160                 {
2161                         if (WebTest.CurrentTest.UserData == null) {
2162                                 ArrayList list = new ArrayList ();
2163                                 list.Add ("ItemDeleting");
2164                                 WebTest.CurrentTest.UserData = list;
2165                         }
2166                         else {
2167                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
2168                                 if (list == null)
2169                                         throw new NullReferenceException ();
2170                                 list.Add ("ItemDeleting");
2171                                 WebTest.CurrentTest.UserData = list;
2172                         }
2173                 }
2174                 #endregion
2175
2176                 [Test]
2177                 [Category ("NunitWeb")]
2178                 public void FormView_FireEvent_5 ()
2179                 {
2180                         WebTest t = new WebTest ("FormViewInsertEditDelete.aspx");
2181                         t.Invoker = PageInvoker.CreateOnInit (FireEvent_5_Init);
2182                         t.Run ();
2183
2184                         //Delete Item
2185                         FormRequest fr = new FormRequest (t.Response, "form1");
2186                         fr.Controls.Add ("__EVENTTARGET");
2187                         fr.Controls.Add ("__EVENTARGUMENT");
2188                         fr.Controls["__EVENTTARGET"].Value = "FormView1";
2189                         fr.Controls["__EVENTARGUMENT"].Value = "Page$2";
2190                         t.Request = fr;
2191                         t.Run ();
2192
2193                         ArrayList eventlist = t.UserData as ArrayList;
2194                         if (eventlist == null)
2195                                 Assert.Fail ("User data does not been created fail");
2196
2197                         Assert.AreEqual ("PageIndexChanging", eventlist[0], "#1");
2198                         Assert.AreEqual ("PageIndexChanged", eventlist[1], "#2");
2199                 }
2200
2201                 #region FireEvent_5
2202                 public static void FireEvent_5_Init (Page p)
2203                 {
2204                         FormView d = p.FindControl ("FormView1") as FormView;
2205                         if (d != null) {
2206                                 d.PageIndexChanged+=new EventHandler(d_PageIndexChanged);
2207                                 d.PageIndexChanging+=new FormViewPageEventHandler(d_PageIndexChanging);
2208                         }
2209                 }
2210
2211                 static void d_PageIndexChanging (object sender, FormViewPageEventArgs e)
2212                 {
2213                         if (WebTest.CurrentTest.UserData == null) {
2214                                 ArrayList list = new ArrayList ();
2215                                 list.Add ("PageIndexChanging");
2216                                 WebTest.CurrentTest.UserData = list;
2217                         }
2218                         else {
2219                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
2220                                 if (list == null)
2221                                         throw new NullReferenceException ();
2222                                 list.Add ("PageIndexChanging");
2223                                 WebTest.CurrentTest.UserData = list;
2224                         }
2225                 }
2226
2227                 static void d_PageIndexChanged (object sender, EventArgs e)
2228                 {
2229                         if (WebTest.CurrentTest.UserData == null) {
2230                                 ArrayList list = new ArrayList ();
2231                                 list.Add ("PageIndexChanged");
2232                                 WebTest.CurrentTest.UserData = list;
2233                         }
2234                         else {
2235                                 ArrayList list = WebTest.CurrentTest.UserData as ArrayList;
2236                                 if (list == null)
2237                                         throw new NullReferenceException ();
2238                                 list.Add ("PageIndexChanged");
2239                                 WebTest.CurrentTest.UserData = list;
2240                         }
2241                 }
2242                 #endregion
2243
2244                 [Test]
2245                 [Category ("NunitWeb")]
2246                 public void FormView_InsertPostback ()
2247                 {
2248                         WebTest t = new WebTest ("FormViewInsertEditDelete.aspx");
2249                         string pageHTML = t.Run ();
2250                         Assert.AreEqual (true, pageHTML.Contains ("1001"), "BeforeInsert1");
2251                         Assert.AreEqual (true, pageHTML.Contains ("Mahesh"), "BeforeInsert2");
2252                         Assert.AreEqual (true, pageHTML.Contains ("Chand"), "BeforeInsert3");
2253                         Assert.AreEqual (false, pageHTML.Contains ("Page$4"), "BeforeInsert4");
2254                         FormRequest fr = new FormRequest (t.Response, "form1");
2255                         fr.Controls.Add ("__EVENTTARGET");
2256                         fr.Controls.Add ("__EVENTARGUMENT");
2257                         fr.Controls["__EVENTTARGET"].Value = "FormView1$NewButton";
2258                         fr.Controls["__EVENTARGUMENT"].Value = "";
2259                         t.Request = fr;
2260                         pageHTML = t.Run ();
2261                         string newHtml = pageHTML.Substring (pageHTML.IndexOf ("start") + 5, pageHTML.IndexOf ("end") - pageHTML.IndexOf ("start") - 5);
2262                         string origHtml = @" <div>
2263                         &nbsp;
2264                         <table cellspacing=""0"" border=""0"" id=""FormView1"" style=""border-collapse:collapse;"">
2265                         <tr>
2266                         <td colspan=""2"">
2267                         Insert ID:
2268                          <input name=""FormView1$IDInsert"" type=""text"" id=""FormView1_IDInsert"" /><br />
2269                         Insert First Name:
2270                          <input name=""FormView1$FNameInsert"" type=""text"" id=""FormView1_FNameInsert"" />
2271                         <br />
2272                         Insert Last Name:&nbsp;
2273                          <input name=""FormView1$LNameInsert"" type=""text"" id=""FormView1_LNameInsert"" />
2274                         <a id=""FormView1_InsertButton"" href=""javascript:__doPostBack('FormView1$InsertButton','')"">Insert</a>
2275                         <a id=""FormView1_CancelInsertButton"" href=""javascript:__doPostBack('FormView1$CancelInsertButton','')"">Cancel</a>
2276                         </td>
2277                         </tr>
2278                         </table>
2279                          </div>";
2280                         HtmlDiff.AssertAreEqual (origHtml, newHtml, "InsertPostback");
2281
2282                         //Insert new record
2283
2284                         fr = new FormRequest (t.Response, "form1");
2285                         fr.Controls.Add ("__EVENTTARGET");
2286                         fr.Controls.Add ("__EVENTARGUMENT");
2287                         fr.Controls.Add ("FormView1$IDInsert");
2288                         fr.Controls.Add ("FormView1$FNameInsert");
2289                         fr.Controls.Add ("FormView1$LNameInsert");
2290                         fr.Controls["FormView1$IDInsert"].Value = "33";
2291                         fr.Controls["FormView1$FNameInsert"].Value = "InsertFirstName";
2292                         fr.Controls["FormView1$LNameInsert"].Value ="InsertLastName";
2293                         fr.Controls["__EVENTTARGET"].Value = "FormView1$InsertButton";
2294                         fr.Controls["__EVENTARGUMENT"].Value = "";
2295                         t.Request = fr;
2296                         pageHTML = t.Run ();
2297                         Assert.AreEqual (true, pageHTML.Contains ("1001"), "AfterInsert1");
2298                         Assert.AreEqual (true, pageHTML.Contains ("Mahesh"), "AfterInsert2");
2299                         Assert.AreEqual (true, pageHTML.Contains ("Chand"), "AfterInsert3");
2300                         Assert.AreEqual (true, pageHTML.Contains ("Page$4"), "AfterInsert4");
2301
2302                         //Checking that the inserted record appears on page 4.
2303
2304                         fr = new FormRequest (t.Response, "form1");
2305                         fr.Controls.Add ("__EVENTTARGET");
2306                         fr.Controls.Add ("__EVENTARGUMENT");
2307                         fr.Controls["__EVENTTARGET"].Value = "FormView1";
2308                         fr.Controls["__EVENTARGUMENT"].Value = "Page$4";
2309                         t.Request = fr;
2310                         pageHTML = t.Run ();
2311                         Assert.AreEqual (true, pageHTML.Contains ("33"), "AfterInsert1");
2312                         Assert.AreEqual (true, pageHTML.Contains ("InsertLastName"), "AfterInsert2");
2313                         Assert.AreEqual (true, pageHTML.Contains ("InsertFirstName"), "AfterInsert3");
2314
2315                 }
2316
2317                 [Test]
2318                 [Category ("NunitWeb")]
2319                 public void FormView_DeleteAndEmptyTemplatePostback ()
2320                 {
2321                         WebTest t = new WebTest ("FormViewInsertEditDelete.aspx");
2322                         string pageHTML = t.Run ();
2323
2324                         Assert.AreEqual (true, pageHTML.Contains ("1001"), "BeforeDelete1");
2325                         Assert.AreEqual (true, pageHTML.Contains ("Mahesh"), "BeforeDelete2");
2326                         Assert.AreEqual (true, pageHTML.Contains ("Chand"), "BeforeDelete3");
2327                         Assert.AreEqual (true, pageHTML.Contains ("Page$3"), "BeforeDelete4");
2328                         //Delete First Item
2329                         FormRequest fr = new FormRequest (t.Response, "form1");
2330                         fr.Controls.Add ("__EVENTTARGET");
2331                         fr.Controls.Add ("__EVENTARGUMENT");
2332                         fr.Controls["__EVENTTARGET"].Value = "FormView1$DeleteButton";
2333                         fr.Controls["__EVENTARGUMENT"].Value = "";
2334                         t.Request = fr;
2335                         pageHTML = t.Run ();
2336                         Assert.AreEqual (true, pageHTML.Contains ("1002"), "AfterFirstDelete1");
2337                         Assert.AreEqual (true, pageHTML.Contains ("Talmadge"), "AfterFirstDelete2");
2338                         Assert.AreEqual (true, pageHTML.Contains ("Melanie"), "AfterFirstDelete3");
2339                         Assert.AreEqual (true, pageHTML.Contains ("Page$2"), "AfterFirstDelete4");
2340                         Assert.AreEqual (false, pageHTML.Contains ("Page$3"), "AfterFirstDelete5");
2341
2342                         //Delete second item
2343
2344                         fr = new FormRequest (t.Response, "form1");
2345                         fr.Controls.Add ("__EVENTTARGET");
2346                         fr.Controls.Add ("__EVENTARGUMENT");
2347                         fr.Controls["__EVENTTARGET"].Value = "FormView1$DeleteButton";
2348                         fr.Controls["__EVENTARGUMENT"].Value = "";
2349                         t.Request = fr;
2350                         pageHTML = t.Run ();
2351                         Assert.AreEqual (true, pageHTML.Contains ("1003"), "AfterSecondDelete1");
2352                         Assert.AreEqual (true, pageHTML.Contains ("Bansal"), "AfterSecondDelete2");
2353                         Assert.AreEqual (true, pageHTML.Contains ("Vinay"), "AfterSecondDelete3");
2354                         Assert.AreEqual (false, pageHTML.Contains ("Page$2"), "AfterSecondDelete4");
2355
2356                         //Delete last item and checking that the EmptyDataTemplate appears.
2357
2358                         fr = new FormRequest (t.Response, "form1");
2359                         fr.Controls.Add ("__EVENTTARGET");
2360                         fr.Controls.Add ("__EVENTARGUMENT");
2361                         fr.Controls["__EVENTTARGET"].Value = "FormView1$DeleteButton";
2362                         fr.Controls["__EVENTARGUMENT"].Value = "";
2363                         t.Request = fr;
2364                         pageHTML = t.Run ();
2365                         Assert.AreEqual (true, pageHTML.Contains ("FormView1_Label1"), "EmptyTemplateTest1");
2366                         Assert.AreEqual (true, pageHTML.Contains ("The Database is empty"), "EmptyTemplateTest2");
2367                 }
2368
2369                 [Test]
2370                 public void FormView_CurrentMode () {
2371                         FormView view = new FormView ();
2372                         view.DefaultMode = FormViewMode.Insert;
2373                         Assert.AreEqual (FormViewMode.Insert, view.CurrentMode, "FormView_CurrentMode#1");
2374                         view.ChangeMode (FormViewMode.Edit);
2375                         Assert.AreEqual (FormViewMode.Edit, view.CurrentMode, "FormView_CurrentMode#2");
2376                 }
2377
2378                 [Test]
2379                 public void FormView_CreateDataSourceSelectArguments2 () {
2380                         DataSourceView view;
2381                         Page p = new Page ();
2382
2383                         Poker dv = new Poker ();
2384                         p.Controls.Add (dv);
2385
2386                         ObjectDataSource data = new ObjectDataSource ();
2387                         data.TypeName = typeof (DataSourceObject).AssemblyQualifiedName;
2388                         data.SelectMethod = "GetList";
2389                         data.SortParameterName = "sortExpression";
2390                         DataSourceSelectArguments arg;
2391                         p.Controls.Add (data);
2392
2393                         dv.DataSource = data;
2394                         dv.DataBind ();
2395
2396                         arg = dv.DoCreateDataSourceSelectArguments ();
2397                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "Default");
2398
2399                         dv.AllowPaging = true;
2400                         dv.PageIndex = 2;
2401                         arg = dv.DoCreateDataSourceSelectArguments ();
2402                         view = dv.DoGetData ();
2403                         Assert.IsFalse (view.CanPage);
2404                         Assert.IsTrue (view.CanRetrieveTotalRowCount);
2405                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "AllowPaging = true, CanPage = false, CanRetrieveTotalRowCount = true");
2406
2407                         // make DataSourceView.CanPage = true
2408                         data.EnablePaging = true;
2409
2410                         arg = dv.DoCreateDataSourceSelectArguments ();
2411                         view = dv.DoGetData ();
2412                         Assert.IsTrue (view.CanPage);
2413                         Assert.IsFalse (view.CanRetrieveTotalRowCount);
2414                         Assert.IsTrue (arg.Equals (new DataSourceSelectArguments (2, -1)), "AllowPaging = true, CanPage = true, CanRetrieveTotalRowCount = false");
2415
2416                         dv.AllowPaging = false;
2417                         arg = dv.DoCreateDataSourceSelectArguments ();
2418                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "AllowPaging = false, CanPage = true, CanRetrieveTotalRowCount = false");
2419
2420                         // make DataSourceView.CanRetrieveTotalRowCount = true
2421                         data.SelectCountMethod = "GetCount";
2422
2423                         arg = dv.DoCreateDataSourceSelectArguments ();
2424                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "AllowPaging = false, CanPage = true, CanRetrieveTotalRowCount = true");
2425
2426                         dv.AllowPaging = true;
2427                         arg = dv.DoCreateDataSourceSelectArguments ();
2428                         DataSourceSelectArguments arg1 = new DataSourceSelectArguments (2, 1);
2429                         arg1.RetrieveTotalRowCount = true;
2430                         view = dv.DoGetData ();
2431                         Assert.IsTrue (view.CanPage);
2432                         Assert.IsTrue (view.CanRetrieveTotalRowCount);
2433                         Assert.IsTrue (arg.Equals (arg1), "AllowPaging = true, CanPage = true, CanRetrieveTotalRowCount = true");
2434                 }
2435
2436                 [Test]
2437                 public void FormView_GetPostBackOptions () {
2438                         FormView fv = new FormView ();
2439                         fv.Page = new Page ();
2440                         IButtonControl btn = new Button ();
2441                         btn.CausesValidation = false;
2442                         Assert.IsFalse (btn.CausesValidation);
2443                         Assert.AreEqual (String.Empty, btn.CommandName);
2444                         Assert.AreEqual (String.Empty, btn.CommandArgument);
2445                         Assert.AreEqual (String.Empty, btn.PostBackUrl);
2446                         Assert.AreEqual (String.Empty, btn.ValidationGroup);
2447                         PostBackOptions options = ((IPostBackContainer) fv).GetPostBackOptions (btn);
2448                         Assert.IsFalse (options.PerformValidation);
2449                         Assert.IsFalse (options.AutoPostBack);
2450                         Assert.IsFalse (options.TrackFocus);
2451                         Assert.IsTrue (options.ClientSubmit);
2452                         Assert.IsTrue (options.RequiresJavaScriptProtocol);
2453                         Assert.AreEqual ("$", options.Argument);
2454                         Assert.AreEqual (null, options.ActionUrl);
2455                         Assert.AreEqual (null, options.ValidationGroup);
2456                         Assert.IsTrue (object.ReferenceEquals (options.TargetControl, fv));
2457
2458                         btn.ValidationGroup = "VG";
2459                         btn.CommandName = "CMD";
2460                         btn.CommandArgument = "ARG";
2461                         btn.PostBackUrl = "Page.aspx";
2462                         Assert.IsFalse (btn.CausesValidation);
2463                         Assert.AreEqual ("CMD", btn.CommandName);
2464                         Assert.AreEqual ("ARG", btn.CommandArgument);
2465                         Assert.AreEqual ("Page.aspx", btn.PostBackUrl);
2466                         Assert.AreEqual ("VG", btn.ValidationGroup);
2467                         options = ((IPostBackContainer) fv).GetPostBackOptions (btn);
2468                         Assert.IsFalse (options.PerformValidation);
2469                         Assert.IsFalse (options.AutoPostBack);
2470                         Assert.IsFalse (options.TrackFocus);
2471                         Assert.IsTrue (options.ClientSubmit);
2472                         Assert.IsTrue (options.RequiresJavaScriptProtocol);
2473                         Assert.AreEqual ("CMD$ARG", options.Argument);
2474                         Assert.AreEqual (null, options.ActionUrl);
2475                         Assert.AreEqual (null, options.ValidationGroup);
2476                 }
2477
2478                 [Test]
2479                 [ExpectedException (typeof (InvalidOperationException))]
2480                 public void FormView_GetPostBackOptions_CausesValidation () {
2481                         FormView fv = new FormView ();
2482                         fv.Page = new Page ();
2483                         IButtonControl btn = new Button ();
2484                         Assert.IsTrue (btn.CausesValidation);
2485                         Assert.AreEqual (String.Empty, btn.CommandName);
2486                         Assert.AreEqual (String.Empty, btn.CommandArgument);
2487                         Assert.AreEqual (String.Empty, btn.PostBackUrl);
2488                         Assert.AreEqual (String.Empty, btn.ValidationGroup);
2489                         PostBackOptions options = ((IPostBackContainer) fv).GetPostBackOptions (btn);
2490                 }
2491
2492                 [Test]
2493                 [ExpectedException (typeof (ArgumentNullException))]
2494                 public void FormView_GetPostBackOptions_Null_Argument () {
2495                         FormView fv = new FormView ();
2496                         fv.Page = new Page ();
2497                         PostBackOptions options = ((IPostBackContainer) fv).GetPostBackOptions (null);
2498                 }
2499
2500                 [Test]
2501                 [Category ("NunitWeb")]
2502                 public void FormView_RequiresDataBinding () {
2503                         PageDelegates delegates = new PageDelegates ();
2504                         delegates.LoadComplete = FormView_RequiresDataBinding_LoadComplete;
2505                         PageInvoker invoker = new PageInvoker (delegates);
2506                         WebTest t = new WebTest (invoker);
2507                         t.Run ();
2508                 }
2509
2510                 public static void FormView_RequiresDataBinding_LoadComplete (Page p) {
2511                         Poker view = new Poker ();
2512                         p.Form.Controls.Add (view);
2513
2514                         view.DataSource = new string [] { "A", "B", "C" };
2515                         view.DataBind ();
2516
2517                         Assert.AreEqual (false, view.GetRequiresDataBinding ());
2518
2519                         view.PagerTemplate = new CompiledTemplateBuilder (BuildTemplateMethod);
2520                         Assert.AreEqual (false, view.GetRequiresDataBinding (), "PagerTemplate was set");
2521
2522                         view.EmptyDataTemplate = new CompiledTemplateBuilder (BuildTemplateMethod);
2523                         Assert.AreEqual (false, view.GetRequiresDataBinding (), "EmptyDataTemplate was set");
2524
2525                         view.HeaderTemplate = new CompiledTemplateBuilder (BuildTemplateMethod);
2526                         Assert.AreEqual (false, view.GetRequiresDataBinding (), "HeaderTemplate was set");
2527
2528                         view.FooterTemplate = new CompiledTemplateBuilder (BuildTemplateMethod);
2529                         Assert.AreEqual (false, view.GetRequiresDataBinding (), "FooterTemplate was set");
2530
2531                         view.EditItemTemplate = new CompiledTemplateBuilder (BuildTemplateMethod);
2532                         Assert.AreEqual (false, view.GetRequiresDataBinding (), "EditItemTemplate was set");
2533
2534                         view.InsertItemTemplate = new CompiledTemplateBuilder (BuildTemplateMethod);
2535                         Assert.AreEqual (false, view.GetRequiresDataBinding (), "InsertItemTemplate was set");
2536
2537                         view.ItemTemplate = new CompiledTemplateBuilder (BuildTemplateMethod);
2538                         Assert.AreEqual (false, view.GetRequiresDataBinding (), "ItemTemplate was set");
2539                 }
2540
2541                 public static void BuildTemplateMethod (Control c) { }
2542         }
2543
2544         public class TestMyData
2545         {
2546                 static IList<int> str;
2547                 //str.(new int[] { 1, 2, 3, 4, 5, 6 });
2548
2549                 static TestMyData ()
2550                 {
2551                         InitData ();
2552                 }
2553
2554                 public static void InitData()
2555                 {
2556                         str = new List<int> ();
2557                         for (int i=1;i<7;i++)
2558                                 str.Add (i);
2559                 }
2560                 public static IList<int> GetMyList()
2561                 {
2562                         return str;
2563                 }
2564
2565                 public static int UpdateList(int index, int value)
2566                 {
2567                         str[index] = value;
2568                         return str[index];
2569                 }
2570
2571                 public static int InsertList(int value)
2572                 {
2573                         str.Add(value);
2574                         return value;
2575                 }
2576
2577                 public static void DeleteList(int value)
2578                 {
2579                         str.Remove(value);
2580                 }
2581
2582         }
2583
2584         public class MyTemplate : ITemplate
2585         {
2586
2587                 Label l = new Label ();
2588 #region ITemplate Members
2589
2590                 public void InstantiateIn (Control container)
2591                 {
2592                         container.Controls.Add (l);
2593
2594                 }
2595
2596                 public void SetDataItem (object value)
2597                 {
2598                         l.Text = value.ToString ();
2599                 }
2600
2601 #endregion
2602         }
2603
2604 public class FormViewDataObject
2605         {
2606
2607                 public static DataTable ds = CreateDataTable();
2608
2609                 public static DataTable Select()
2610                 {
2611
2612                         return ds;
2613
2614                 }
2615
2616
2617
2618                 public static DataTable Delete(string ID, string FName, string LName)
2619                 {
2620
2621                         DataRow dr = ds.Rows.Find(ID);
2622
2623                         if (dr != null)
2624                         {
2625
2626                                 ds.Rows.Remove(dr);
2627
2628                         }
2629
2630                         return ds;
2631
2632                 }
2633
2634
2635
2636                 public static DataTable Insert(string ID, string FName, string LName)
2637                 {
2638
2639                         DataRow dr = ds.NewRow();
2640                         dr["ID"] = ID;
2641                         dr["FName"] = FName;
2642                         dr["LName"] = LName;
2643                         ds.Rows.Add(dr);
2644                         return ds;
2645                 }
2646
2647
2648
2649                 public static DataTable Update(string ID, string FName, string LName)
2650                 {
2651                         DataRow dr = ds.Rows.Find(ID);
2652                         if (dr == null)
2653                         {
2654                                 Label lbl = new Label();
2655                                 lbl.Text = "ID doesn't exist ";
2656                                 return ds;
2657                         }
2658                         dr["FName"] = FName;
2659                         dr["LName"] = LName;
2660                         return ds;
2661
2662                 }
2663
2664
2665
2666                 public static DataTable CreateDataTable()
2667                 {
2668
2669                         DataTable aTable = new DataTable("A");
2670                         DataColumn dtCol;
2671                         DataRow dtRow;
2672
2673                         // Create ID column and add to the DataTable.
2674
2675                         dtCol = new DataColumn();
2676                         dtCol.DataType = Type.GetType("System.Int32");
2677                         dtCol.ColumnName = "ID";
2678                         dtCol.AutoIncrement = true;
2679                         dtCol.Caption = "ID";
2680                         dtCol.ReadOnly = true;
2681                         dtCol.Unique = true;
2682                         aTable.Columns.Add(dtCol);
2683
2684
2685
2686                         // Create Name column and add to the table
2687
2688                         dtCol = new DataColumn();
2689                         dtCol.DataType = Type.GetType("System.String");
2690                         dtCol.ColumnName = "FName";
2691                         dtCol.AutoIncrement = false;
2692                         dtCol.Caption = "First Name";
2693                         dtCol.ReadOnly = false;
2694                         dtCol.Unique = false;
2695                         aTable.Columns.Add(dtCol);
2696
2697
2698
2699                         // Create Last Name column and add to the table.
2700
2701                         dtCol = new DataColumn();
2702                         dtCol.DataType = Type.GetType("System.String");
2703                         dtCol.ColumnName = "LName";
2704                         dtCol.AutoIncrement = false;
2705                         dtCol.Caption = "Last Name";
2706                         dtCol.ReadOnly = false;
2707                         dtCol.Unique = false;
2708                         aTable.Columns.Add(dtCol);
2709
2710
2711
2712                         // Create three rows to the table
2713
2714                         dtRow = aTable.NewRow();
2715                         dtRow["ID"] = 1001;
2716                         dtRow["FName"] = "Mahesh";
2717                         dtRow["LName"] = "Chand";
2718                         aTable.Rows.Add(dtRow);
2719
2720                         dtRow = aTable.NewRow();
2721                         dtRow["ID"] = 1002;
2722                         dtRow["FName"] = "Melanie";
2723                         dtRow["LName"] = "Talmadge";
2724                         aTable.Rows.Add(dtRow);
2725
2726                         dtRow = aTable.NewRow();
2727                         dtRow["ID"] = 1003;
2728                         dtRow["FName"] = "Vinay";
2729                         dtRow["LName"] = "Bansal";
2730                         aTable.Rows.Add(dtRow);
2731
2732                         aTable.PrimaryKey = new DataColumn[] { aTable.Columns["ID"] };
2733                         return aTable;
2734
2735                 }
2736         }
2737 }
2738
2739
2740 #endif