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

   1 //
   2 // Tests for System.Web.UI.WebControls.FormView.cs
   3 //
   4 // Author:
   5 //      Merav Sudri (meravs@mainsoft.com)
   6 //
   7 //
   8 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 #if NET_2_0
  31
  32 using NUnit.Framework;
  33 using System;
  34 using System.IO;
  35 using System.Data;
  36 using System.Drawing;
  37 using System.Collections;
  38 using System.Collections.Specialized;
  39 using System.Globalization;
  40 using System.Web;
  41 using System.Web.UI;
  42 using System.Web.UI.HtmlControls;
  43 using System.Web.UI.WebControls;
  44 using MonoTests.SystemWeb.Framework;
  45 using MonoTests.stand_alone.WebHarness;
  46 using System.Collections.Generic;
  47
  48
  49 namespace MonoTests.System.Web.UI.WebControls
  50 {
  51         [TestFixture]
  52         public class DetailsViewTest {
  53
  54                 public class DataSourceObject
  55                 {
  56                         public static List<string> GetList (string sortExpression, int startRowIndex, int maximumRows) {
  57                                 return GetList ();
  58                         }
  59
  60                         public static List<string> GetList (int startRowIndex, int maximumRows) {
  61                                 return GetList ();
  62                         }
  63
  64                         public static List<string> GetList (string sortExpression) {
  65                                 return GetList ();
  66                         }
  67
  68                         public static List<string> GetList () {
  69                                 List<string> list = new List<string> ();
  70                                 list.Add ("Norway");
  71                                 list.Add ("Sweden");
  72                                 list.Add ("France");
  73                                 list.Add ("Italy");
  74                                 list.Add ("Israel");
  75                                 list.Add ("Russia");
  76                                 return list;
  77                         }
  78
  79                         public static int GetCount () {
  80                                 return GetList ().Count;
  81                         }
  82                 }
  83
  84                 public class PokerDetailsView : DetailsView
  85                 {
  86                         public bool ensureDataBound=false;
  87                         public bool isInitializePager = false;
  88                         public bool controlHierarchy = false;
  89                         public bool ensureCreateChildControls = false;
  90                         public bool createChildControls1 = false;
  91                         public bool createChildControls2 = false;
  92                         public PokerDetailsView ()
  93                         {
  94                          TrackViewState ();
  95                         }
  96
  97                         public object SaveState ()
  98                         {
  99                          return SaveViewState ();
 100                         }
 101
 102                          public void LoadState (object o)
 103                         {
 104                          LoadViewState (o);
 105                         }
 106
 107                         public StateBag StateBag
 108                         {
 109                           get { return base.ViewState; }
 110                         }
 111
 112                         public HtmlTextWriterTag PokerTagKey
 113                         {
 114                                 get { return base.TagKey; }
 115                         }
 116
 117                         public string Render ()
 118                         {
 119                                 StringWriter sw = new StringWriter ();
 120                                 HtmlTextWriter tw = new HtmlTextWriter (sw);
 121                                 Render (tw);
 122                                 return sw.ToString ();
 123                         }
 124
 125                         public void DoOnInit (EventArgs e)
 126                         {
 127                                 OnInit (e);
 128                         }
 129
 130                         public void DoOnDataSourceViewChanged (Object sender, EventArgs e)
 131                         {
 132                                 OnDataSourceViewChanged (sender, e);
 133                         }
 134
 135                         public void DoOnItemCommand (DetailsViewCommandEventArgs e)
 136                         {
 137                                 OnItemCommand (e);
 138                         }
 139
 140                         public void DoOnItemCreated (EventArgs e)
 141                         {
 142                                 OnItemCreated (e);
 143                         }
 144
 145                         public void DoOnItemDeleted (DetailsViewDeletedEventArgs e)
 146                         {
 147                                 OnItemDeleted (e);
 148                         }
 149
 150                         public void DoOnItemDeleting  (DetailsViewDeleteEventArgs e)
 151                         {
 152                                 OnItemDeleting (e);
 153                         }
 154
 155                         public void DoOnItemInserted (DetailsViewInsertedEventArgs e)
 156                         {
 157                                 OnItemInserted (e);
 158                         }
 159
 160                         public void DoOnItemInserting (DetailsViewInsertEventArgs e)
 161                         {
 162                                 OnItemInserting (e);
 163                         }
 164
 165                         public void DoOnItemUpdated (DetailsViewUpdatedEventArgs  e)
 166                         {
 167                                 OnItemUpdated(e);
 168                         }
 169
 170                         public void DoOnItemUpdating (DetailsViewUpdateEventArgs e)
 171                         {
 172                                 OnItemUpdating (e);
 173                         }
 174
 175
 176                         public void DoOnModeChanged (EventArgs e)
 177                         {
 178                                 OnModeChanged (e);
 179                         }
 180                         public void DoOnModeChanging (DetailsViewModeEventArgs e)
 181                         {
 182                                 OnModeChanging (e);
 183                         }
 184                         public void DoOnPageIndexChanged (EventArgs e)
 185                         {
 186                                 OnPageIndexChanged (e);
 187                         }
 188                         public void DoOnPageIndexChanging (DetailsViewPageEventArgs e)
 189                         {
 190                                 OnPageIndexChanging (e);
 191                         }
 192
 193                         public void DoOnPagePreLoad  (Object sender , EventArgs e)
 194                         {
 195                                 OnPagePreLoad (sender, e);
 196                         }
 197                         public void DoOnPreRender (EventArgs e)
 198                         {
 199                                 OnPreRender (e);
 200                         }
 201                         public void DoOnUnload (EventArgs e)
 202                         {
 203                                 OnUnload (e);
 204                         }
 205                         public void DoOnBubbleEvent (Object sender, EventArgs e)
 206                         {
 207                                 OnBubbleEvent (sender,e);
 208                         }
 209
 210                         public Object DoSaveControlState ()
 211                         {
 212                                 return SaveControlState ();
 213                         }
 214
 215                         public void DoLoadControlState (Object saveState)
 216                         {
 217                                 LoadControlState (saveState);
 218                         }
 219
 220                         public AutoGeneratedField DoCreateAutoGeneratedRow (AutoGeneratedFieldProperties filedProperties)
 221                         {
 222                                 return CreateAutoGeneratedRow (filedProperties);
 223                         }
 224
 225                         public ICollection DoCreateAutoGeneratedRows (Object DataItem)
 226                         {
 227                                 return CreateAutoGeneratedRows (DataItem);
 228                         }
 229
 230                         public int DoCreateChildControls (IEnumerable dataSource,bool dataBinding)
 231                         {
 232                                 return CreateChildControls (dataSource, dataBinding);
 233                         }
 234
 235                         public Style DoCreateControlStyle ()
 236                         {
 237                                 return CreateControlStyle ();
 238                         }
 239
 240                         public DetailsViewRow  DoCreateRow (int rowIndex,DataControlRowType rowType, DataControlRowState rowState)
 241                         {
 242                                 return CreateRow (rowIndex, rowType, rowState);
 243                         }
 244
 245                         public Table DoCreateTable ()
 246                         {
 247                                 return CreateTable ();
 248                         }
 249
 250                         protected override void EnsureDataBound ()
 251                         {
 252                                 base.EnsureDataBound ();
 253                                 ensureDataBound = true;
 254                         }
 255
 256                         protected override void EnsureChildControls ()
 257                         {
 258                                 base.EnsureChildControls ();
 259                                 ensureCreateChildControls = true;
 260                         }
 261
 262                         protected override void CreateChildControls ()
 263                         {
 264                                 base.CreateChildControls ();
 265                                 createChildControls1 = true;
 266                         }
 267
 268                         protected override int CreateChildControls (IEnumerable data, bool dataBinding)
 269                         {
 270                                 createChildControls2 = true;
 271                                 return base.CreateChildControls (data, dataBinding);
 272                         }
 273
 274                         public void DoConfirmInitState ()
 275                         {
 276                                 base.ConfirmInitState ();
 277                         }
 278
 279                         public void DoExtractRowValues (IOrderedDictionary fieldValues, bool includeReadOnlyFields, bool includeKeys)
 280                         {
 281                                 ExtractRowValues (fieldValues, includeReadOnlyFields, includeKeys);
 282                         }
 283
 284                         public ICollection  DoCreateFieldSet (Object dataItem, bool useDataSource)
 285                         {
 286                                 return CreateFieldSet (dataItem, useDataSource);
 287                         }
 288
 289                         public string DoGetCallbackResult ()
 290                         {
 291                                 return GetCallbackResult ();
 292                         }
 293
 294                         public string DoGetCallbackScript (IButtonControl buttonControl, string argument)
 295                         {
 296                                 return GetCallbackScript (buttonControl, argument);
 297                         }
 298
 299                         protected override void InitializePager (DetailsViewRow row, PagedDataSource pagedDataSource)
 300                         {
 301                                 base.InitializePager (row,pagedDataSource);
 302                                 isInitializePager = true;
 303                         }
 304
 305                         public void DoPerformDataBinding (IEnumerable data)
 306                         {
 307                                 PerformDataBinding (data);
 308                         }
 309
 310                         protected override void PrepareControlHierarchy ()
 311                         {
 312                                 base.PrepareControlHierarchy ();
 313                                 controlHierarchy = true;
 314                         }
 315
 316                         public void DoRaiseCallbackEvent (string eventArgument)
 317                         {
 318                                 base.RaiseCallbackEvent (eventArgument);
 319                         }
 320
 321                         public void DoEnsureChildControls ()
 322                         {
 323                                 base.EnsureChildControls ();
 324                         }
 325
 326                         public DataSourceSelectArguments DoCreateDataSourceSelectArguments ()
 327                         {
 328                                 return CreateDataSourceSelectArguments ();
 329                         }
 330
 331                         public DataSourceView DoGetData ()
 332                         {
 333                                 return GetData ();
 334                         }
 335                 }
 336
 337                 ArrayList myds = new ArrayList ();
 338                 [TestFixtureSetUp]
 339                 public void setup ()
 340                 {
 341                         myds.Add ("Item1");
 342                         myds.Add ("Item2");
 343                         myds.Add ("Item3");
 344                         myds.Add ("Item4");
 345                         myds.Add ("Item5");
 346                         myds.Add ("Item6");
 347 #if VISUAL_STUDIO
 348                         WebTest.CopyResource (GetType (), "MonoTests.System.Web.UI.WebControls.Resources.FooterTemplateTest.aspx",
 349                                 "FooterTemplateTest.aspx");
 350                         WebTest.CopyResource (GetType (), "MonoTests.System.Web.UI.WebControls.Resources.DetailsViewTemplates.aspx",
 351                                 "DetailsViewTemplates.aspx");
 352                         WebTest.CopyResource (GetType (), "MonoTests.System.Web.UI.WebControls.Resources.DetailsViewDataActions.aspx",
 353                                 "DetailsViewDataActions.aspx");
 354                         WebTest.CopyResource (GetType (), "MonoTests.System.Web.UI.WebControls.Resources.DetailsViewProperties1.aspx",
 355                                 "DetailsViewProperties1.aspx");
 356 #else
 357                         WebTest.CopyResource (GetType (), "FooterTemplateTest.aspx", "FooterTemplateTest.aspx");
 358                         WebTest.CopyResource (GetType (), "DetailsViewTemplates.aspx", "DetailsViewTemplates.aspx");
 359                         WebTest.CopyResource (GetType (), "DetailsViewDataActions.aspx", "DetailsViewDataActions.aspx");
 360                         WebTest.CopyResource (GetType (), "DetailsViewProperties1.aspx", "DetailsViewProperties1.aspx");
 361 #endif
 362
 363                 }
 364
 365
 366
 367                 [Test]
 368                 [Category ("NotWorking")]
 369                 public void DetailsView_DefaultProperties ()
 370                 {
 371                         PokerDetailsView dv = new PokerDetailsView ();
 372                         Assert.IsNotNull (dv.Rows);
 373                         Assert.AreEqual (false, dv.AllowPaging, "AllowPagingDefault");
 374                         Assert.AreEqual (typeof(TableItemStyle), dv.AlternatingRowStyle.GetType(),"AlternatingRowStyleDefault") ;
 375                         Assert.AreEqual (false, dv.AutoGenerateDeleteButton, "AutoGenerateDeleteButtonDefault");
 376                         Assert.AreEqual (false, dv.AutoGenerateEditButton, "AutoGenerateEditButtonDefault");
 377                         Assert.AreEqual (false, dv.AutoGenerateInsertButton, "AutoGenerateInsertButtonDefault");
 378                         Assert.AreEqual (true, dv.AutoGenerateRows, "AutoGenerateRowsDefault");
 379                         Assert.AreEqual ("", dv.BackImageUrl, "BackImageUrlDefault");
 380                         Assert.AreEqual (null, dv.BottomPagerRow, "BottomPagerRowDefault");
 381                         Assert.AreEqual ("", dv.Caption, "CaptionDefault");
 382                         Assert.AreEqual (TableCaptionAlign.NotSet, dv.CaptionAlign, "CaptionAlignDefault");
 383                         Assert.AreEqual (-1, dv.CellPadding, "CellPaddingDefault");
 384                         Assert.AreEqual (0, dv.CellSpacing, "CellSpacingDefault");
 385                         Assert.AreEqual (typeof(TableItemStyle), dv.CommandRowStyle.GetType(),"CommandRowStyleDefault");
 386                         Assert.AreEqual (DetailsViewMode.ReadOnly, dv.CurrentMode, "CurrentModeDefault");
 387                         Assert.AreEqual (null, dv.DataItem, "DataItemDefault");
 388                         Assert.AreEqual (0, dv.DataItemCount, " DataItemCountDefault");
 389                         Assert.AreEqual (0, dv.DataItemIndex, "DataItemIndexDefault");
 390                         Assert.AreEqual (typeof (DataKey), dv.DataKey.GetType (), "DataKeyDefault");
 391                         Assert.AreEqual (new string[0],dv.DataKeyNames,"DataKeyNamesDefault");
 392                         Assert.AreEqual (DetailsViewMode.ReadOnly, dv.DefaultMode, "DefaultMode");
 393                         Assert.AreEqual (typeof (TableItemStyle),dv.EditRowStyle.GetType(),"EditRowStyleDefault");
 394                         Assert.AreEqual (typeof (TableItemStyle),dv.EmptyDataRowStyle.GetType(), " EmptyDataRowStyleDefault");
 395                         Assert.AreEqual (null,dv.EmptyDataTemplate,"EmptyDataTemplate");
 396                         Assert.AreEqual (false,dv.EnablePagingCallbacks, "EnablePagingCallbacksDefault");
 397                         Assert.AreEqual (true,dv.FieldHeaderStyle.IsEmpty,"FieldHeaderStyleDefault");
 398                         Assert.AreEqual (typeof (TableItemStyle),dv.FieldHeaderStyle.GetType() ,"FieldHeaderStyleDefault");
 399                         Assert.AreEqual (0, dv.Fields.Count  ,"FiledsDefault");
 400                         Assert.AreEqual (null, dv.FooterRow, "FooterRowDefault1");
 401                         Assert.AreEqual (typeof (TableItemStyle), dv.FooterStyle.GetType (), "FooterStyleDefault");
 402                         Assert.AreEqual (null, dv.FooterTemplate, "FooterTemplateDefault");
 403                         Assert.AreEqual ("", dv.FooterText, "FooterTextDefault");
 404                         Assert.AreEqual (GridLines.Both, dv.GridLines, "GridLinesDefault");
 405                         Assert.AreEqual (null, dv.HeaderRow, "HeaderRowDefault");
 406                         Assert.AreEqual (typeof (TableItemStyle), dv.HeaderStyle.GetType() , "HeaderStyleDefault");
 407                         Assert.AreEqual (null, dv.HeaderTemplate, "HeaderTemplateDefault");
 408                         Assert.AreEqual ("", dv.HeaderText, "HeaderTextDefault");
 409                         Assert.AreEqual (HorizontalAlign.NotSet, dv.HorizontalAlign, "HorizontalAlignDefault");
 410                         Assert.AreEqual (typeof (TableItemStyle), dv.InsertRowStyle.GetType (), "InsertRowStyleDefault");
 411                         Assert.AreEqual (0, dv.PageCount, "PageCountDefault");
 412                         Assert.AreEqual (0, dv.PageIndex, "PageIndexDefault");
 413                         Assert.AreEqual (typeof (PagerSettings), dv.PagerSettings.GetType() , "PagerSettingsDefault");
 414                         Assert.AreEqual (typeof (TableItemStyle), dv.PagerStyle.GetType() , "PagerStyleDefault");
 415                         Assert.AreEqual (null, dv.PagerTemplate, "PagerTemplateDefault");
 416                         Assert.AreEqual (0, dv.Rows.Count, "RowsDefault1");
 417                         Assert.AreEqual (typeof (DetailsViewRowCollection), dv.Rows.GetType (), "RowDefault2");
 418                         Assert.AreEqual (typeof (TableItemStyle), dv.RowStyle.GetType (), "RowStyleDefault");
 419                         Assert.AreEqual (null, dv.SelectedValue, "SelectedValueDefault");
 420                         Assert.AreEqual (null, dv.TopPagerRow, "TopPagerRow");
 421                 }
 422
 423                 [Test]
 424                 [Category ("NotWorking")]
 425                 public void DetailsView_AssignToDefaultProperties ()
 426                 {
 427                         PokerDetailsView dv = new PokerDetailsView ();
 428                         dv.AllowPaging = true;
 429                         dv.DataSource = myds;
 430                         dv.DataBind ();
 431                         Assert.AreEqual (true, dv.AllowPaging, "AllowPaging");
 432                         dv.AlternatingRowStyle.CssClass = "style.css";
 433                         Assert.AreEqual ("style.css", dv.AlternatingRowStyle.CssClass, "AlternatingRowStyle");
 434                         dv.AutoGenerateDeleteButton = true;
 435                         Assert.AreEqual (true, dv.AutoGenerateDeleteButton, "AutoGenerateDeleteButton");
 436                         dv.AutoGenerateEditButton = true;
 437                         Assert.AreEqual (true, dv.AutoGenerateEditButton, "AutoGenerateEditButton");
 438                         dv.AutoGenerateInsertButton = true;
 439                         Assert.AreEqual (true, dv.AutoGenerateInsertButton, "AutoGenerateInsertButton");
 440                         dv.AutoGenerateRows = false;
 441                         Assert.AreEqual (false, dv.AutoGenerateRows, "AutoGenerateRows");
 442                         dv.BackImageUrl = "image.jpg";
 443                         Assert.AreEqual ("image.jpg", dv.BackImageUrl, "BackImageUrl");
 444                         dv.Caption = "Caption Test";
 445                         Assert.AreEqual ("Caption Test", dv.Caption, "Caption");
 446                         dv.CaptionAlign = TableCaptionAlign.Right;
 447                         Assert.AreEqual (TableCaptionAlign.Right, dv.CaptionAlign, "CaptionAlign");
 448                         dv.CellPadding = 2;
 449                         Assert.AreEqual (2, dv.CellPadding, "CellPadding");
 450                         dv.CellSpacing = 5;
 451                         Assert.AreEqual (5, dv.CellSpacing, "CellSpacing");
 452                         dv.CommandRowStyle.BackColor = Color.Purple;
 453                         Assert.AreEqual (Color.Purple, dv.CommandRowStyle.BackColor, "CommandRowStyle.BackColor");
 454                         dv.ChangeMode (DetailsViewMode.Insert);
 455                         Assert.AreEqual (DetailsViewMode.Insert, dv.CurrentMode, "CurrentModeInsert");
 456                         dv.ChangeMode (DetailsViewMode.Edit );
 457                         Assert.AreEqual (DetailsViewMode.Edit, dv.CurrentMode, "CurrentModeEdit");
 458                         Assert.AreEqual ("Item1", dv.DataItem, "DataItem");
 459                         Assert.AreEqual (6, dv.DataItemCount, "DataItemCount");
 460                         Assert.AreEqual (0, dv.DataItemIndex, "DataItemIndex");
 461                         string[] names ={ "test1", "test2", "test3" };
 462                         dv.DataKeyNames = names;
 463                         Assert.AreEqual (names, dv.DataKeyNames, "DataKeyNames");
 464                         dv.DefaultMode = DetailsViewMode.Edit;
 465                         Assert.AreEqual (DetailsViewMode.Edit, dv.DefaultMode, "DefaultModeEdit");
 466                         dv.DefaultMode = DetailsViewMode.Insert;
 467                         Assert.AreEqual (DetailsViewMode.Insert, dv.DefaultMode, "DefaultModeInsert");
 468                         dv.DefaultMode = DetailsViewMode.ReadOnly;
 469                         Assert.AreEqual (DetailsViewMode.ReadOnly, dv.DefaultMode, "DefaultModeReadOnly");
 470                         dv.EditRowStyle.ForeColor = Color.Pink;
 471                         Assert.AreEqual (Color.Pink, dv.EditRowStyle.ForeColor, "EditRowStyle");
 472                         dv.EmptyDataRowStyle.HorizontalAlign = HorizontalAlign.Center;
 473                         Assert.AreEqual (HorizontalAlign.Center, dv.EmptyDataRowStyle.HorizontalAlign, "HorizontalAlignCenter");
 474                         dv.EmptyDataTemplate = new DTemplate ();
 475                         Assert.AreEqual (typeof (DTemplate), dv.EmptyDataTemplate.GetType() , "EmptyDataTemplate");
 476                         dv.EmptyDataText = "No Data";
 477                         Assert.AreEqual ("No Data", dv.EmptyDataText, "EmptyDataText");
 478                         dv.EnablePagingCallbacks = true;
 479                         Assert.AreEqual (true, dv.EnablePagingCallbacks, "EnablePagingCallbacks");
 480                         dv.FieldHeaderStyle.CssClass = "style.css";
 481                         Assert.AreEqual ("style.css", dv.FieldHeaderStyle.CssClass, "FieldHeaderStyle");
 482                         DataControlFieldCollection coll=new DataControlFieldCollection ();
 483                         dv.FooterStyle.HorizontalAlign = HorizontalAlign.Right ;
 484                         Assert.AreEqual (HorizontalAlign.Right, dv.FooterStyle.HorizontalAlign , "FooterStyle");
 485                         dv.FooterTemplate = new DTemplate ();
 486                         Assert.AreEqual (typeof(DTemplate ),dv.FooterTemplate.GetType() ,"FooterTemplate");
 487                         dv.FooterText = "Footer Text";
 488                         Assert.AreEqual ("Footer Text", dv.FooterText, "FooterText");
 489                         dv.GridLines = GridLines.Horizontal;
 490                         Assert.AreEqual (GridLines.Horizontal, dv.GridLines, "GridLinesHorizontal ");
 491                         dv.GridLines = GridLines.None;
 492                         Assert.AreEqual (GridLines.None , dv.GridLines, "GridLinesNone ");
 493                         dv.GridLines = GridLines.Vertical;
 494                         Assert.AreEqual (GridLines.Vertical, dv.GridLines, "GridLinesVertical ");
 495                         dv.GridLines = GridLines.Both;
 496                         Assert.AreEqual (GridLines.Both, dv.GridLines, "GridLinesBoth ");
 497                         dv.HeaderStyle.BorderColor = Color.PapayaWhip;
 498                         Assert.AreEqual (Color.PapayaWhip, dv.HeaderStyle.BorderColor, "HeaderStyle");
 499                         dv.HeaderTemplate = new DTemplate ();
 500                         Assert.AreEqual (typeof (DTemplate), dv.HeaderTemplate.GetType (), "HeaderTemplate");
 501                         dv.HeaderText = "Header Text";
 502                         Assert.AreEqual ("Header Text", dv.HeaderText, "HeaderText");
 503                         dv.HorizontalAlign = HorizontalAlign.Center;
 504                         Assert.AreEqual (HorizontalAlign.Center, dv.HorizontalAlign, "HorizontalAlignCenter");
 505                         dv.HorizontalAlign = HorizontalAlign.Justify;
 506                         Assert.AreEqual (HorizontalAlign.Justify , dv.HorizontalAlign, "HorizontalAlignJustify");
 507                         dv.HorizontalAlign = HorizontalAlign.Left ;
 508                         Assert.AreEqual (HorizontalAlign.Left , dv.HorizontalAlign, "HorizontalAlignLeft");
 509                         dv.HorizontalAlign = HorizontalAlign.NotSet ;
 510                         Assert.AreEqual (HorizontalAlign.NotSet , dv.HorizontalAlign, "HorizontalAlignNotSet");
 511                         dv.HorizontalAlign = HorizontalAlign.Right ;
 512                         Assert.AreEqual (HorizontalAlign.Right , dv.HorizontalAlign, "HorizontalAlignRight");
 513                         dv.InsertRowStyle.BackColor = Color.PeachPuff;
 514                         Assert.AreEqual (Color.PeachPuff, dv.InsertRowStyle.BackColor, "InsertRowStyle");
 515                         Assert.AreEqual (6, dv.PageCount, "PageCount");
 516                         Assert.AreEqual (0, dv.PageIndex, "PageIndex");
 517                         dv.PagerSettings.LastPageImageUrl = "image.jpg";
 518                         Assert.AreEqual ("image.jpg", dv.PagerSettings.LastPageImageUrl, "PagerSettings");
 519                         dv.PagerStyle.CssClass = "style.css";
 520                         Assert.AreEqual ("style.css", dv.PagerStyle.CssClass, "PagerStyle");
 521                         dv.PagerTemplate = new DTemplate ();
 522                         Assert.AreEqual (typeof (DTemplate), dv.PagerTemplate.GetType (), "PagerTemplate");
 523                         Assert.AreEqual (1, dv.Rows.Count, "Rows");
 524                         dv.RowStyle.BackColor  = Color.Plum  ;
 525                         Assert.AreEqual (Color.Plum, dv.RowStyle.BackColor, "RowStyle");
 526                         dv.FooterRow.CssClass="style.css";
 527                         Assert.AreEqual ("style.css", dv.FooterRow.CssClass , "FooterRow");
 528                         dv.HeaderRow.BackColor =Color.Pink ;
 529                         Assert.AreEqual (Color.Pink, dv.HeaderRow.BackColor, "HeaderRow");
 530
 531                 }
 532
 533                 [Test]
 534                 public void DetailsView_DefaultProtectedProperties ()
 535                 {
 536                         PokerDetailsView dv = new PokerDetailsView ();
 537                         Assert.AreEqual (HtmlTextWriterTag.Table, dv.PokerTagKey, "TagKey");
 538                 }
 539
 540                 [Test]
 541                 [Category ("NotWorking")]
 542                 public void DetailsView_AssignedPropertiesRender ()
 543                 {
 544                                                 string RenderedPageHtml = new WebTest ("DetailsViewProperties1.aspx").Run ();
 545                         string newHtmlValue = RenderedPageHtml.Substring (RenderedPageHtml.IndexOf ("starttest") + 9, RenderedPageHtml.IndexOf ("endtest") - RenderedPageHtml.IndexOf ("starttest") - 9);
 546                         string origHtmlValue = @" <div>
 547                         <div>
 548                         <table cellspacing=""20"" cellpadding=""30"" rules=""all"" border=""1"" id=""DetailsView1"" style=""height:50px;width:125px;background-image:url(Blue%20hills.jpg);"">
 549                         <caption align=""Bottom"">
 550                         Caption Test
 551                         </caption><tr>
 552                         <td>ID</td><td>1001</td>
 553                         </tr><tr>
 554                         <td>FName</td><td>Mahesh</td>
 555                         </tr><tr>
 556                         <td>LName</td><td>Chand</td>
 557                         </tr>
 558                         </table>
 559                         </div>
 560                          </div>";
 561                         HtmlDiff.AssertAreEqual (origHtmlValue, newHtmlValue, "RenderDetailsViewProperties1");
 562                         Assert.AreEqual (true,origHtmlValue.Contains (@"cellpadding=""30"""),"CellpaddingRender");
 563                         Assert.AreEqual (true, origHtmlValue.Contains (@"cellspacing=""20"""), "CellspacingRender");
 564                         Assert.AreEqual (true, origHtmlValue.Contains ("Caption Test"), "CaptionRender");
 565                         Assert.AreEqual (true, origHtmlValue.Contains (@"caption align=""Bottom"""), "CaptionalignRender");
 566                         Assert.AreEqual (true, origHtmlValue.Contains ("Blue%20hills.jpg"), "BackImageRender");
 567                         Assert.AreEqual (true, origHtmlValue.Contains ("Blue%20hills.jpg"), "BackImageRender");
 568                         //GridLines and HorizontalAlign were set but can not be shown in this rendering.
 569                 }
 570
 571
 572                 [Test]
 573                 [Category ("NunitWeb")]
 574                 [Category ("NotWorking")]
 575                 public void DetailsView_EmptyDataTextPropertyRender ()
 576                 {
 577                         PageDelegate pd = new PageDelegate (DetailsView_EmptyDataTextProperty);
 578                         WebTest t = new WebTest (PageInvoker.CreateOnLoad (pd));
 579                         string result = t.Run ();
 580                         FormRequest fr = new FormRequest (t.Response, "form1");
 581                         fr.Controls.Add ("__EVENTTARGET");
 582                         fr.Controls.Add ("__EVENTARGUMENT");
 583                         fr.Controls["__EVENTTARGET"].Value = "LinkButton1";
 584                         fr.Controls["__EVENTARGUMENT"].Value = "";
 585                         t.Request = fr;
 586                         //t.Invoker = PageInvoker.CreateOnLoad (pd);
 587                         result = t.Run ();
 588                         string newHtml = HtmlDiff.GetControlFromPageHtml (result);
 589                         string origHtml=@"<div>
 590                                         <table cellspacing=""0"" rules=""all"" border=""1"" style=""border-collapse:collapse;"">
 591                                         <tr>
 592                                         <td>Empty Data</td>
 593                                         </tr>
 594                                         </table>
 595                                         </div><a id=""LinkButton1"" href=""javascript:__doPostBack('LinkButton1','')"">Test</a>";
 596                         HtmlDiff.AssertAreEqual(origHtml, newHtml, "EmptyDataTextTest");
 597
 598
 599                 }
 600
 601                 public static void DetailsView_EmptyDataTextProperty (Page p)
 602                 {
 603                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
 604                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
 605
 606                         PokerDetailsView dv = new PokerDetailsView ();
 607                         dv.DataSource = new ArrayList ();
 608                         dv.EmptyDataText = "Empty Data";
 609                         LinkButton lb = new LinkButton ();
 610                         lb.ID = "LinkButton1";
 611                         lb.Text = "Test";
 612
 613                         p.Form.Controls.Add (lcb);
 614                         p.Form.Controls.Add (dv);
 615                         dv.DataBind ();
 616                         p.Form.Controls.Add (lb);
 617                         p.Form.Controls.Add (lce);
 618                 }
 619                 //ToDo: Add more properties rendering tests (PageSettings,AutoGeneratedRows etc...)
 620
 621
 622                 //Public Methods
 623
 624                 [Test]
 625                 public void DetailsView_ChangeMode ()
 626                 {
 627                         PokerDetailsView dv = new PokerDetailsView ();
 628                         Assert.AreEqual (DetailsViewMode.ReadOnly, dv.CurrentMode, "ChangeModeDefault");
 629                         dv.ChangeMode (DetailsViewMode.Insert);
 630                         Assert.AreEqual (DetailsViewMode.Insert, dv.CurrentMode, "ChangeModeInsert");
 631                         dv.ChangeMode (DetailsViewMode.Edit);
 632                         Assert.AreEqual (DetailsViewMode.Edit, dv.CurrentMode, "ChangeModeEdit");
 633                         dv.ChangeMode (DetailsViewMode.ReadOnly);
 634                         Assert.AreEqual (DetailsViewMode.ReadOnly, dv.CurrentMode, "ChangeModeReadOnly");
 635                 }
 636
 637                 [Test]
 638                 [Category ("NotWorking")]
 639                 public void FormView_DataBind ()
 640                 {
 641                         PokerDetailsView dv = new PokerDetailsView ();
 642                         dv.AllowPaging = true;
 643                         dv.DataSource = myds;
 644                         Assert.AreEqual (0, dv.PageCount, "BeforeDataBind1");
 645                         Assert.AreEqual (null, dv.DataItem, "BeforeDataBind2");
 646                         dv.DataBind ();
 647                         Assert.AreEqual (6, dv.PageCount, "AfterDataBind1");
 648                         Assert.AreEqual (6, dv.DataItemCount, "AfterDataBind2");
 649                         Assert.AreEqual ("Item1", dv.DataItem, "AfterDataBind3");
 650                 }
 651
 652                 [Test]
 653                 [Category ("NotWorking")]
 654                 public void FormView_IsBindableType ()
 655                 {
 656                         bool isBindable = false;
 657                         PokerDetailsView dv = new PokerDetailsView ();
 658                         isBindable = dv.IsBindableType (typeof (Decimal));
 659                         Assert.AreEqual (true, isBindable, "IsBindableTypeDecimal");
 660                         isBindable = dv.IsBindableType (typeof (Int32));
 661                         Assert.AreEqual (true, isBindable, "IsBindableTypeInt32");
 662                         isBindable = dv.IsBindableType (typeof (String));
 663                         Assert.AreEqual (true, isBindable, "IsBindableTypeString");
 664                         isBindable = dv.IsBindableType (typeof (Boolean));
 665                         Assert.AreEqual (true, isBindable, "IsBindableTypeBoolean");
 666                         isBindable = dv.IsBindableType (typeof (DateTime));
 667                         Assert.AreEqual (true, isBindable, "IsBindableTypeDateTime");
 668                         isBindable = dv.IsBindableType (typeof (Byte));
 669                         Assert.AreEqual (true, isBindable, "IsBindableTypeByte");
 670                         isBindable = dv.IsBindableType (typeof (Guid));
 671                         Assert.AreEqual (true, isBindable, "IsBindableTypeGuid");
 672                         isBindable = dv.IsBindableType (typeof (DTemplate));
 673                         Assert.AreEqual (false, isBindable, "IsBindableTypeMyTemplate");
 674                 }
 675
 676
 677                 private bool isDeleted = false;
 678
 679                 [Test]
 680                 [Category ("NotWorking")]
 681                 public void DetailsView_DeleteItemHandler ()
 682                 {
 683                         PokerDetailsView dv = new PokerDetailsView ();
 684                         dv.DataSource = myds;
 685                         dv.DataBind ();
 686                         Assert.AreEqual (false, isDeleted, "BeforeDeleteItem");
 687                         dv.ItemDeleting += new DetailsViewDeleteEventHandler (dv_DeleteingHandler);
 688                         dv.DeleteItem ();
 689                         Assert.AreEqual (true, isDeleted, "BeforeDeleteItem");
 690
 691                 }
 692
 693                 public void dv_DeleteingHandler (Object sender, DetailsViewDeleteEventArgs e)
 694                 {
 695                         isDeleted = true;
 696                 }
 697
 698                 [Test]
 699                 [Category ("NunitWeb")]
 700                 [Category ("NotWorking")]
 701                 public void DetailsView_DeleteItemTest ()
 702                 {
 703                         string html = new WebTest (PageInvoker.CreateOnLoad (
 704                                 new PageDelegate (DetailsView_DeleteItem))).Run ();
 705                         string newHtml = HtmlDiff.GetControlFromPageHtml (html);
 706                         string origHtml = @"<div>
 707                                         <table cellspacing=""0"" rules=""all"" border=""1"" style=""border-collapse:collapse;"">
 708                                         <tr>
 709                                         <td>ID</td><td>1002</td>
 710                                         </tr><tr>
 711                                         <td>FName</td><td>Melanie</td>
 712                                         </tr><tr>
 713                                         <td>LName</td><td>Talmadge</td>
 714                                         </tr><tr>
 715                                         <td colspan=""2""><table border=""0"">
 716                                         <tr>
 717                                         <td><span>1</span></td><td><a href=""javascript:__doPostBack('ctl01','Page$2')"">2</a></td>
 718                                         </tr>
 719                                         </table></td>
 720                                         </tr>
 721                                         </table>
 722                                         </div>";
 723                         HtmlDiff.AssertAreEqual (origHtml, newHtml, "DeleteItemMethod");
 724                 }
 725
 726                 public static void DetailsView_DeleteItem (Page p)
 727                 {
 728                         LiteralControl lcb = new LiteralControl (HtmlDiff.BEGIN_TAG);
 729                         LiteralControl lce = new LiteralControl (HtmlDiff.END_TAG);
 730                         PokerDetailsView dv = new PokerDetailsView ();
 731                         ObjectDataSource ds = new ObjectDataSource ();
 732                         ds.ID = "ObjectDataSource1";
 733                         ds.TypeName = "MonoTests.System.Web.UI.WebControls.TableObject";
 734                         ds.SelectMethod = "GetMyData";
 735                         ds.DeleteMethod = "Delete";
 736                         ds.InsertMethod = "Insert";
 737                         ds.UpdateMethod = "Update";
 738                         Parameter p1 = new Parameter ("ID", TypeCode.String);
 739                         Parameter p2 = new Parameter ("FName", TypeCode.String);
 740                         Parameter p3 = new Parameter ("LName", TypeCode.String);
 741                         ds.DeleteParameters.Add (p1);
 742                         ds.DeleteParameters.Add (p2);
 743                         ds.DeleteParameters.Add (p3);
 744                         dv.Page = p;
 745                         ds.Page = p;
 746                         p.Form.Controls.Add (lcb);
 747                         p.Form.Controls.Add (dv);
 748                         p.Form.Controls.Add (ds);
 749                         p.Form.Controls.Add (lce);
 750                         dv.AllowPaging = true;
 751                         dv.DataKeyNames = new string[] { "ID", "FName", "LName" };
 752                         dv.DataSourceID = "ObjectDataSource1";
 753                         dv.DataBind ();
 754                         dv.DeleteItem ();
 755                 }
 756
 757                 //ToDo: InsertItem method should be checked using postback
 758                 private bool insertItem = false;
 759                 [Test]
 760                 [Category ("NotWorking")]
 761                 public void DetailsView_InsertItem ()
 762                 {
 763                         PokerDetailsView dv = new PokerDetailsView ();
 764                         dv.Page = new Page ();
 765                         dv.ChangeMode (DetailsViewMode.Insert);
 766                         dv.ItemInserting += new DetailsViewInsertEventHandler (insert_item);
 767                         Assert.AreEqual (false, insertItem, "BeforeInsertItem");
 768                         dv.InsertItem (true);
 769                         Assert.AreEqual (true, insertItem, "AfterInsertItem");
 770
 771                 }
 772
 773                 public void insert_item (object sender, DetailsViewInsertEventArgs e)
 774                 {
 775                         insertItem = true;
 776                 }
 777
 778                 //ToDo: UpdateItem method should be checked using postback
 779                 private bool updateItem = false;
 780                 [Test]
 781                 [Category ("NotWorking")]
 782                 public void DetailsView_UpdateItem ()
 783                 {
 784                         PokerDetailsView dv = new PokerDetailsView ();
 785                         dv.ChangeMode (DetailsViewMode.Edit);
 786                         dv.Page = new Page ();
 787                         dv.ItemUpdating += new DetailsViewUpdateEventHandler (update_item);
 788                         Assert.AreEqual (false, updateItem, "BeforeUpdateItem");
 789                         dv.UpdateItem (true);
 790                         Assert.AreEqual (true, updateItem, "AfterUpdateItem");
 791
 792                 }
 793
 794                 public void update_item (object sender, DetailsViewUpdateEventArgs e)
 795                 {
 796                         updateItem = true;
 797                 }
 798
 799                 //protected methods
 800
 801                 [Test]
 802                 [Category ("NotWorking")]
 803                 public void DetailsView_CreateAutoGeneratedRows ()
 804                 {
 805                         PokerDetailsView dv = new PokerDetailsView ();
 806                         DataTable ds = TableObject.CreateDataTable ();
 807                         dv.DataSource = ds;
 808                         dv.DataBind ();
 809                         ICollection col = dv.DoCreateAutoGeneratedRows (dv.DataItem);
 810                         Assert.AreEqual (typeof(ArrayList),col.GetType (),"CreateAutoGeneratedRowsType");
 811                         Assert.AreEqual (3, col.Count , "CreateAutoGeneratedRowsCount");
 812                         Assert.AreEqual (typeof (AutoGeneratedField), ((ArrayList) col)[0].GetType (), "AutoGeneratedRowType");
 813                         Assert.AreEqual ("ID", ((ArrayList) col)[0].ToString (), "AutoGeneratedRowName1");
 814                         Assert.AreEqual ("FName", ((AutoGeneratedField)((ArrayList) col)[1]).HeaderText, "AutoGeneratedRowName2");
 815                         Assert.AreEqual ("LName", ((AutoGeneratedField) ((ArrayList) col)[2]).SortExpression , "AutoGeneratedRowName3");
 816
 817                 }
 818
 819                 [Test]
 820                 [Category ("NotWorking")]
 821                 public void DetailsView_CreateAutoGenerateRow ()
 822                 {
 823                         PokerDetailsView dv = new PokerDetailsView ();
 824                         AutoGeneratedFieldProperties prop = new AutoGeneratedFieldProperties ();
 825                         prop.Name = "FieldItem";
 826                         prop.Type = typeof(String);
 827                         AutoGeneratedField field = dv.DoCreateAutoGeneratedRow (prop);
 828                         Assert.AreEqual (typeof (string), field.DataType, "FieldDataType");
 829                         Assert.AreEqual ("FieldItem", field.HeaderText, "FieldHeaderText");
 830                         Assert.AreEqual ("FieldItem",field.SortExpression ,"FieldSortExpretion");
 831                         Assert.AreEqual (typeof(AutoGeneratedField), field.GetType (), "AutoGeneratedFieldType");
 832
 833                 }
 834
 835                 [Test]
 836                 [Category ("NotWorking")]
 837                 public void DetailsView_CreateChildControls ()
 838                 {
 839                         PokerDetailsView dv = new PokerDetailsView ();
 840                         Assert.AreEqual (6,dv.DoCreateChildControls (myds, true),"CreateChildControls1");
 841                         Assert.AreEqual (6, dv.DoCreateChildControls (myds, false), "CreateChildControls2");
 842                 }
 843
 844                 [Test]
 845                 [Category ("NotWorking")]
 846                 public void DetailsView_CreateControlStyle ()
 847                 {
 848                         PokerDetailsView dv = new PokerDetailsView ();
 849                         Style style = dv.DoCreateControlStyle ();
 850                         Assert.AreEqual (0, ((TableStyle) style).CellSpacing, "CreateControlStyle1");
 851                         Assert.AreEqual (GridLines.Both, ((TableStyle) style).GridLines, "CreateControlStyle2");
 852
 853                 }
 854
 855                 [Test]
 856                 [Category ("NotWorking")]
 857                 public void DetailsView_CreateRow ()
 858                 {
 859                         PokerDetailsView dv = new PokerDetailsView ();
 860                         DetailsViewRow row = dv.DoCreateRow (1, DataControlRowType.DataRow, DataControlRowState.Alternate);
 861                         Assert.AreEqual (1, row.RowIndex, "rowIndex1");
 862                         Assert.AreEqual (DataControlRowType.DataRow, row.RowType, "RowType1");
 863                         Assert.AreEqual (DataControlRowState.Alternate, row.RowState, "RowState1");
 864                         row = dv.DoCreateRow (2, DataControlRowType.Header, DataControlRowState.Insert);
 865                         Assert.AreEqual (2, row.RowIndex, "rowIndex2");
 866                         Assert.AreEqual (DataControlRowType.Header , row.RowType, "RowType2");
 867                         Assert.AreEqual (DataControlRowState.Insert , row.RowState, "RowState2");
 868                         row = dv.DoCreateRow (3, DataControlRowType.EmptyDataRow , DataControlRowState.Selected );
 869                         Assert.AreEqual (3, row.RowIndex, "rowIndex3");
 870                         Assert.AreEqual (DataControlRowType.EmptyDataRow , row.RowType, "RowType3");
 871                         Assert.AreEqual (DataControlRowState.Selected , row.RowState, "RowState3");
 872                         DetailsViewPagerRow pagerRow = (DetailsViewPagerRow )dv.DoCreateRow (5, DataControlRowType.Pager , DataControlRowState.Edit );
 873                         Assert.AreEqual (5, pagerRow.RowIndex, "rowIndex4");
 874                         Assert.AreEqual (DataControlRowType.Pager, pagerRow.RowType, "RowType4");
 875                         Assert.AreEqual (DataControlRowState.Edit, pagerRow.RowState, "RowState4");
 876
 877
 878                 }
 879
 880                 [Test]
 881                 [Category ("NotWorking")]
 882                 public void DetailsView_CreateTable ()
 883                 {
 884                         PokerDetailsView dv = new PokerDetailsView ();
 885                         Table tb = dv.DoCreateTable();
 886                         Assert.AreEqual (null, tb.Parent, "CreateTable1");
 887                         Assert.AreEqual ("", tb.BackImageUrl, "CreateTable2");
 888                         Assert.AreEqual (0, tb.Rows.Count, "CreateTable3");
 889                         Assert.AreEqual (null, tb.ClientID , "CreateTable3");
 890                         dv.ID = "testId"; //private filed _parentID should be set to "testId"
 891                         tb = dv.DoCreateTable ();
 892                         Assert.AreEqual (-1, tb.CellSpacing, "CreateTable4");
 893                         Assert.AreEqual (HorizontalAlign.NotSet , tb.HorizontalAlign , "CreateTable5");
 894                 }
 895
 896                 [Test]
 897                 [Category ("NotWorking")]
 898                 public void DetailsView_EnsureDataBound ()
 899                 {
 900                         ObjectDataSource ds = new ObjectDataSource ();
 901                         ds.ID = "ObjectDataSource1";
 902                         ds.TypeName = "System.Guid";
 903                         ds.SelectMethod = "ToByteArray";
 904                         Page p = new Page ();
 905                         PokerDetailsView dv = new PokerDetailsView ();
 906                         dv.Page = p;
 907                         ds.Page = p;
 908                         p.Controls.Add (dv);
 909                         p.Controls.Add (ds);
 910                         dv.DataSourceID = "ObjectDataSource1";
 911                         Assert.AreEqual (false, dv.ensureDataBound, "BeforeEnsureDataBound");
 912                         dv.DoConfirmInitState ();
 913                         dv.DoOnPreRender (EventArgs.Empty);
 914                         Assert.AreEqual (true, dv.ensureDataBound, "AfterEnsureDataBound");
 915                 }
 916
 917                 [Test]
 918                 [Category ("NotWorking")]
 919                 public void DetailsView_EnsureChildControls ()
 920                 {
 921                         PokerDetailsView dv = new PokerDetailsView ();
 922                         int i = dv.Rows.Count;
 923                         Assert.IsTrue (dv.ensureCreateChildControls);
 924                         Assert.IsFalse (dv.ensureDataBound);
 925                         Assert.IsFalse (dv.createChildControls1);
 926                         Assert.IsFalse (dv.createChildControls2);
 927                 }
 928
 929                 [Test]
 930                 [Category ("NotWorking")]
 931                 public void DetailsView_ExtractRowValues ()
 932                 {
 933                         PokerDetailsView dv = new PokerDetailsView ();
 934                         DataTable ds = TableObject.CreateDataTable ();
 935                         dv.DataSource = ds;
 936                         dv.DataBind ();
 937                         OrderedDictionary fieldsValues = new OrderedDictionary ();
 938                         dv.DoExtractRowValues (fieldsValues, true, true);
 939                         Assert.AreEqual (3, fieldsValues.Count, "ExtractRowValues1");
 940                         Assert.AreEqual (3, fieldsValues.Keys.Count, "ExtractRowValues2");
 941                         Assert.AreEqual (3, fieldsValues.Values.Count, "ExtractRowValues3");
 942                         Assert.AreEqual (true, fieldsValues.Contains ("ID"), "ExtractRowValues4");
 943                         IDictionaryEnumerator enumerator=fieldsValues.GetEnumerator ();
 944                         enumerator.MoveNext ();
 945                         Assert.AreEqual ("ID",enumerator.Key,"FieldValue1");
 946                         Assert.AreEqual ("1001", enumerator.Value , "FieldValue2");
 947                         enumerator.MoveNext ();
 948                         Assert.AreEqual ("FName", enumerator.Key, "FieldValue3");
 949                         Assert.AreEqual ("Mahesh", enumerator.Value, "FieldValue4");
 950                         enumerator.MoveNext ();
 951                         Assert.AreEqual ("LName", enumerator.Key, "FieldValue5");
 952                         Assert.AreEqual ("Chand", enumerator.Value, "FieldValue6");
 953                         fieldsValues = new OrderedDictionary ();
 954                         dv.DoExtractRowValues (fieldsValues, false, false);
 955                         Assert.AreEqual (0, fieldsValues.Count, "ExtractRowValues-NotReadOnly1");
 956                         fieldsValues = new OrderedDictionary ();
 957                         dv.DoExtractRowValues (fieldsValues, true, false);
 958                         Assert.AreEqual (3, fieldsValues.Count, "ExtractRowValues-NoPrimaryKeys1");
 959                         Assert.AreEqual (3, fieldsValues.Keys.Count, "ExtractRowValues-NoPrimaryKeys2");
 960                         fieldsValues = new OrderedDictionary ();
 961                         dv.DoExtractRowValues (fieldsValues, false, true);
 962                         Assert.AreEqual (0, fieldsValues.Count, "ExtractRowValues-NotReadOnly2");
 963                         Assert.AreEqual (0, fieldsValues.Keys.Count, "ExtractRowValues-NotReadOnly3");
 964                 }
 965
 966                 [Test]
 967                 [Category ("NotWorking")]
 968                 public void DetailsView_CreateFieldSet_dont_useDataSource ()
 969                 {
 970                         DataTable ds = TableObject.CreateDataTable ();
 971                         PokerDetailsView dv1 = new PokerDetailsView ();
 972                         dv1.DataSource = ds;
 973                         dv1.DataBind ();
 974                         ICollection fieldSet1 = dv1.DoCreateFieldSet ("FieldTest", true);
 975                         Assert.AreEqual (1, fieldSet1.Count, "FiledSetCount");
 976                         AutoGeneratedField agf = (AutoGeneratedField) ((ArrayList) fieldSet1)[0];
 977                         Assert.AreEqual ("Item", agf.HeaderText, "FieldSetCount");
 978                 }
 979
 980                 [Test]
 981                 public  void DetailsView_CreateFieldSet_useDataSource ()
 982                 {
 983                         DataTable ds = TableObject.CreateDataTable ();
 984                         PokerDetailsView dv2 = new PokerDetailsView ();
 985                         dv2.DataSource = ds;
 986                         dv2.DataBind ();
 987                         ICollection fieldSet2 = dv2.DoCreateFieldSet ("FieldTest", false);
 988                         Assert.AreEqual (3, fieldSet2.Count, "FiledSetCount");
 989                         Assert.AreEqual ("ID", ((ArrayList) fieldSet2)[0].ToString (), "FieldValue1");
 990                         Assert.AreEqual (typeof (Int32), ((AutoGeneratedField) ((ArrayList) fieldSet2)[0]).DataType, "FieldType1");
 991                         Assert.AreEqual ("FName", ((ArrayList) fieldSet2)[1].ToString (), "FieldValue2");
 992                         Assert.AreEqual (typeof (String), ((AutoGeneratedField) ((ArrayList) fieldSet2)[1]).DataType, "FieldType2");
 993                         Assert.AreEqual ("LName", ((ArrayList) fieldSet2)[2].ToString (), "FieldValue3");
 994                         Assert.AreEqual (typeof (String), ((AutoGeneratedField) ((ArrayList) fieldSet2)[2]).DataType, "FieldType3");
 995
 996
 997                 }
 998
 999                 [Test]
1000                 [Category ("NotWorking")]
1001                 public void DetailsView_GetCallBackResult ()
1002                 {
1003                         PokerDetailsView dv = new PokerDetailsView ();
1004                         Page p = new Page ();
1005                         p.Controls.Add (dv);
1006                         DataTable ds = TableObject.CreateDataTable ();
1007                         dv.DataSource = ds;
1008                         dv.DataBind ();
1009                         dv.DoRaiseCallbackEvent ("a|b$c");
1010                         string callbackResult=@"<table cellspacing=""0"" rules=""all"" border=""1"" style=""border-collapse:collapse;"">
1011                                                 <tr>
1012                                                 <td>ID</td><td>1001</td>
1013                                                 </tr><tr>
1014                                                 <td>FName</td><td>Mahesh</td>
1015                                                 </tr><tr>
1016                                                 <td>LName</td><td>Chand</td>
1017                                                 </tr>
1018                                                 </table>";
1019                         string cbres = dv.DoGetCallbackResult ();
1020                         Assert.IsNotNull (cbres);
1021                         HtmlDiff.AssertAreEqual (callbackResult, cbres.Substring(dv.DoGetCallbackResult().IndexOf ("<table")), "GetCallbackResult");
1022
1023                 }
1024
1025                 [Test]
1026                 public void DetailsView_GetCallbackScript ()
1027                 {
1028                         //Not implemented
1029                 }
1030
1031                 [Test]
1032                 [Category ("NotWorking")]
1033                 public void DetailsView_InitializePager ()
1034                 {
1035                         PokerDetailsView dv = new PokerDetailsView ();
1036                         Page page = new Page ();
1037                         dv.AllowPaging = true;
1038                         dv.DataSource = myds;
1039                         page.Controls.Add (dv);
1040                         Assert.AreEqual (0, dv.PageCount, "BeforeInitializePagerPageCount");
1041                         Assert.AreEqual (false, dv.isInitializePager, "BeforeInitializePager");
1042                         dv.DataBind ();
1043                         Assert.AreEqual (true, dv.isInitializePager, "AfterInitializePager");
1044                         Assert.AreEqual (6, dv.PageCount, "AfterInitializePagerPageCount");
1045                 }
1046
1047                 [Test]
1048                 public void DetailsView_InitializeRow ()
1049                 {
1050                         //Not implemented
1051                 }
1052
1053                 [Test]
1054                 [Category ("NotWorking")]
1055                 public void DetailsView_PerformDataBinding ()
1056                 {
1057                         PokerDetailsView dv = new PokerDetailsView ();
1058                         Assert.AreEqual (0, dv.DataItemCount, "BeforePerformDataBinding");
1059                         dv.DoPerformDataBinding (myds);
1060                         Assert.AreEqual (6, dv.DataItemCount, "AfterPerformDataBinding");
1061                 }
1062
1063                 [Test]
1064                 [Category ("NotWorking")]
1065                 public void DetailsView_PrepareControlHierarchy ()
1066                 {
1067                         PokerDetailsView dv = new PokerDetailsView ();
1068                         //dv.Render ();
1069                         //Assert.AreEqual (0, dv.Controls.Count, "ControlHierarchy1");
1070                         //Assert.AreEqual (true, dv.controlHierarchy, "ControlHierarchy2");
1071                         dv.controlHierarchy = false;
1072                         dv.AllowPaging = true;
1073                         dv.DataSource = myds;
1074                         dv.DataBind ();
1075                         dv.Page = new Page ();
1076                         dv.Render ();
1077                         Assert.AreEqual (1, dv.Controls.Count, "ControlHierarchy3");
1078                         Assert.AreEqual (true, dv.controlHierarchy, "ControlHierarchy4");
1079                         Button bt = new Button ();
1080                         dv.Controls.Add (bt);
1081                         dv.controlHierarchy = false;
1082                         dv.Render ();
1083                         Assert.AreEqual (2, dv.Controls.Count, "ControlHierarchy3");
1084                         Assert.AreEqual (true, dv.controlHierarchy, "ControlHierarchy4");
1085                 }
1086
1087                 //Render Methods
1088                 [Test]
1089                 [Category ("NotWorking")]
1090                 public void DetailsView_FooterTemplateRender ()
1091                 {
1092                         //Footer Template property is checked.
1093                         string RenderedPageHtml = new WebTest ("FooterTemplateTest.aspx").Run ();
1094                         string newHtmlValue = RenderedPageHtml.Substring (RenderedPageHtml.IndexOf ("starttest")+9, RenderedPageHtml.IndexOf ("endtest") - RenderedPageHtml.IndexOf ("starttest")-9);
1095                         string origHtmlValue = @" <div>
1096                                                   <div>
1097                                                 <table cellspacing=""0"" rules=""all"" border=""1"" id=""DetailsView1"" style=""height:50px;width:125px;border-collapse:collapse;"">
1098                                                 <tr>
1099                                                 <td>ID</td><td>1001</td>
1100                                                 </tr><tr>
1101                                                 <td>FName</td><td>Mahesh</td>
1102                                                 </tr><tr>
1103                                                 <td>LName</td><td>Chand</td>
1104                                                 </tr><tr>
1105                                                 <td colspan=""2"">
1106                                                  Footer Template Test<a id=""DetailsView1_HyperLink1"">Footer</a>
1107                                                  </td>
1108                                                 </tr><tr>
1109                                                 <td colspan=""2""><table border=""0"">
1110                                                 <tr>
1111                                                 <td><span>1</span></td><td><a href=""javascript:__doPostBack('DetailsView1','Page$2')"">2</a></td><td><a href=""javascript:__doPostBack('DetailsView1','Page$3')"">3</a></td>
1112                                                 </tr>
1113                                                 </table></td>
1114                                                 </tr>
1115                                                 </table>
1116                                                 </div>
1117                                                  </div>";
1118
1119
1120                        HtmlDiff.AssertAreEqual (origHtmlValue, newHtmlValue, "RenderFooterTemplate");
1121                 }
1122
1123                 [Test]
1124                 [Category ("NotWorking")]
1125                 public void DetailsView_RenderHeaderTemplate ()
1126                 {
1127                         //Header Template property is checked
1128                         string RenderedPageHtml = new WebTest ("DetailsViewTemplates.aspx").Run ();
1129                         string newHtmlValue = RenderedPageHtml.Substring (RenderedPageHtml.IndexOf ("test1") + 5, RenderedPageHtml.IndexOf ("test2") - RenderedPageHtml.IndexOf ("test1") - 5);
1130                         string origHtmlValue = @" <div>
1131                                                  <div>
1132                                                 <table cellspacing=""0"" rules=""all"" border=""1"" id=""DetailsView1"" style=""height:50px;width:125px;border-collapse:collapse;"">
1133                                                 <tr>
1134                                                 <td colspan=""2"">
1135                                                 Header Template<input type=""submit"" name=""DetailsView1$Button1"" value=""Header button"" id=""DetailsView1_Button1"" />
1136                                                  </td>
1137                                                 </tr><tr>
1138                                                 <td>ID</td><td>1001</td>
1139                                                 </tr><tr>
1140                                                 <td>FName</td><td>Mahesh</td>
1141                                                 </tr><tr>
1142                                                 <td>LName</td><td>Chand</td>
1143                                                 </tr><tr>
1144                                                 <td colspan=""2""><a href=""javascript:__doPostBack('DetailsView1','Delete$0')"">Delete</a></td>
1145                                                         </tr><tr>
1146                                                 <td colspan=""2""><table border=""0"">
1147                                                 <tr>
1148                                                 <td><span>1</span></td><td><a href=""javascript:__doPostBack('DetailsView1','Page$2')"">2</a></td><td><a href=""javascript:__doPostBack('DetailsView1','Page$3')"">3</a></td>
1149                                                 </tr>
1150                                                 </table></td>
1151                                                 </tr>
1152                                                 </table>
1153                                                 </div>";
1154
1155
1156                 HtmlDiff.AssertAreEqual (origHtmlValue, newHtmlValue, "RenderHeaderTemplate");
1157                 }
1158
1159                 [Test]
1160                 [Category ("NotWorking")]
1161                 public void DetailsView_PagerTemplateRender ()
1162                 {
1163                         //Pager Template property is checked
1164                         string RenderedPageHtml = new WebTest ("DetailsViewTemplates.aspx").Run ();
1165                         string newHtmlValue = RenderedPageHtml.Substring (RenderedPageHtml.IndexOf ("test2") + 5, RenderedPageHtml.IndexOf ("test3") - RenderedPageHtml.IndexOf ("test2") - 5);
1166                         string origHtmlValue = @" <div>
1167                                                 <table cellspacing=""0"" rules=""all"" border=""1"" id=""DetailsView2"" style=""height:50px;width:125px;border-collapse:collapse;"">
1168                                                 <tr>
1169                                                 <td>ID</td><td>1001</td>
1170                                                 </tr><tr>
1171                                                 <td>FName</td><td>Mahesh</td>
1172                                                 </tr><tr>
1173                                                 <td>LName</td><td>Chand</td>
1174                                                 </tr><tr>
1175                                                 <td colspan=""2"">
1176                                                  <input type=""submit"" name=""DetailsView2$ctl01$Button2"" value=""Prev"" id=""DetailsView2_ctl01_Button2"" />
1177                                                   <input type=""submit"" name=""DetailsView2$ctl01$Button3"" value=""Next"" id=""DetailsView2_ctl01_Button3"" />
1178                                                 </td>
1179                                                 </tr>
1180                                                 </table>
1181                                                 </div>";
1182
1183                         HtmlDiff.AssertAreEqual (origHtmlValue, newHtmlValue, "RenderPagerTemplate");
1184                 }
1185
1186                 [Test]
1187                 [Category ("NotWorking")]
1188                 public void DetailsView_EditFieldsRender ()
1189                 {
1190                         string RenderedPageHtml = new WebTest ("DetailsViewTemplates.aspx").Run ();
1191                         string newHtmlValue = RenderedPageHtml.Substring (RenderedPageHtml.IndexOf ("test3") + 5, RenderedPageHtml.IndexOf ("endtest") - RenderedPageHtml.IndexOf ("test3") - 5);
1192                         string origHtmlValue = @" </div>
1193                                                         <div>
1194                                                 <table cellspacing=""0"" rules=""all"" border=""1"" id=""DetailsView3"" style=""height:50px;width:125px;border-collapse:collapse;"">
1195                                                 <tr>
1196                                                 <td>ID</td><td>1001</td>
1197                                                 </tr><tr>
1198                                                 <td>FName</td><td>Mahesh</td>
1199                                                 </tr><tr>
1200                                                 <td>LName</td><td>Chand</td>
1201                                                 </tr><tr>
1202                                                 <td colspan=""2""><a href=""javascript:__doPostBack('DetailsView3','$0')"">TestButtonField</a></td>
1203                                                 </tr><tr>
1204                                                 <td>&nbsp;</td><td><a></a></td>
1205                                                 </tr><tr>
1206                                                 <td>Image field</td><td></td>
1207                                                 </tr><tr>
1208                                                 <td>&nbsp;</td><td></td>
1209                                                 </tr><tr>
1210                                                 <td>Template Field</td><td style=""background-color:#FFE0C0;"">&nbsp;</td>
1211                                                 </tr><tr>
1212                                                 <td colspan=""2""><table border=""0"">
1213                                                 <tr>
1214                                                 <td><span>1</span></td><td><a href=""javascript:__doPostBack('DetailsView3','Page$2')"">2</a></td><td><a href=""javascript:__doPostBack('DetailsView3','Page$3')"">3</a></td>
1215                                                 </tr>
1216                                                 </table></td>
1217                                                 </tr>
1218                                                 </table>
1219                                                 </div>";
1220
1221
1222                         HtmlDiff.AssertAreEqual (origHtmlValue, newHtmlValue, "RenderDataFields");
1223                 }
1224
1225                 [Test]
1226                 [Category ("NunitWeb")]
1227                 [Category ("NotWorking")]
1228                 public void DetailsView_PagingPostback ()
1229                 {
1230                         WebTest t = new WebTest ("DetailsViewDataActions.aspx");
1231                         string pageHTML = t.Run ();
1232                         pageHTML = pageHTML.Substring (pageHTML.IndexOf ("starttest") + 9, pageHTML.IndexOf ("endtest") - pageHTML.IndexOf ("starttest") - 9);
1233                         string origHtmlValue = @" <div>
1234                                                  &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;
1235                                                  <div>
1236                                                 <table cellspacing=""0"" rules=""all"" border=""1"" id=""DetailsView1"" style=""height:50px;width:125px;border-collapse:collapse;"">
1237                                                 <tr>
1238                                                 <td>ID</td><td>1001</td>
1239                                                 </tr><tr>
1240                                                 <td>FName</td><td>Mahesh</td>
1241                                                 </tr><tr>
1242                                                 <td>LName</td><td>Chand</td>
1243                                                 </tr><tr>
1244                                                 <td colspan=""2""><a href=""javascript:__doPostBack('DetailsView1','Edit$0')"">Edit</a>&nbsp;<a href=""javascript:__doPostBack('DetailsView1','Delete$0')"">Delete</a>&nbsp;<a href=""javascript:__doPostBack('DetailsView1','New$0')"">New</a></td>
1245                                                 </tr><tr>
1246                                                 <td colspan=""2""><table border=""0"">
1247                                                 <tr>
1248                                                 <td><span>1</span></td><td><a href=""javascript:__doPostBack('DetailsView1','Page$2')"">2</a></td><td><a href=""javascript:__doPostBack('DetailsView1','Page$3')"">3</a></td>
1249                                                 </tr>
1250                                                 </table></td>
1251                                                 </tr>
1252                                                 </table>
1253                                                 </div>
1254                                                   </div>";
1255                         HtmlDiff.AssertAreEqual (origHtmlValue, pageHTML, "BeforePagingDataPostback");
1256                         FormRequest fr = new FormRequest (t.Response, "form1");
1257                         fr.Controls.Add ("__EVENTTARGET");
1258                         fr.Controls.Add ("__EVENTARGUMENT");
1259                         fr.Controls["__EVENTTARGET"].Value = "DetailsView1";
1260                         fr.Controls["__EVENTARGUMENT"].Value = "Page$2";
1261                         t.Request = fr;
1262                         pageHTML = t.Run ();
1263                         pageHTML = pageHTML.Substring (pageHTML.IndexOf ("starttest") + 9, pageHTML.IndexOf ("endtest") - pageHTML.IndexOf ("starttest") - 9);
1264                         origHtmlValue = @" <div>
1265                                         &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;
1266                                         <div>
1267                                         <table cellspacing=""0"" rules=""all"" border=""1"" id=""DetailsView1"" style=""height:50px;width:125px;border-collapse:collapse;"">
1268                                         <tr>
1269                                         <td>ID</td><td>1002</td>
1270                                         </tr><tr>
1271                                         <td>FName</td><td>Melanie</td>
1272                                         </tr><tr>
1273                                         <td>LName</td><td>Talmadge</td>
1274                                         </tr><tr>
1275                                         <td colspan=""2""><a href=""javascript:__doPostBack('DetailsView1','Edit$1')"">Edit</a>&nbsp;<a href=""javascript:__doPostBack('DetailsView1','Delete$1')"">Delete</a>&nbsp;<a href=""javascript:__doPostBack('DetailsView1','New$1')"">New</a></td>
1276                                         </tr><tr>
1277                                         <td colspan=""2""><table border=""0"">
1278                                         <tr>
1279                                         <td><a href=""javascript:__doPostBack('DetailsView1','Page$1')"">1</a></td><td><span>2</span></td><td><a href=""javascript:__doPostBack('DetailsView1','Page$3')"">3</a></td>
1280                                         </tr>
1281                                         </table></td>
1282                                         </tr>
1283                                         </table>
1284                                         </div>
1285                                         </div>";
1286                         HtmlDiff.AssertAreEqual (origHtmlValue, pageHTML, "AfterPagingDataPostback");
1287
1288                 }
1289
1290                 [Test]
1291                 [Category ("NunitWeb")]
1292                 [Category ("NotWorking")]
1293                 public void DetailsView_EditPostback ()
1294                 {
1295                         WebTest t = new WebTest ("DetailsViewDataActions.aspx");
1296                         string pageHTML = t.Run ();
1297                         Assert.AreEqual (true, pageHTML.Contains ("Edit"), "BeforeEditPostback");
1298                         FormRequest fr = new FormRequest (t.Response, "form1");
1299                         fr.Controls.Add ("__EVENTTARGET");
1300                         fr.Controls.Add ("__EVENTARGUMENT");
1301                         fr.Controls["__EVENTTARGET"].Value = "DetailsView1";
1302                         fr.Controls["__EVENTARGUMENT"].Value = "Edit$0";
1303                         t.Request = fr;
1304                         pageHTML = t.Run ();
1305                         pageHTML = pageHTML.Substring (pageHTML.IndexOf ("starttest") + 9, pageHTML.IndexOf ("endtest") - pageHTML.IndexOf ("starttest") - 9);
1306                         string origHtmlValue = @" <div>
1307                                                 &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;
1308                                                 <div>
1309                                                 <table cellspacing=""0"" rules=""all"" border=""1"" id=""DetailsView1"" style=""height:50px;width:125px;border-collapse:collapse;"">
1310                                                 <tr>
1311                                                 <td>ID</td><td>1001</td>
1312                                                 </tr><tr>
1313                                                 <td>FName</td><td>Mahesh</td>
1314                                                 </tr><tr>
1315                                                 <td>LName</td><td>Chand</td>
1316                                                 </tr><tr>
1317                                                 <td colspan=""2""><a href=""javascript:__doPostBack('DetailsView1$ctl01','')"">Update</a>&nbsp;<a href=""javascript:__doPostBack('DetailsView1','Cancel$0')"">Cancel</a></td>
1318                                                 </tr><tr>
1319                                                 <td colspan=""2""><table border=""0"">
1320                                                 <tr>
1321                                                 <td><span>1</span></td><td><a href=""javascript:__doPostBack('DetailsView1','Page$2')"">2</a></td><td><a href=""javascript:__doPostBack('DetailsView1','Page$3')"">3</a></td>
1322                                                 </tr>
1323                                                 </table></td>
1324                                                 </tr>
1325                                                 </table>
1326                                                 </div>
1327                                                 </div>";
1328                                         HtmlDiff.AssertAreEqual (origHtmlValue, pageHTML, "AfterEditPostback");
1329
1330
1331                 }
1332
1333                 [Test]
1334                 [Category ("NunitWeb")]
1335                 [Category ("NotWorking")]
1336                 public void DetailsView_DeletePostback ()
1337                 {
1338                         WebTest t = new WebTest ("DetailsViewDataActions.aspx");
1339                         string pageHTML = t.Run ();
1340                         Assert.AreEqual (true, pageHTML.Contains ("1001"), "BeforeDeletePostback");
1341                         FormRequest fr = new FormRequest (t.Response, "form1");
1342                         fr.Controls.Add ("__EVENTTARGET");
1343                         fr.Controls.Add ("__EVENTARGUMENT");
1344                         fr.Controls["__EVENTTARGET"].Value = "DetailsView1";
1345                         fr.Controls["__EVENTARGUMENT"].Value = "Delete$0";
1346                         t.Request = fr;
1347                         pageHTML = t.Run ();
1348                         pageHTML = pageHTML.Substring (pageHTML.IndexOf ("starttest") + 9, pageHTML.IndexOf ("endtest") - pageHTML.IndexOf ("starttest") - 9);
1349                         string origHtmlValue = @"   <div>
1350                                                    &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;
1351                                                  <div>
1352                                                 <table cellspacing=""0"" rules=""all"" border=""1"" id=""DetailsView1"" style=""height:50px;width:125px;border-collapse:collapse;"">
1353                                                 <tr>
1354                                                 <td>ID</td><td>1002</td>
1355                                                 </tr><tr>
1356                                                 <td>FName</td><td>Melanie</td>
1357                                                 </tr><tr>
1358                                                 <td>LName</td><td>Talmadge</td>
1359                                                 </tr><tr>
1360                                                 <td colspan=""2""><a href=""javascript:__doPostBack('DetailsView1','Edit$0')"">Edit</a>&nbsp;<a href=""javascript:__doPostBack('DetailsView1','Delete$0')"">Delete</a>&nbsp;<a href=""javascript:__doPostBack('DetailsView1','New$0')"">New</a></td>
1361                                                 </tr><tr>
1362                                                 <td colspan=""2""><table border=""0"">
1363                                                 <tr>
1364                                                 <td><span>1</span></td><td><a href=""javascript:__doPostBack('DetailsView1','Page$2')"">2</a></td>
1365                                                 </tr>
1366                                                 </table></td>
1367                                                 </tr>
1368                                                 </table>
1369                                                 </div>
1370                                                 </div>";
1371
1372                         HtmlDiff.AssertAreEqual (origHtmlValue, pageHTML, "DeleteDataPostback");
1373                         Assert.AreEqual (false, pageHTML.Contains ("1001"), "AfterDeletePostback");
1374
1375
1376
1377                 }
1378
1379                 [Test]
1380                 [Category ("NunitWeb")]
1381                 [Category ("NotWorking")]
1382                 public void DetailsView_InsertPostback ()
1383                 {
1384
1385                         WebTest t = new WebTest ("DetailsViewDataActions.aspx");
1386                         string pageHTML = t.Run ();
1387                         Assert.AreEqual (true, pageHTML.Contains ("1001"), "BeforeDeletePostback");
1388                         FormRequest fr = new FormRequest (t.Response, "form1");
1389                         fr.Controls.Add ("__EVENTTARGET");
1390                         fr.Controls.Add ("__EVENTARGUMENT");
1391                         fr.Controls["__EVENTTARGET"].Value = "DetailsView1";
1392                         fr.Controls["__EVENTARGUMENT"].Value = "New$0";
1393                         t.Request = fr;
1394                         pageHTML = t.Run ();
1395                         pageHTML = pageHTML.Substring (pageHTML.IndexOf ("starttest") + 9, pageHTML.IndexOf ("endtest") - pageHTML.IndexOf ("starttest") - 9);
1396                         string origHtmlValue = @" <div>
1397                         &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;
1398                          <div>
1399                         <table cellspacing=""0"" rules=""all"" border=""1"" id=""DetailsView1"" style=""height:50px;width:125px;border-collapse:collapse;"">
1400                         <tr>
1401                         <td>ID</td><td><input name=""DetailsView1$ctl01"" type=""text"" title=""ID"" /></td>
1402                         </tr><tr>
1403                         <td>FName</td><td><input name=""DetailsView1$ctl02"" type=""text"" title=""FName"" /></td>
1404                         </tr><tr>
1405                         <td>LName</td><td><input name=""DetailsView1$ctl03"" type=""text"" title=""LName"" /></td>
1406                         </tr><tr>
1407                         <td colspan=""2""><a href=""javascript:__doPostBack('DetailsView1$ctl04','')"">Insert</a>&nbsp;<a href=""javascript:__doPostBack('DetailsView1','Cancel$-1')"">Cancel</a></td>
1408                         </tr>
1409                         </table>
1410                         </div>
1411                         </div>";
1412
1413                         HtmlDiff.AssertAreEqual (origHtmlValue, pageHTML, "InsertDataPostback");
1414                 }
1415
1416
1417                 [Test]
1418                 [Category ("NotWorking")]
1419                 public void DetailsView_ViewState ()
1420                 {
1421                         PokerDetailsView dv = new PokerDetailsView ();
1422                         PokerDetailsView copy = new PokerDetailsView ();
1423                         dv.HeaderText = "Header";
1424                         dv.GridLines = GridLines.Vertical;
1425                         dv.CssClass = "style.css";
1426                         object state = dv.SaveState ();
1427                         copy.LoadState (state);
1428                         Assert.AreEqual ("Header", copy.HeaderText, "ViewStateHeaderText");
1429                         Assert.AreEqual (GridLines.Vertical, copy.GridLines, "ViewStateGridLines");
1430                         Assert.AreEqual ("style.css", copy.CssClass, "ViewStateCssClass");
1431                 }
1432
1433                 [Test]
1434                 [Category ("NotWorking")]
1435                 public void DetailsView_ControlState ()
1436                 {
1437
1438                         PokerDetailsView dv = new PokerDetailsView ();
1439                         PokerDetailsView copy = new PokerDetailsView ();
1440                         string[] keys = new String[2];
1441                         keys[0] = "key1";
1442                         keys[1] = "key2";
1443                         dv.DataKeyNames = keys;
1444                         dv.BackImageUrl = "photo.jpg";
1445                         dv.DefaultMode = DetailsViewMode.Insert;
1446                         object state = dv.DoSaveControlState ();
1447                         copy.DoLoadControlState (state);
1448                         Assert.AreEqual ("key1", copy.DataKeyNames[0], "ControlStateDataKeyValue");
1449                         Assert.AreEqual ("key2", copy.DataKeyNames[1], "ControlStateDataKeyValue2");
1450                         Assert.AreEqual (DetailsViewMode.Insert, copy.DefaultMode, "ControlStateDefaultMode");
1451
1452                 }
1453
1454                 //events
1455                 private bool init;
1456                 private bool itemCommand;
1457                 private bool itemCreated;
1458                 private bool itemDeleted;
1459                 private bool itemDeleting;
1460                 private bool itemInserted;
1461                 private bool itemInserting;
1462                 private bool itemUpdated;
1463                 private bool itemUpdating;
1464                 private bool modeChanged;
1465                 private bool modeChanging;
1466                 private bool pageIndexChanged;
1467                 private bool pageIndexChanging;
1468                 private bool pagePreLoad;
1469                 private bool dataSourceViewChanged;
1470                 private bool preRender;
1471                 private bool unload;
1472                 private int newPageIndex;
1473
1474                 public void ResetEvents ()
1475                 {
1476                         init = false;
1477                         itemCommand = false;
1478                         itemCreated = false;
1479                         itemDeleted = false;
1480                         itemDeleting = false;
1481                         itemInserted = false;
1482                         itemInserting = false;
1483                         itemUpdated = false;
1484                         itemUpdating = false;
1485                         modeChanged = false;
1486                         modeChanging = false;
1487                         pageIndexChanged = false;
1488                         pageIndexChanging = false;
1489                         pagePreLoad = false;
1490                         dataSourceViewChanged = false;
1491                         preRender = false;
1492                         unload = false;
1493                 }
1494
1495                 [Test]
1496                 [Category ("NotWorking")]
1497                 public void DetailsView_BubbleEvents ()
1498                 {
1499                         ResetEvents ();
1500                         DetailsViewCommandEventArgs com;
1501                         PokerDetailsView dv = new PokerDetailsView ();
1502                         dv.DataSource = TableObject.CreateDataTable ();
1503                         Page page = new Page ();
1504                         Button bt = new Button ();
1505                         dv.AllowPaging = true;
1506                         page.Controls.Add (dv);
1507                         dv.ItemCommand += new DetailsViewCommandEventHandler (dv_ItemCommand );
1508                         dv.ItemDeleted += new DetailsViewDeletedEventHandler (dv_ItemDeleted );
1509                         //Delete
1510                         dv.ItemDeleting += new DetailsViewDeleteEventHandler (dv_ItemDeleting );
1511                         com = new DetailsViewCommandEventArgs (bt, new CommandEventArgs ("Delete", null));
1512                         Assert.AreEqual (false, itemCommand, "BeforeDeleteCommandBubbleEvent");
1513                         Assert.AreEqual (false, itemDeleting, "BeforeDeleteBubbleEvent");
1514                         dv.DoOnBubbleEvent (bt, com);
1515                         Assert.AreEqual (true, itemDeleting, "AfterDeleteBubbleEvent");
1516                         Assert.AreEqual (true, itemCommand, "AfterDeleteCommandBubbleEvent");
1517
1518                         //Insert
1519                         itemCommand = false;
1520                         dv.ItemInserting += new DetailsViewInsertEventHandler (dv_ItemInserting);
1521                         dv.ChangeMode (DetailsViewMode.Insert);
1522                         com = new DetailsViewCommandEventArgs (bt, new CommandEventArgs ("Insert", null));
1523                         Assert.AreEqual (false, itemCommand, "BeforeInsertCommandBubbleEvent");
1524                         Assert.AreEqual (false, itemInserting, "BeforeInsertBubbleEvent");
1525                         dv.DoOnBubbleEvent (bt, com);
1526                         Assert.AreEqual (true, itemCommand, "AfterInsertCommandBubbleEvent");
1527                         Assert.AreEqual (true, itemInserting, "AfterInsertBubbleEvent");
1528
1529                         //Update
1530                         itemCommand = false;
1531                         dv.ItemUpdating += new DetailsViewUpdateEventHandler (dv_ItemUpdating);
1532                         dv.ChangeMode (DetailsViewMode.Edit);
1533                         com = new DetailsViewCommandEventArgs (bt, new CommandEventArgs ("Update", null));
1534                         Assert.AreEqual (false, itemUpdating, "BeforeUpdateEvent");
1535                         Assert.AreEqual (false, itemCommand, "BeforeUpdateCommandEvent");
1536                         dv.DoOnBubbleEvent (bt, com);
1537                         Assert.AreEqual (true, itemCommand, "AfterUpdateCommandBubbleEvent");
1538                         Assert.AreEqual (true, itemUpdating, "AfterUpdateBubbleEvent");
1539
1540                         //Cancel
1541                         itemCommand = false;
1542                         dv.ModeChanging += new DetailsViewModeEventHandler (dv_ModeChanging);
1543                         com = new DetailsViewCommandEventArgs (bt, new CommandEventArgs ("Cancel", null));
1544                         Assert.AreEqual (false, itemCommand, "BeforeCancelCommandBubbleEvent");
1545                         Assert.AreEqual (false, modeChanging, "BeforeCancelBubbleEvent");
1546                         dv.DoOnBubbleEvent (bt, com);
1547                         Assert.AreEqual (true, itemCommand, "AfterCancelCommandBubbleEvent");
1548                         Assert.AreEqual (true, modeChanging, "AfterCancelBubbleEvent");
1549
1550                         //Edit
1551                         itemCommand = false;
1552                         modeChanging = false;
1553                         com = new DetailsViewCommandEventArgs (bt, new CommandEventArgs ("Edit", null));
1554                         Assert.AreEqual (false, itemCommand, "BeforeEditCommandBubbleEvent");
1555                         Assert.AreEqual (false, modeChanging, "BeforeEditBubbleEvent");
1556                         dv.DoOnBubbleEvent (bt, com);
1557                         Assert.AreEqual (true, itemCommand, "AfterEditCommandBubbleEvent");
1558                         Assert.AreEqual (true, modeChanging, "AfterEditBubbleEvent");
1559
1560                         //New
1561                         itemCommand = false;
1562                         modeChanging = false;
1563                         com = new DetailsViewCommandEventArgs (bt, new CommandEventArgs ("New", null));
1564                         Assert.AreEqual (false, itemCommand, "BeforeNewCommandBubbleEvent");
1565                         Assert.AreEqual (false, modeChanging, "BeforeNewBubbleEvent");
1566                         dv.DoOnBubbleEvent (bt, com);
1567                         Assert.AreEqual (true, itemCommand, "AfterNewCommandBubbleEvent");
1568                         Assert.AreEqual (true, modeChanging, "AfterNewBubbleEvent");
1569
1570                         //Page Index default
1571                         itemCommand = false;
1572                         dv.PageIndexChanging += new DetailsViewPageEventHandler (dv_PageIndexChanging );
1573                         com = new DetailsViewCommandEventArgs (bt, new CommandEventArgs ("Page", null));
1574                         Assert.AreEqual (false, itemCommand, "BeforePageCommandBubbleEvent");
1575                         Assert.AreEqual (false, pageIndexChanging, "BeforePageBubbleEvent");
1576                         dv.DoOnBubbleEvent (bt, com);
1577                         Assert.AreEqual (true, itemCommand, "AfterPageCommandBubbleEvent");
1578                         Assert.AreEqual (true, pageIndexChanging, "AfterPageBubbleEvent");
1579
1580                         //Next Page
1581                         itemCommand = false;
1582                         pageIndexChanging = false;
1583                         com = new DetailsViewCommandEventArgs (bt, new CommandEventArgs ("Page", "Next"));
1584                         Assert.AreEqual (false, itemCommand, "BeforeNextPageCommandBubbleEvent");
1585                         Assert.AreEqual (false, pageIndexChanging, "BeforeNextPageBubbleEvent");
1586                         dv.DoOnBubbleEvent (bt, com);
1587                         Assert.AreEqual (true, itemCommand, "AfterNextPageCommandBubbleEvent");
1588                         Assert.AreEqual (true, pageIndexChanging, "AfterNextPageBubbleEvent");
1589                         Assert.AreEqual (1, newPageIndex, "NextPageIndex");
1590
1591                         //Prev Page
1592                         itemCommand = false;
1593                         pageIndexChanging = false;
1594                         com = new DetailsViewCommandEventArgs (bt, new CommandEventArgs ("Page", "Prev"));
1595                         Assert.AreEqual (false, itemCommand, "BeforePrevPageCommandBubbleEvent");
1596                         Assert.AreEqual (false, pageIndexChanging, "BeforePrevPageBubbleEvent");
1597                         dv.DoOnBubbleEvent (bt, com);
1598                         Assert.AreEqual (true, itemCommand, "AfterPrevPageCommandBubbleEvent");
1599                         Assert.AreEqual (true, pageIndexChanging, "AfterPrevPageBubbleEvent");
1600                         Assert.AreEqual (-1, newPageIndex, "PrevPageIndex");
1601
1602                         //First Page
1603                         itemCommand = false;
1604                         pageIndexChanging = false;
1605                         com = new DetailsViewCommandEventArgs (bt, new CommandEventArgs ("Page", "First"));
1606                         Assert.AreEqual (false, itemCommand, "BeforeFirstPageCommandBubbleEvent");
1607                         Assert.AreEqual (false, pageIndexChanging, "BeforeFirstPageBubbleEvent");
1608                         dv.DoOnBubbleEvent (bt, com);
1609                         Assert.AreEqual (true, itemCommand, "AfterFirstPageCommandBubbleEvent");
1610                         Assert.AreEqual (true, pageIndexChanging, "AfterFirstPageBubbleEvent");
1611                         Assert.AreEqual (0, newPageIndex, "FirstPageIndex");
1612
1613                         //Last Page
1614                         itemCommand = false;
1615                         pageIndexChanging = false;
1616                         com = new DetailsViewCommandEventArgs (bt, new CommandEventArgs ("Page", "Last"));
1617                         Assert.AreEqual (false, itemCommand, "BeforeLastPageCommandBubbleEvent");
1618                         Assert.AreEqual (false, pageIndexChanging, "BeforeLastPageBubbleEvent");
1619                         dv.DoOnBubbleEvent (bt, com);
1620                         Assert.AreEqual (true, itemCommand, "AfterLastPageCommandBubbleEvent");
1621                         Assert.AreEqual (true, pageIndexChanging, "AfterLastPageBubbleEvent");
1622                         Assert.AreEqual (-1, newPageIndex, "FirstPageIndex");
1623
1624                 }
1625
1626                 [Test]
1627                 [Category ("NotWorking")]
1628                 public void DetailsView_Events ()
1629                 {
1630                         ResetEvents ();
1631                         PokerDetailsView dv = new PokerDetailsView ();
1632                         Button bt = new Button ();
1633                         Page pg = new Page ();
1634                         dv.Page = pg;
1635                         dv.Init += new EventHandler (dv_Init);
1636                         dv.ItemCommand += new DetailsViewCommandEventHandler (dv_ItemCommand);
1637                         dv.ItemCreated += new EventHandler (dv_ItemCreated);
1638                         dv.ItemDeleted += new DetailsViewDeletedEventHandler (dv_ItemDeleted);
1639                         dv.ItemDeleting += new DetailsViewDeleteEventHandler (dv_ItemDeleting);
1640                         dv.ItemInserted += new DetailsViewInsertedEventHandler (dv_ItemInserted);
1641                         dv.ItemInserting += new DetailsViewInsertEventHandler (dv_ItemInserting);
1642                         dv.ItemUpdated += new DetailsViewUpdatedEventHandler (dv_ItemUpdated);
1643                         dv.ItemUpdating += new DetailsViewUpdateEventHandler (dv_ItemUpdating);
1644                         dv.ModeChanged += new EventHandler (dv_ModeChanged);
1645                         dv.ModeChanging += new DetailsViewModeEventHandler (dv_ModeChanging);
1646                         dv.PageIndexChanged += new EventHandler (dv_PageIndexChanged);
1647                         dv.PageIndexChanging += new DetailsViewPageEventHandler (dv_PageIndexChanging);
1648                         dv.DataBound += new EventHandler (dv_DataBound);
1649                         dv.PreRender += new EventHandler (dv_PreRender);
1650                         dv.Unload += new EventHandler (dv_Unload);
1651                         Assert.AreEqual (false, init, "BeforeInit");
1652                         dv.DoOnInit (new EventArgs ());
1653                         Assert.AreEqual (true, init, "AfterInit");
1654                         Assert.AreEqual (false, itemCommand, "BeforeItemCommand");
1655                         dv.DoOnItemCommand (new DetailsViewCommandEventArgs (bt,new CommandEventArgs ("",null)));
1656                         Assert.AreEqual (true, itemCommand , "AfterItemCommand");
1657                         Assert.AreEqual (false, itemCreated, "BeforeItemCreated");
1658                         dv.DoOnItemCreated (new EventArgs ());
1659                         Assert.AreEqual (true, itemCreated, "AfterItemCreated");
1660                         Assert.AreEqual (false, itemDeleted, "BeforeItemDeleted");
1661                         dv.DoOnItemDeleted (new DetailsViewDeletedEventArgs (3, new Exception ()));
1662                         Assert.AreEqual (true, itemDeleted, "AfterItemDeleted");
1663                         Assert.AreEqual (false, itemDeleting, "BeforeItemDeleting");
1664                         dv.DoOnItemDeleting(new DetailsViewDeleteEventArgs (2));
1665                         Assert.AreEqual (true, itemDeleting, "AfterItemDeleting");
1666                         Assert.AreEqual (false, itemInserted, "BeforeItemInserted");
1667                         dv.DoOnItemInserted (new DetailsViewInsertedEventArgs (3,new Exception()));
1668                         Assert.AreEqual (true, itemInserted, "AfterItemInserted");
1669                         Assert.AreEqual (false, itemInserting, "BeforeItemInserting");
1670                         dv.DoOnItemInserting (new DetailsViewInsertEventArgs (bt));
1671                         Assert.AreEqual (true, itemInserting, "AfterItemInserting");
1672                         Assert.AreEqual (false, itemUpdated, "BeforeItemUpdated");
1673                         dv.DoOnItemUpdated (new DetailsViewUpdatedEventArgs (2,new Exception()));
1674                         Assert.AreEqual (true, itemUpdated, "AfterItemUpdated");
1675                         Assert.AreEqual (false, itemUpdating, "BeforeItemUpdating");
1676                         dv.DoOnItemUpdating (new DetailsViewUpdateEventArgs (bt));
1677                         Assert.AreEqual (true, itemUpdating, "AfterItemUpdating");
1678                         Assert.AreEqual (false, modeChanged, "BeforeModeChanged");
1679                         dv.DoOnModeChanged (new EventArgs ());
1680                         Assert.AreEqual (true, modeChanged, "AfterModeChanged");
1681                         Assert.AreEqual (false, modeChanging, "BeforeModeChanging");
1682                         dv.DoOnModeChanging (new DetailsViewModeEventArgs (DetailsViewMode.Insert ,false));
1683                         Assert.AreEqual (true, modeChanging, "AfterModeChanging");
1684                         Assert.AreEqual (false, pageIndexChanged, "BeforePageIndexChanged");
1685                         dv.DoOnPageIndexChanged (new EventArgs ());
1686                         Assert.AreEqual (true, pageIndexChanged, "AfterPageIndexChanged");
1687                         Assert.AreEqual (false, pageIndexChanging, "BeforePageIndexChanging");
1688                         dv.DoOnPageIndexChanging (new DetailsViewPageEventArgs (2));
1689                         Assert.AreEqual (true, pageIndexChanging, "AfterPageIndexChanging");
1690                         //Assert.AreEqual (false, pagePreLoad, "BeforePagePreLoad");
1691                         //dv.DoOnPagePreLoad (pg, new EventArgs ());
1692                         //Assert.AreEqual (true, pagePreLoad, "AfterPagePreLoad");
1693                         Assert.AreEqual (false, preRender, "BeforePreRender");
1694                         dv.DoOnPreRender(new EventArgs ());
1695                         Assert.AreEqual (true, preRender, "AfterPreRender");
1696                         Assert.AreEqual (false, unload, "BeforeUnload");
1697                         dv.DoOnUnload (new EventArgs ());
1698                         Assert.AreEqual (true, unload, "AfterUnload");
1699                         //Assert.AreEqual (false, dataSourceViewChanged, "BeforeDataSourceViewChanged");
1700                         //dv.DoOnDataSourceViewChanged (bt, new EventArgs ());
1701                         //Assert.AreEqual (true, dataSourceViewChanged, "AfterDataSourceViewChanged");
1702
1703
1704
1705
1706                 }
1707
1708                 void dv_DataBound(object sender, EventArgs e)
1709                 {
1710                         dataSourceViewChanged = true;
1711                 }
1712
1713
1714                 void dv_Unload (object sender, EventArgs e)
1715                 {
1716                         unload = true;
1717                 }
1718
1719                 void dv_PreRender (object sender, EventArgs e)
1720                 {
1721                         preRender = true;
1722                 }
1723
1724                 void dv_PageIndexChanging (object sender, DetailsViewPageEventArgs e)
1725                 {
1726                         pageIndexChanging = true;
1727                         newPageIndex = e.NewPageIndex;
1728                 }
1729
1730                 void dv_PageIndexChanged (object sender, EventArgs e)
1731                 {
1732                         pageIndexChanged = true;
1733                 }
1734
1735                 void dv_ModeChanging (object sender, DetailsViewModeEventArgs e)
1736                 {
1737                         modeChanging = true;
1738                 }
1739
1740                 void dv_ModeChanged (object sender, EventArgs e)
1741                 {
1742                         modeChanged = true;
1743
1744                 }
1745
1746
1747
1748                 void dv_ItemUpdating (object sender, DetailsViewUpdateEventArgs e)
1749                 {
1750                         itemUpdating = true;
1751                 }
1752
1753                 void dv_ItemUpdated (object sender, DetailsViewUpdatedEventArgs e)
1754                 {
1755                         itemUpdated = true;
1756                 }
1757
1758                 void dv_ItemInserting (object sender, DetailsViewInsertEventArgs e)
1759                 {
1760                         itemInserting = true;
1761                 }
1762
1763                 void dv_ItemInserted (object sender, DetailsViewInsertedEventArgs e)
1764                 {
1765                         itemInserted = true;
1766                 }
1767
1768                 void dv_ItemDeleting (object sender, DetailsViewDeleteEventArgs e)
1769                 {
1770                         itemDeleting = true;
1771                 }
1772
1773                 void dv_ItemDeleted (object sender, DetailsViewDeletedEventArgs e)
1774                 {
1775                         itemDeleted = true;
1776                 }
1777
1778                 void dv_ItemCreated (object sender, EventArgs e)
1779                 {
1780                         itemCreated = true;
1781                 }
1782
1783                 void dv_ItemCommand (object sender, DetailsViewCommandEventArgs e)
1784                 {
1785                         itemCommand = true;
1786                 }
1787
1788                 void dv_Init (object sender, EventArgs e)
1789                 {
1790                         init = true;
1791                 }
1792
1793                 //Exceptions
1794
1795                 [Test]
1796                 [Category ("NotWorking")]
1797                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1798                 public void CellPaddingException ()
1799                 {
1800                         PokerDetailsView dv = new PokerDetailsView ();
1801                         dv.CellPadding = -2;
1802                 }
1803
1804                 [Test]
1805                 [Category ("NotWorking")]
1806                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1807                 public void CellSpacingException ()
1808                 {
1809                         PokerDetailsView dv = new PokerDetailsView ();
1810                         dv.CellSpacing = -5;
1811                 }
1812
1813                 [Test]
1814                 [Category ("NotWorking")]
1815                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1816                 public void PageIndexException ()
1817                 {
1818                         PokerDetailsView dv = new PokerDetailsView ();
1819                         dv.PageIndex = -5;
1820                 }
1821
1822                 [Test]
1823                 [Category ("NotWorking")]
1824                 [ExpectedException (typeof (HttpException))]
1825                 public void InsertItemException ()
1826                 {
1827                         PokerDetailsView dv = new PokerDetailsView ();
1828                         dv.InsertItem (true);
1829                 }
1830
1831                 [Test]
1832                 [Category ("NotWorking")]
1833                 [ExpectedException (typeof (HttpException))]
1834                 public void UpdateItemException ()
1835                 {
1836                         PokerDetailsView dv = new PokerDetailsView ();
1837                         dv.UpdateItem (true);
1838                 }
1839
1840                 [Test]
1841                 [Category ("NotWorking")]
1842                 public void DetailsView_CreateDataSourceSelectArguments () {
1843                         DataSourceView view;
1844                         Page p = new Page ();
1845
1846                         PokerDetailsView dv = new PokerDetailsView ();
1847                         p.Controls.Add (dv);
1848
1849                         ObjectDataSource data = new ObjectDataSource ();
1850                         data.TypeName = typeof (DataSourceObject).AssemblyQualifiedName;
1851                         data.SelectMethod = "GetList";
1852                         data.SortParameterName = "sortExpression";
1853                         DataSourceSelectArguments arg;
1854                         p.Controls.Add (data);
1855
1856                         dv.DataSource = data;
1857                         dv.DataBind ();
1858
1859                         arg = dv.DoCreateDataSourceSelectArguments ();
1860                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "Default");
1861
1862                         dv.AllowPaging = true;
1863                         dv.PageIndex = 2;
1864                         arg = dv.DoCreateDataSourceSelectArguments ();
1865                         view = dv.DoGetData ();
1866                         Assert.IsFalse (view.CanPage);
1867                         Assert.IsTrue (view.CanRetrieveTotalRowCount);
1868                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "AllowPaging = true, CanPage = false, CanRetrieveTotalRowCount = true");
1869
1870                         // make DataSourceView.CanPage = true
1871                         data.EnablePaging = true;
1872
1873                         arg = dv.DoCreateDataSourceSelectArguments ();
1874                         view = dv.DoGetData ();
1875                         Assert.IsTrue (view.CanPage);
1876                         Assert.IsFalse (view.CanRetrieveTotalRowCount);
1877                         Assert.IsTrue (arg.Equals (new DataSourceSelectArguments (2, -1)), "AllowPaging = true, CanPage = true, CanRetrieveTotalRowCount = false");
1878
1879                         dv.AllowPaging = false;
1880                         arg = dv.DoCreateDataSourceSelectArguments ();
1881                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "AllowPaging = false, CanPage = true, CanRetrieveTotalRowCount = false");
1882
1883                         // make DataSourceView.CanRetrieveTotalRowCount = true
1884                         data.SelectCountMethod = "GetCount";
1885
1886                         arg = dv.DoCreateDataSourceSelectArguments ();
1887                         Assert.IsTrue (arg.Equals (DataSourceSelectArguments.Empty), "AllowPaging = false, CanPage = true, CanRetrieveTotalRowCount = true");
1888
1889                         dv.AllowPaging = true;
1890                         arg = dv.DoCreateDataSourceSelectArguments ();
1891                         DataSourceSelectArguments arg1 = new DataSourceSelectArguments (2, 1);
1892                         arg1.RetrieveTotalRowCount = true;
1893                         view = dv.DoGetData ();
1894                         Assert.IsTrue (view.CanPage);
1895                         Assert.IsTrue (view.CanRetrieveTotalRowCount);
1896                         Assert.IsTrue (arg.Equals (arg1), "AllowPaging = true, CanPage = true, CanRetrieveTotalRowCount = true");
1897                 }
1898
1899                 [Test]
1900                 public void DetailsView_CurrentMode () {
1901                         DetailsView view = new DetailsView ();
1902                         view.DefaultMode = DetailsViewMode.Insert;
1903                         Assert.AreEqual (DetailsViewMode.Insert, view.CurrentMode, "DetailsView_CurrentMode#1");
1904                         view.ChangeMode (DetailsViewMode.Edit);
1905                         Assert.AreEqual (DetailsViewMode.Edit, view.CurrentMode, "DetailsView_CurrentMode#2");
1906                 }
1907         }
1908
1909         public class DTemplate : ITemplate
1910         {
1911
1912                 Label l = new Label ();
1913 #region ITemplate Members
1914
1915                 public void InstantiateIn (Control container)
1916                 {
1917                         container.Controls.Add (l);
1918
1919                 }
1920
1921                 public void SetDataItem (object value)
1922                 {
1923                         l.Text = value.ToString ();
1924                 }
1925
1926                 #endregion
1927         }
1928
1929         public class TableObject
1930         {
1931                 public static DataTable ds = CreateDataTable ();
1932                 public static DataTable GetMyData ()
1933                 {
1934                         return ds;
1935                 }
1936
1937                 public static DataTable Delete (string ID, string FName, string LName)
1938                 {
1939                         DataRow dr = ds.Rows.Find (ID);
1940                         Assert.IsNotNull (dr);
1941                         int oldCount = ds.Rows.Count;
1942                         ds.Rows.Remove (dr);
1943                         Assert.AreEqual (oldCount - 1, ds.Rows.Count);
1944                         return ds;
1945
1946                 }
1947
1948                 public static DataTable Update (string ID, string FName, string LName)
1949                 {
1950                         DataRow dr = ds.Rows.Find (ID);
1951                         if (dr == null) {
1952                                 Label lbl = new Label ();
1953                                 lbl.Text = "ID doesn't exist. update only FName and LName";
1954                                 return ds;
1955                         }
1956                         dr["FName"] = FName;
1957                         dr["LName"] = LName;
1958                         return ds;
1959
1960                 }
1961
1962                 public static DataTable Insert (string ID, string FName, string LName)
1963                 {
1964                         DataRow dr = ds.NewRow ();
1965                         dr["ID"] = ID;
1966                         dr["FName"] = FName;
1967                         dr["LName"] = LName;
1968                         int oldCount = ds.Rows.Count;
1969                         ds.Rows.Add (dr);
1970                         Assert.AreEqual (oldCount + 1, ds.Rows.Count);
1971                         return ds;
1972                 }
1973
1974
1975                 public static DataTable CreateDataTable ()
1976                 {
1977
1978                         DataTable aTable = new DataTable ("A");
1979                         DataColumn dtCol;
1980                         DataRow dtRow;
1981
1982                         // Create ID column and add to the DataTable.
1983
1984                         dtCol = new DataColumn ();
1985                         dtCol.DataType = Type.GetType ("System.Int32");
1986                         dtCol.ColumnName = "ID";
1987                         dtCol.AutoIncrement = true;
1988                         dtCol.Caption = "ID";
1989                         dtCol.ReadOnly = true;
1990                         dtCol.Unique = true;
1991
1992                         // Add the column to the DataColumnCollection.
1993
1994                         aTable.Columns.Add (dtCol);
1995
1996                         // Create Name column and add to the table
1997
1998                         dtCol = new DataColumn ();
1999                         dtCol.DataType = Type.GetType ("System.String");
2000                         dtCol.ColumnName = "FName";
2001                         dtCol.AutoIncrement = false;
2002                         dtCol.Caption = "First Name";
2003                         dtCol.ReadOnly = false;
2004                         dtCol.Unique = false;
2005                         aTable.Columns.Add (dtCol);
2006
2007
2008                         // Create Last Name column and add to the table.
2009
2010                         dtCol = new DataColumn ();
2011                         dtCol.DataType = Type.GetType ("System.String");
2012                         dtCol.ColumnName = "LName";
2013                         dtCol.AutoIncrement = false;
2014                         dtCol.Caption = "Last Name";
2015                         dtCol.ReadOnly = false;
2016                         dtCol.Unique = false;
2017                         aTable.Columns.Add (dtCol);
2018
2019
2020                         // Create three rows to the table
2021                         dtRow = aTable.NewRow ();
2022                         dtRow["ID"] = 1001;
2023                         dtRow["FName"] = "Mahesh";
2024                         dtRow["LName"] = "Chand";
2025                         aTable.Rows.Add (dtRow);
2026
2027
2028                         dtRow = aTable.NewRow ();
2029                         dtRow["ID"] = 1002;
2030                         dtRow["FName"] = "Melanie";
2031                         dtRow["LName"] = "Talmadge";
2032                         aTable.Rows.Add (dtRow);
2033
2034                         dtRow = aTable.NewRow ();
2035                         dtRow["ID"] = 1003;
2036                         dtRow["FName"] = "Vinay";
2037                         dtRow["LName"] = "Bansal";
2038                         aTable.Rows.Add (dtRow);
2039
2040                         aTable.PrimaryKey = new DataColumn[] { aTable.Columns["ID"] };
2041                         return aTable;
2042
2043                 }
2044         }
2045 }
2046 #endif
2047