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