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

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