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