mcs/class/System.Data/Test/System.Data/DataColumnCollectionTest.cs

   1 // DataColumnCollectionTest.cs - NUnit Test Cases for System.Data.DataColumnCollection
   2 //
   3 // Authors:
   4 //   Franklin Wise <gracenote@earthlink.net>
   5 //   Ville Palo <vi64pa@kolumbus.fi>
   6 //   Martin Willemoes Hansen <mwh@sysrq.dk>
   7 //
   8 // (C) Copyright 2002 Franklin Wise
   9 // (C) Copyright 2003 Ville Palo
  10 // (C) Copyright 2003 Martin Willemoes Hansen
  11 //
  12
  13 //
  14 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  15 //
  16 // Permission is hereby granted, free of charge, to any person obtaining
  17 // a copy of this software and associated documentation files (the
  18 // "Software"), to deal in the Software without restriction, including
  19 // without limitation the rights to use, copy, modify, merge, publish,
  20 // distribute, sublicense, and/or sell copies of the Software, and to
  21 // permit persons to whom the Software is furnished to do so, subject to
  22 // the following conditions:
  23 //
  24 // The above copyright notice and this permission notice shall be
  25 // included in all copies or substantial portions of the Software.
  26 //
  27 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  28 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  29 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  30 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  31 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  32 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  33 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  34 //
  35
  36 using NUnit.Framework;
  37 using System;
  38 using System.Data;
  39 using System.Xml;
  40
  41 namespace MonoTests.System.Data
  42 {
  43         [TestFixture]
  44         public class DataColumnCollectionTest : Assertion
  45         {
  46                 private DataTable _tbl;
  47
  48                 [SetUp]
  49                 public void GetReady ()
  50                 {
  51                         _tbl = new DataTable();
  52                 }
  53
  54                 //TODO
  55                 [Test]
  56                 public void AddValidationExceptions()
  57                 {
  58
  59                         //Set DefaultValue and AutoIncr == true
  60                         //And get an exception
  61                 }
  62
  63                 [Test]
  64                 public void Add ()
  65                 {
  66                         DataTable Table = new DataTable ("test_table");
  67                         DataColumnCollection Cols = Table.Columns;
  68                         DataColumn C = null;
  69                         Cols.Add ();
  70                         Cols.Add ();
  71
  72                         C = Cols [0];
  73                         AssertEquals ("test#01", true, C.AllowDBNull);
  74                         AssertEquals ("test#02", false, C.AutoIncrement);
  75                         AssertEquals ("test#03", 0L, C.AutoIncrementSeed);
  76                         AssertEquals ("test#04", 1L, C.AutoIncrementStep);
  77                         AssertEquals ("test#05", "Column1", C.Caption);
  78                         AssertEquals ("test#06", "Element", C.ColumnMapping.ToString ());
  79                         AssertEquals ("test#07", "Column1", C.ColumnName);
  80                         AssertEquals ("test#08", true, C.Container == null);
  81                         AssertEquals ("test#09", typeof (string), C.DataType);
  82                         AssertEquals ("test#10", DBNull.Value, C.DefaultValue);
  83                         AssertEquals ("test#11", false, C.DesignMode);
  84                         AssertEquals ("test#12", "", C.Expression);
  85                         AssertEquals ("test#13", 0, C.ExtendedProperties.Count);
  86                         AssertEquals ("test#14", -1, C.MaxLength);
  87                         AssertEquals ("test#15", "", C.Namespace);
  88                         AssertEquals ("test#16", 0, C.Ordinal);
  89                         AssertEquals ("test#17", "", C.Prefix);
  90                         AssertEquals ("test#18", false, C.ReadOnly);
  91                         AssertEquals ("test#19", null, C.Site);
  92                         AssertEquals ("test#20", "test_table", C.Table.TableName);
  93                         AssertEquals ("test#21", "Column1", C.ToString ());
  94                         AssertEquals ("test#22", false, C.Unique);
  95
  96                         C = Cols [1];
  97                         AssertEquals ("test#23", true, C.AllowDBNull);
  98                         AssertEquals ("test#24", false, C.AutoIncrement);
  99                         AssertEquals ("test#25", 0L, C.AutoIncrementSeed);
 100                         AssertEquals ("test#26", 1L, C.AutoIncrementStep);
 101                         AssertEquals ("test#27", "Column2", C.Caption);
 102                         AssertEquals ("test#28", "Element", C.ColumnMapping.ToString ());
 103                         AssertEquals ("test#29", "Column2", C.ColumnName);
 104                         AssertEquals ("test#30", true, C.Container == null);
 105                         AssertEquals ("test#31", typeof (string), C.DataType);
 106                         AssertEquals ("test#32", DBNull.Value, C.DefaultValue);
 107                         AssertEquals ("test#33", false, C.DesignMode);
 108                         AssertEquals ("test#34", "", C.Expression);
 109                         AssertEquals ("test#35", 0, C.ExtendedProperties.Count);
 110                         AssertEquals ("test#36", -1, C.MaxLength);
 111                         AssertEquals ("test#37", "", C.Namespace);
 112                         AssertEquals ("test#38", 1, C.Ordinal);
 113                         AssertEquals ("test#39", "", C.Prefix);
 114                         AssertEquals ("test#40", false, C.ReadOnly);
 115                         AssertEquals ("test#41", null, C.Site);
 116                         AssertEquals ("test#42", "test_table", C.Table.TableName);
 117                         AssertEquals ("test#43", "Column2", C.ToString ());
 118                         AssertEquals ("test#44", false, C.Unique);
 119
 120                         Cols.Add ("test1", typeof (int), "");
 121                         Cols.Add ("test2", typeof (string), "Column1 + Column2");
 122
 123                         C = Cols [2];
 124                         AssertEquals ("test#45", true, C.AllowDBNull);
 125                         AssertEquals ("test#46", false, C.AutoIncrement);
 126                         AssertEquals ("test#47", 0L, C.AutoIncrementSeed);
 127                         AssertEquals ("test#48", 1L, C.AutoIncrementStep);
 128                         AssertEquals ("test#49", "test1", C.Caption);
 129                         AssertEquals ("test#50", "Element", C.ColumnMapping.ToString ());
 130                         AssertEquals ("test#51", "test1", C.ColumnName);
 131                         AssertEquals ("test#52", true, C.Container == null);
 132                         AssertEquals ("test#53", typeof (int), C.DataType);
 133                         AssertEquals ("test#54", DBNull.Value, C.DefaultValue);
 134                         AssertEquals ("test#55", false, C.DesignMode);
 135                         AssertEquals ("test#56", "", C.Expression);
 136                         AssertEquals ("test#57", 0, C.ExtendedProperties.Count);
 137                         AssertEquals ("test#58", -1, C.MaxLength);
 138                         AssertEquals ("test#59", "", C.Namespace);
 139                         AssertEquals ("test#60", 2, C.Ordinal);
 140                         AssertEquals ("test#61", "", C.Prefix);
 141                         AssertEquals ("test#62", false, C.ReadOnly);
 142                         AssertEquals ("test#63", null, C.Site);
 143                         AssertEquals ("test#64", "test_table", C.Table.TableName);
 144                         AssertEquals ("test#65", "test1", C.ToString ());
 145                         AssertEquals ("test#66", false, C.Unique);
 146
 147                         C = Cols [3];
 148                         AssertEquals ("test#67", true, C.AllowDBNull);
 149                         AssertEquals ("test#68", false, C.AutoIncrement);
 150                         AssertEquals ("test#69", 0L, C.AutoIncrementSeed);
 151                         AssertEquals ("test#70", 1L, C.AutoIncrementStep);
 152                         AssertEquals ("test#71", "test2", C.Caption);
 153                         AssertEquals ("test#72", "Element", C.ColumnMapping.ToString ());
 154                         AssertEquals ("test#73", "test2", C.ColumnName);
 155                         AssertEquals ("test#74", true, C.Container == null);
 156                         AssertEquals ("test#75", typeof (string), C.DataType);
 157                         AssertEquals ("test#76", DBNull.Value, C.DefaultValue);
 158                         AssertEquals ("test#77", false, C.DesignMode);
 159                         AssertEquals ("test#78", "Column1 + Column2", C.Expression);
 160                         AssertEquals ("test#79", 0, C.ExtendedProperties.Count);
 161                         AssertEquals ("test#80", -1, C.MaxLength);
 162                         AssertEquals ("test#81", "", C.Namespace);
 163                         AssertEquals ("test#82", 3, C.Ordinal);
 164                         AssertEquals ("test#83", "", C.Prefix);
 165                         AssertEquals ("test#84", true, C.ReadOnly);
 166                         AssertEquals ("test#85", null, C.Site);
 167                         AssertEquals ("test#86", "test_table", C.Table.TableName);
 168                         AssertEquals ("test#87", "test2 + Column1 + Column2", C.ToString ());
 169                         AssertEquals ("test#88", false, C.Unique);
 170
 171                         C = new DataColumn ("test3", typeof (int));
 172                         Cols.Add (C);
 173
 174                         C = Cols [4];
 175                         AssertEquals ("test#89", true, C.AllowDBNull);
 176                         AssertEquals ("test#90", false, C.AutoIncrement);
 177                         AssertEquals ("test#91", 0L, C.AutoIncrementSeed);
 178                         AssertEquals ("test#92", 1L, C.AutoIncrementStep);
 179                         AssertEquals ("test#93", "test3", C.Caption);
 180                         AssertEquals ("test#94", "Element", C.ColumnMapping.ToString ());
 181                         AssertEquals ("test#95", "test3", C.ColumnName);
 182                         AssertEquals ("test#96", true, C.Container == null);
 183                         AssertEquals ("test#97", typeof (int), C.DataType);
 184                         AssertEquals ("test#98", DBNull.Value, C.DefaultValue);
 185                         AssertEquals ("test#99", false, C.DesignMode);
 186                         AssertEquals ("test#100", "", C.Expression);
 187                         AssertEquals ("test#101", 0, C.ExtendedProperties.Count);
 188                         AssertEquals ("test#102", -1, C.MaxLength);
 189                         AssertEquals ("test#103", "", C.Namespace);
 190                         AssertEquals ("test#104", 4, C.Ordinal);
 191                         AssertEquals ("test#105", "", C.Prefix);
 192                         AssertEquals ("test#106", false, C.ReadOnly);
 193                         AssertEquals ("test#107", null, C.Site);
 194                         AssertEquals ("test#108", "test_table", C.Table.TableName);
 195                         AssertEquals ("test#109", "test3", C.ToString ());
 196                         AssertEquals ("test#110", false, C.Unique);
 197                 }
 198
 199                 [Test]
 200                 public void AddExceptions ()
 201                 {
 202                         DataTable Table = new DataTable ("test_table");
 203                         DataTable Table2 = new DataTable ("test_table2");
 204                         DataColumnCollection Cols = Table.Columns;
 205                         DataColumn C = null;
 206
 207                         try {
 208                                 Cols.Add (C);
 209                                 Fail ("test#01");
 210                         } catch (Exception e) {
 211                                 AssertEquals ("test#02", typeof (ArgumentNullException), e.GetType ());
 212                         }
 213
 214                         C = new DataColumn ("test");
 215                         Cols.Add (C);
 216
 217                         try {
 218                                 Cols.Add (C);
 219                                 Fail ("test#04");
 220                         } catch (ArgumentException e) {
 221 //                              AssertEquals ("test#05", typeof (ArgumentException), e.GetType ());
 222 //                              AssertEquals ("test#06", "Column 'test' already belongs to this or another DataTable.", e.Message);
 223                         }
 224
 225                         try {
 226                                 Table2.Columns.Add (C);
 227                                 Fail ("test#07");
 228                         } catch (ArgumentException e) {
 229 //                              AssertEquals ("test#08", typeof (ArgumentException), e.GetType ());
 230 //                              AssertEquals ("test#09", "Column 'test' already belongs to this or another DataTable.", e.Message);
 231                         }
 232
 233                         DataColumn C2 = new DataColumn ("test");
 234
 235                         try {
 236                                 Cols.Add (C2);
 237                                 Fail ("test#10");
 238                         } catch (DuplicateNameException e) {
 239 //                              AssertEquals ("test#11", typeof (DuplicateNameException), e.GetType ());
 240 //                              AssertEquals ("test#12", "A DataColumn named 'test' already belongs to this DataTable.", e.Message);
 241                         }
 242
 243                         try {
 244                                 Cols.Add ("test2", typeof (string), "substring ('fdsafewq', 2)");
 245                                 Fail ("test#13");
 246                         } catch (InvalidExpressionException e) {
 247 //                              AssertEquals ("test#14", true, e is InvalidExpressionException);
 248 //                              AssertEquals ("test#15", "Expression 'substring ('fdsafewq', 2)' is invalid.", e.Message);
 249                         }
 250                 }
 251
 252                 [Test]
 253                 public void AddRange ()
 254                 {
 255                         DataTable Table = new DataTable ("test_table");
 256                         DataTable Table2 = new DataTable ("test_table2");
 257                         DataColumnCollection Cols = Table.Columns;
 258                         DataColumn C = null;
 259                         DataColumn [] ColArray = new DataColumn [2];
 260
 261                         C = new DataColumn ("test1");
 262                         ColArray [0] = C;
 263
 264                         C = new DataColumn ("test2");
 265                         C.AllowDBNull = false;
 266                         C.Caption = "Test_caption";
 267                         C.DataType = typeof (XmlReader);
 268                         ColArray [1] = C;
 269
 270                         Cols.AddRange (ColArray);
 271
 272                         C = Cols [0];
 273                         AssertEquals ("test#01", true, C.AllowDBNull);
 274                         AssertEquals ("test#02", false, C.AutoIncrement);
 275                         AssertEquals ("test#03", 0L, C.AutoIncrementSeed);
 276                         AssertEquals ("test#04", 1L, C.AutoIncrementStep);
 277                         AssertEquals ("test#05", "test1", C.Caption);
 278                         AssertEquals ("test#06", "Element", C.ColumnMapping.ToString ());
 279                         AssertEquals ("test#07", "test1", C.ColumnName);
 280                         AssertEquals ("test#08", true, C.Container == null);
 281                         AssertEquals ("test#09", typeof (string), C.DataType);
 282                         AssertEquals ("test#10", DBNull.Value, C.DefaultValue);
 283                         AssertEquals ("test#11", false, C.DesignMode);
 284                         AssertEquals ("test#12", "", C.Expression);
 285                         AssertEquals ("test#13", 0, C.ExtendedProperties.Count);
 286                         AssertEquals ("test#14", -1, C.MaxLength);
 287                         AssertEquals ("test#15", "", C.Namespace);
 288                         AssertEquals ("test#16", 0, C.Ordinal);
 289                         AssertEquals ("test#17", "", C.Prefix);
 290                         AssertEquals ("test#18", false, C.ReadOnly);
 291                         AssertEquals ("test#19", null, C.Site);
 292                         AssertEquals ("test#20", "test_table", C.Table.TableName);
 293                         AssertEquals ("test#21", "test1", C.ToString ());
 294                         AssertEquals ("test#22", false, C.Unique);
 295
 296                         C = Cols [1];
 297                         AssertEquals ("test#01", false, C.AllowDBNull);
 298                         AssertEquals ("test#02", false, C.AutoIncrement);
 299                         AssertEquals ("test#03", 0L, C.AutoIncrementSeed);
 300                         AssertEquals ("test#04", 1L, C.AutoIncrementStep);
 301                         AssertEquals ("test#05", "Test_caption", C.Caption);
 302                         AssertEquals ("test#06", "Element", C.ColumnMapping.ToString ());
 303                         AssertEquals ("test#07", "test2", C.ColumnName);
 304                         AssertEquals ("test#08", true, C.Container == null);
 305                         AssertEquals ("test#09", typeof (XmlReader), C.DataType);
 306                         AssertEquals ("test#10", DBNull.Value, C.DefaultValue);
 307                         AssertEquals ("test#11", false, C.DesignMode);
 308                         AssertEquals ("test#12", "", C.Expression);
 309                         AssertEquals ("test#13", 0, C.ExtendedProperties.Count);
 310                         AssertEquals ("test#14", -1, C.MaxLength);
 311                         AssertEquals ("test#15", "", C.Namespace);
 312                         AssertEquals ("test#16", 1, C.Ordinal);
 313                         AssertEquals ("test#17", "", C.Prefix);
 314                         AssertEquals ("test#18", false, C.ReadOnly);
 315                         AssertEquals ("test#19", null, C.Site);
 316                         AssertEquals ("test#20", "test_table", C.Table.TableName);
 317                         AssertEquals ("test#21", "test2", C.ToString ());
 318                         AssertEquals ("test#22", false, C.Unique);
 319                 }
 320
 321                 [Test]
 322                 public void CanRemove ()
 323                 {
 324                         DataTable Table = new DataTable ("test_table");
 325                         DataTable Table2 = new DataTable ("test_table_2");
 326                         DataColumnCollection Cols = Table.Columns;
 327                         DataColumn C = new DataColumn ("test1");
 328                         Cols.Add ();
 329
 330                         // LAMESPEC: MSDN says that if C doesn't belong to Cols
 331                         // Exception is thrown.
 332                         AssertEquals ("test#01", false, Cols.CanRemove (C));
 333
 334                         Cols.Add (C);
 335                         AssertEquals ("test#02", true, Cols.CanRemove (C));
 336
 337                         C = new DataColumn ();
 338                         C.Expression = "test1 + 2";
 339                         Cols.Add (C);
 340
 341                         C = Cols ["test2"];
 342                         AssertEquals ("test#03", false, Cols.CanRemove (C));
 343
 344                         C = new DataColumn ("t");
 345                         Table2.Columns.Add (C);
 346                         DataColumnCollection Cols2 = Table2.Columns;
 347                         AssertEquals ("test#04", true, Cols2.CanRemove (C));
 348
 349                         DataRelation Rel = new DataRelation ("Rel", Table.Columns [0], Table2.Columns [0]);
 350                         DataSet Set = new DataSet ();
 351                         Set.Tables.Add (Table);
 352                         Set.Tables.Add (Table2);
 353                         Set.Relations.Add (Rel);
 354
 355                         AssertEquals ("test#05", false, Cols2.CanRemove (C));
 356                         AssertEquals ("test#06", false, Cols.CanRemove (null));
 357                 }
 358
 359                 [Test]
 360                 public void Clear ()
 361                 {
 362                         DataTable Table = new DataTable ("test_table");
 363                         DataTable Table2 = new DataTable ("test_table2");
 364                         DataSet Set = new DataSet ();
 365                         Set.Tables.Add (Table);
 366                         Set.Tables.Add (Table2);
 367                         DataColumnCollection Cols = Table.Columns;
 368                         DataColumnCollection Cols2 = Table2.Columns;
 369
 370                         Cols.Add ();
 371                         Cols.Add ("testi");
 372
 373                         Cols.Clear ();
 374                         AssertEquals ("test#01", 0, Cols.Count);
 375
 376                         Cols.Add ();
 377                         Cols.Add ("testi");
 378                         Cols2.Add ();
 379                         Cols2.Add ();
 380
 381                         DataRelation Rel = new DataRelation ("Rel", Cols [0], Cols2 [0]);
 382                         Set.Relations.Add (Rel);
 383                         try {
 384                                 Cols.Clear ();
 385                                 Fail ("test#02");
 386                         } catch (Exception e) {
 387                                 AssertEquals ("test#03", typeof (ArgumentException), e.GetType ());
 388                                 AssertEquals ("test#04", "Cannot remove this column, because it is part of the parent key for relationship Rel.", e.Message);
 389                         }
 390                 }
 391
 392                 [Test]
 393                 public void Contains ()
 394                 {
 395                         DataTable Table = new DataTable ("test_table");
 396                         DataColumnCollection Cols = Table.Columns;
 397
 398                         Cols.Add ("test");
 399                         Cols.Add ("tesT2");
 400
 401                         AssertEquals ("test#01", true, Cols.Contains ("test"));
 402                         AssertEquals ("test#02", false, Cols.Contains ("_test"));
 403                         AssertEquals ("test#03", true, Cols.Contains ("TEST"));
 404                         Table.CaseSensitive = true;
 405                         AssertEquals ("test#04", true, Cols.Contains ("TEST"));
 406                         AssertEquals ("test#05", true, Cols.Contains ("test2"));
 407                         AssertEquals ("test#06", false, Cols.Contains ("_test2"));
 408                         AssertEquals ("test#07", true, Cols.Contains ("TEST2"));
 409                 }
 410
 411                 [Test]
 412                 public void CopyTo ()
 413                 {
 414                         DataTable Table = new DataTable ("test_table");
 415                         DataColumnCollection Cols = Table.Columns;
 416
 417                         Cols.Add ("test");
 418                         Cols.Add ("test2");
 419                         Cols.Add ("test3");
 420                         Cols.Add ("test4");
 421
 422                         DataColumn [] array = new DataColumn [4];
 423                         Cols.CopyTo (array, 0);
 424                         AssertEquals ("test#01", 4, array.Length);
 425                         AssertEquals ("test#02", "test", array [0].ColumnName);
 426                         AssertEquals ("test#03", "test2", array [1].ColumnName);
 427                         AssertEquals ("test#04", "test3", array [2].ColumnName);
 428                         AssertEquals ("test#05", "test4", array [3].ColumnName);
 429
 430                         array = new DataColumn [6];
 431                         Cols.CopyTo (array, 2);
 432                         AssertEquals ("test#06", 6, array.Length);
 433                         AssertEquals ("test#07", "test", array [2].ColumnName);
 434                         AssertEquals ("test#08", "test2", array [3].ColumnName);
 435                         AssertEquals ("test#09", "test3", array [4].ColumnName);
 436                         AssertEquals ("test#10", "test4", array [5].ColumnName);
 437                         AssertEquals ("test#11", null, array [0]);
 438                         AssertEquals ("test#12", null, array [1]);
 439                 }
 440
 441                 [Test]
 442                 public void Equals ()
 443                 {
 444                         DataTable Table = new DataTable ("test_table");
 445                         DataTable Table2 = new DataTable ("test_table");
 446                         DataColumnCollection Cols = Table.Columns;
 447                         DataColumnCollection Cols2 = Table2.Columns;
 448
 449                         AssertEquals ("test#01", false, Cols.Equals (Cols2));
 450                         AssertEquals ("test#02", false, Cols2.Equals (Cols));
 451                         AssertEquals ("test#03", false, Object.Equals (Cols, Cols2));
 452                         AssertEquals ("test#04", true, Cols.Equals (Cols));
 453                         AssertEquals ("test#05", true, Cols2.Equals (Cols2));
 454                         AssertEquals ("test#06", true, Object.Equals (Cols2, Cols2));
 455                 }
 456
 457                 [Test]
 458                 public void IndexOf ()
 459                 {
 460                         DataTable Table = new DataTable ("test_table");
 461                         DataColumnCollection Cols = Table.Columns;
 462
 463                         Cols.Add ("test");
 464                         Cols.Add ("test2");
 465                         Cols.Add ("test3");
 466                         Cols.Add ("test4");
 467
 468                         AssertEquals ("test#01", 0, Cols.IndexOf ("test"));
 469                         AssertEquals ("test#02", 1, Cols.IndexOf ("TEST2"));
 470                         Table.CaseSensitive = true;
 471                         AssertEquals ("test#03", 1, Cols.IndexOf ("TEST2"));
 472
 473                         AssertEquals ("test#04", 3, Cols.IndexOf (Cols [3]));
 474                         DataColumn C = new DataColumn ("error");
 475                         AssertEquals ("test#05", -1, Cols.IndexOf (C));
 476                         AssertEquals ("test#06", -1, Cols.IndexOf ("_error_"));
 477                 }
 478
 479                 [Test]
 480                 public void Remove ()
 481                 {
 482                         DataTable Table = new DataTable ("test_table");
 483                         DataColumnCollection Cols = Table.Columns;
 484
 485                         Cols.Add ("test");
 486                         Cols.Add ("test2");
 487                         Cols.Add ("test3");
 488                         Cols.Add ("test4");
 489
 490                         AssertEquals ("test#01", 4, Cols.Count);
 491                         Cols.Remove ("test2");
 492                         AssertEquals ("test#02", 3, Cols.Count);
 493                         Cols.Remove ("TEST3");
 494                         AssertEquals ("test#03", 2, Cols.Count);
 495
 496                         try {
 497                                 Cols.Remove ("_test_");
 498                                 Fail ("test#04");
 499                         } catch (Exception e) {
 500                                 AssertEquals ("test#05", typeof (ArgumentException), e.GetType ());
 501                                 AssertEquals ("test#06", "Column '_test_' does not belong to table test_table.", e.Message);
 502                         }
 503
 504                         Cols.Add ();
 505                         Cols.Add ();
 506                         Cols.Add ();
 507                         Cols.Add ();
 508
 509                         AssertEquals ("test#07", 6, Cols.Count);
 510                         Cols.Remove (Cols [0]);
 511                         Cols.Remove (Cols [0]);
 512                         AssertEquals ("test#08", 4, Cols.Count);
 513                         AssertEquals ("test#09", "Column1", Cols [0].ColumnName);
 514
 515                         try {
 516                                 Cols.Remove (new DataColumn ("Column10"));
 517                                 Fail ("test#10");
 518                         } catch (Exception e) {
 519                                 AssertEquals ("test#11", typeof (ArgumentException), e.GetType ());
 520                                 AssertEquals ("test#12", "Cannot remove a column that doesn't belong to this table.", e.Message);
 521                         }
 522
 523                         Cols.Add ();
 524                         Cols.Add ();
 525                         Cols.Add ();
 526                         Cols.Add ();
 527
 528                         AssertEquals ("test#13", 8, Cols.Count);
 529                         Cols.RemoveAt (7);
 530                         Cols.RemoveAt (1);
 531                         Cols.RemoveAt (0);
 532                         Cols.RemoveAt (0);
 533                         AssertEquals ("test#14", 4, Cols.Count);
 534                         AssertEquals ("test#15", "Column4", Cols [0].ColumnName);
 535                         AssertEquals ("test#16", "Column5", Cols [1].ColumnName);
 536
 537                         try {
 538                                 Cols.RemoveAt (10);
 539                                 Fail ("test#17");
 540                         } catch (Exception e) {
 541                                 AssertEquals ("test#18", typeof (IndexOutOfRangeException), e.GetType ());
 542                                 AssertEquals ("test#19", "Cannot find column 10.", e.Message);
 543                         }
 544                 }
 545
 546                 [Test]
 547                 public void ToStringTest ()
 548                 {
 549                         DataTable Table = new DataTable ("test_table");
 550                         DataColumnCollection Cols = Table.Columns;
 551
 552                         Cols.Add ("test");
 553                         Cols.Add ("test2");
 554                         Cols.Add ("test3");
 555                         AssertEquals ("test#01", "System.Data.DataColumnCollection", Cols.ToString ());
 556                 }
 557
 558         }
 559 }