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