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
  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                         Assert.IsTrue (C.AllowDBNull, "test#01");
  74                         Assert.IsFalse (C.AutoIncrement, "test#02");
  75                         Assert.AreEqual (0L, C.AutoIncrementSeed, "test#03");
  76                         Assert.AreEqual (1L, C.AutoIncrementStep, "test#04");
  77                         Assert.AreEqual ("Column1", C.Caption, "test#05");
  78                         Assert.AreEqual ("Element", C.ColumnMapping.ToString (), "test#06");
  79                         Assert.AreEqual ("Column1", C.ColumnName, "test#07");
  80                         Assert.IsNull (C.Container, "test#08");
  81                         Assert.AreEqual (typeof (string), C.DataType, "test#09");
  82                         Assert.AreEqual (DBNull.Value, C.DefaultValue, "test#10");
  83                         Assert.IsFalse (C.DesignMode, "test#11");
  84                         Assert.AreEqual ("", C.Expression, "test#12");
  85                         Assert.AreEqual (0, C.ExtendedProperties.Count, "test#13");
  86                         Assert.AreEqual (-1, C.MaxLength, "test#14");
  87                         Assert.AreEqual ("", C.Namespace, "test#15");
  88                         Assert.AreEqual (0, C.Ordinal, "test#16");
  89                         Assert.AreEqual ("", C.Prefix, "test#17");
  90                         Assert.IsFalse (C.ReadOnly, "test#18");
  91                         Assert.IsNull (C.Site, "test#19");
  92                         Assert.AreEqual ("test_table", C.Table.TableName, "test#20");
  93                         Assert.AreEqual ("Column1", C.ToString (), "test#21");
  94                         Assert.IsFalse (C.Unique, "test#22");
  95
  96                         C = Cols [1];
  97                         Assert.IsTrue (C.AllowDBNull, "test#23");
  98                         Assert.IsFalse (C.AutoIncrement, "test#24");
  99                         Assert.AreEqual (0L, C.AutoIncrementSeed, "test#25");
 100                         Assert.AreEqual (1L, C.AutoIncrementStep, "test#26");
 101                         Assert.AreEqual ("Column2", C.Caption, "test#27");
 102                         Assert.AreEqual ("Element", C.ColumnMapping.ToString (), "test#28");
 103                         Assert.AreEqual ("Column2", C.ColumnName, "test#29");
 104                         Assert.IsNull (C.Container, "test#30");
 105                         Assert.AreEqual (typeof (string), C.DataType, "test#31");
 106                         Assert.AreEqual (DBNull.Value, C.DefaultValue, "test#32");
 107                         Assert.IsFalse (C.DesignMode, "test#33");
 108                         Assert.AreEqual ("", C.Expression, "test#34");
 109                         Assert.AreEqual (0, C.ExtendedProperties.Count, "test#35");
 110                         Assert.AreEqual (-1, C.MaxLength, "test#36");
 111                         Assert.AreEqual ("", C.Namespace, "test#37");
 112                         Assert.AreEqual (1, C.Ordinal, "test#38");
 113                         Assert.AreEqual ("", C.Prefix, "test#39");
 114                         Assert.IsFalse (C.ReadOnly, "test#40");
 115                         Assert.IsNull (C.Site, "test#41");
 116                         Assert.AreEqual ("test_table", C.Table.TableName, "test#42");
 117                         Assert.AreEqual ("Column2", C.ToString (), "test#43");
 118                         Assert.IsFalse (C.Unique, "test#44");
 119
 120                         Cols.Add ("test1", typeof (int), "");
 121                         Cols.Add ("test2", typeof (string), "Column1 + Column2");
 122
 123                         C = Cols [2];
 124                         Assert.IsTrue (C.AllowDBNull, "test#45");
 125                         Assert.IsFalse (C.AutoIncrement, "test#46");
 126                         Assert.AreEqual (0L, C.AutoIncrementSeed, "test#47");
 127                         Assert.AreEqual (1L, C.AutoIncrementStep, "test#48");
 128                         Assert.AreEqual ("test1", C.Caption, "test#49");
 129                         Assert.AreEqual ("Element", C.ColumnMapping.ToString (), "test#50");
 130                         Assert.AreEqual ("test1", C.ColumnName, "test#51");
 131                         Assert.IsNull (C.Container, "test#52");
 132                         Assert.AreEqual (typeof (int), C.DataType, "test#53");
 133                         Assert.AreEqual (DBNull.Value, C.DefaultValue, "test#54");
 134                         Assert.IsFalse (C.DesignMode, "test#55");
 135                         Assert.AreEqual ("", C.Expression, "test#56");
 136                         Assert.AreEqual (0, C.ExtendedProperties.Count, "test#57");
 137                         Assert.AreEqual (-1, C.MaxLength, "test#58");
 138                         Assert.AreEqual ("", C.Namespace, "test#59");
 139                         Assert.AreEqual (2, C.Ordinal, "test#60");
 140                         Assert.AreEqual ("", C.Prefix, "test#61");
 141                         Assert.IsFalse (C.ReadOnly, "test#62");
 142                         Assert.IsNull (C.Site, "test#63");
 143                         Assert.AreEqual ("test_table", C.Table.TableName, "test#64");
 144                         Assert.AreEqual ("test1", C.ToString (), "test#65");
 145                         Assert.IsFalse (C.Unique, "test#66");
 146
 147                         C = Cols [3];
 148                         Assert.IsTrue (C.AllowDBNull, "test#67");
 149                         Assert.IsFalse (C.AutoIncrement, "test#68");
 150                         Assert.AreEqual (0L, C.AutoIncrementSeed, "test#69");
 151                         Assert.AreEqual (1L, C.AutoIncrementStep, "test#70");
 152                         Assert.AreEqual ("test2", C.Caption, "test#71");
 153                         Assert.AreEqual ("Element", C.ColumnMapping.ToString (), "test#72");
 154                         Assert.AreEqual ("test2", C.ColumnName, "test#73");
 155                         Assert.IsNull (C.Container, "test#74");
 156                         Assert.AreEqual (typeof (string), C.DataType, "test#75");
 157                         Assert.AreEqual (DBNull.Value, C.DefaultValue, "test#76");
 158                         Assert.IsFalse (C.DesignMode, "test#77");
 159                         Assert.AreEqual ("Column1 + Column2", C.Expression, "test#78");
 160                         Assert.AreEqual (0, C.ExtendedProperties.Count, "test#79");
 161                         Assert.AreEqual (-1, C.MaxLength, "test#80");
 162                         Assert.AreEqual ("", C.Namespace, "test#81");
 163                         Assert.AreEqual (3, C.Ordinal, "test#82");
 164                         Assert.AreEqual ("", C.Prefix, "test#83");
 165                         Assert.IsTrue (C.ReadOnly, "test#84");
 166                         Assert.IsNull (C.Site, "test#85");
 167                         Assert.AreEqual ("test_table", C.Table.TableName, "test#86");
 168                         Assert.AreEqual ("test2 + Column1 + Column2", C.ToString (), "test#87");
 169                         Assert.IsFalse (C.Unique, "test#88");
 170
 171                         C = new DataColumn ("test3", typeof (int));
 172                         Cols.Add (C);
 173
 174                         C = Cols [4];
 175                         Assert.IsTrue (C.AllowDBNull, "test#89");
 176                         Assert.IsFalse (C.AutoIncrement, "test#90");
 177                         Assert.AreEqual (0L, C.AutoIncrementSeed, "test#91");
 178                         Assert.AreEqual (1L, C.AutoIncrementStep, "test#92");
 179                         Assert.AreEqual ("test3", C.Caption, "test#93");
 180                         Assert.AreEqual ("Element", C.ColumnMapping.ToString (), "test#94");
 181                         Assert.AreEqual ("test3", C.ColumnName, "test#95");
 182                         Assert.IsNull (C.Container, "test#96");
 183                         Assert.AreEqual (typeof (int), C.DataType, "test#97");
 184                         Assert.AreEqual (DBNull.Value, C.DefaultValue, "test#98");
 185                         Assert.IsFalse (C.DesignMode, "test#99");
 186                         Assert.AreEqual ("", C.Expression, "test#100");
 187                         Assert.AreEqual (0, C.ExtendedProperties.Count, "test#101");
 188                         Assert.AreEqual (-1, C.MaxLength, "test#102");
 189                         Assert.AreEqual ("", C.Namespace, "test#103");
 190                         Assert.AreEqual (4, C.Ordinal, "test#104");
 191                         Assert.AreEqual ("", C.Prefix, "test#105");
 192                         Assert.IsFalse (C.ReadOnly, "test#106");
 193                         Assert.IsNull (C.Site, "test#107");
 194                         Assert.AreEqual ("test_table", C.Table.TableName, "test#108");
 195                         Assert.AreEqual ("test3", C.ToString (), "test#109");
 196                         Assert.IsFalse (C.Unique, "test#110");
 197                 }
 198
 199                 [Test] // Add (String)
 200                 public void Add3_ColumnName_Empty ()
 201                 {
 202                         DataTable table = new DataTable ();
 203                         DataColumnCollection cols = table.Columns;
 204                         DataColumn col;
 205
 206                         col = cols.Add (string.Empty);
 207                         Assert.AreEqual (1, cols.Count, "#A1");
 208                         Assert.AreEqual ("Column1", col.ColumnName, "#A2");
 209                         Assert.AreSame (table, col.Table, "#A3");
 210
 211                         col = cols.Add (string.Empty);
 212                         Assert.AreEqual (2, cols.Count, "#B1");
 213                         Assert.AreEqual ("Column2", col.ColumnName, "#B2");
 214                         Assert.AreSame (table, col.Table, "#B3");
 215
 216                         cols.RemoveAt (1);
 217
 218                         col = cols.Add (string.Empty);
 219                         Assert.AreEqual (2, cols.Count, "#C1");
 220                         Assert.AreEqual ("Column2", col.ColumnName, "#C2");
 221                         Assert.AreSame (table, col.Table, "#C3");
 222
 223                         cols.Clear ();
 224
 225                         col = cols.Add (string.Empty);
 226                         Assert.AreEqual (1, cols.Count, "#D1");
 227                         Assert.AreEqual ("Column1", col.ColumnName, "#D2");
 228                         Assert.AreSame (table, col.Table, "#D3");
 229                 }
 230
 231                 [Test] // Add (String)
 232                 public void Add3_ColumnName_Null ()
 233                 {
 234                         DataTable table = new DataTable ();
 235                         DataColumnCollection cols = table.Columns;
 236                         DataColumn col;
 237
 238                         col = cols.Add ((string) null);
 239                         Assert.AreEqual (1, cols.Count, "#A1");
 240                         Assert.AreEqual ("Column1", col.ColumnName, "#A2");
 241                         Assert.AreSame (table, col.Table, "#A3");
 242
 243                         col = cols.Add ((string) null);
 244                         Assert.AreEqual (2, cols.Count, "#B1");
 245                         Assert.AreEqual ("Column2", col.ColumnName, "#B2");
 246                         Assert.AreSame (table, col.Table, "#B3");
 247
 248                         cols.RemoveAt (1);
 249
 250                         col = cols.Add ((string) null);
 251                         Assert.AreEqual (2, cols.Count, "#C1");
 252                         Assert.AreEqual ("Column2", col.ColumnName, "#C2");
 253                         Assert.AreSame (table, col.Table, "#C3");
 254
 255                         cols.Clear ();
 256
 257                         col = cols.Add ((string) null);
 258                         Assert.AreEqual (1, cols.Count, "#D1");
 259                         Assert.AreEqual ("Column1", col.ColumnName, "#D2");
 260                         Assert.AreSame (table, col.Table, "#D3");
 261                 }
 262
 263                 [Test]
 264                 public void AddExceptions ()
 265                 {
 266                         DataTable Table = new DataTable ("test_table");
 267                         DataTable Table2 = new DataTable ("test_table2");
 268                         DataColumnCollection Cols = Table.Columns;
 269                         DataColumn C = null;
 270
 271                         try {
 272                                 Cols.Add (C);
 273                                 Assert.Fail ("test#01");
 274                         } catch (Exception e) {
 275                                 Assert.AreEqual (typeof (ArgumentNullException), e.GetType (), "test#02");
 276                         }
 277
 278                         C = new DataColumn ("test");
 279                         Cols.Add (C);
 280
 281                         try {
 282                                 Cols.Add (C);
 283                                 Assert.Fail ("test#04");
 284                         } catch (ArgumentException e) {
 285 //                              Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#05");
 286 //                              Assert.AreEqual ("Column 'test' already belongs to this or another DataTable.", e.Message, "test#06");
 287                         }
 288
 289                         try {
 290                                 Table2.Columns.Add (C);
 291                                 Assert.Fail ("test#07");
 292                         } catch (ArgumentException e) {
 293 //                              Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#08");
 294 //                              Assert.AreEqual ("Column 'test' already belongs to this or another DataTable.", e.Message, "test#09");
 295                         }
 296
 297                         DataColumn C2 = new DataColumn ("test");
 298
 299                         try {
 300                                 Cols.Add (C2);
 301                                 Assert.Fail ("test#10");
 302                         } catch (DuplicateNameException e) {
 303 //                              Assert.AreEqual (typeof (DuplicateNameException), e.GetType (), "test#11");
 304 //                              Assert.AreEqual ("A DataColumn named 'test' already belongs to this DataTable.", e.Message, "test#12");
 305                         }
 306
 307                         try {
 308                                 Cols.Add ("test2", typeof (string), "substring ('fdsafewq', 2)");
 309                                 Assert.Fail ("test#13");
 310                         } catch (InvalidExpressionException e) {
 311 //                              Assert.IsTrue (e is InvalidExpressionException, "test#14");
 312 //                              Assert.AreEqual ("Expression 'substring ('fdsafewq', 2)' is invalid.", e.Message, "test#15");
 313                         }
 314                 }
 315
 316                 [Test]
 317                 public void AddRange ()
 318                 {
 319                         DataTable Table = new DataTable ("test_table");
 320                         DataTable Table2 = new DataTable ("test_table2");
 321                         DataColumnCollection Cols = Table.Columns;
 322                         DataColumn C = null;
 323                         DataColumn [] ColArray = new DataColumn [2];
 324
 325                         C = new DataColumn ("test1");
 326                         ColArray [0] = C;
 327
 328                         C = new DataColumn ("test2");
 329                         C.AllowDBNull = false;
 330                         C.Caption = "Test_caption";
 331                         C.DataType = typeof (XmlReader);
 332                         ColArray [1] = C;
 333
 334                         Cols.AddRange (ColArray);
 335
 336                         C = Cols [0];
 337                         Assert.IsTrue (C.AllowDBNull, "test#01");
 338                         Assert.IsFalse (C.AutoIncrement, "test#02");
 339                         Assert.AreEqual (0L, C.AutoIncrementSeed, "test#03");
 340                         Assert.AreEqual (1L, C.AutoIncrementStep, "test#04");
 341                         Assert.AreEqual ("test1", C.Caption, "test#05");
 342                         Assert.AreEqual ("Element", C.ColumnMapping.ToString (), "test#06");
 343                         Assert.AreEqual ("test1", C.ColumnName, "test#07");
 344                         Assert.IsNull (C.Container, "test#08");
 345                         Assert.AreEqual (typeof (string), C.DataType, "test#09");
 346                         Assert.AreEqual (DBNull.Value, C.DefaultValue, "test#10");
 347                         Assert.IsFalse (C.DesignMode, "test#11");
 348                         Assert.AreEqual ("", C.Expression, "test#12");
 349                         Assert.AreEqual (0, C.ExtendedProperties.Count, "test#13");
 350                         Assert.AreEqual (-1, C.MaxLength, "test#14");
 351                         Assert.AreEqual ("", C.Namespace, "test#15");
 352                         Assert.AreEqual (0, C.Ordinal, "test#16");
 353                         Assert.AreEqual ("", C.Prefix, "test#17");
 354                         Assert.IsFalse (C.ReadOnly, "test#18");
 355                         Assert.IsNull (C.Site, "test#19");
 356                         Assert.AreEqual ("test_table", C.Table.TableName, "test#20");
 357                         Assert.AreEqual ("test1", C.ToString (), "test#21");
 358                         Assert.IsFalse (C.Unique, "test#22");
 359
 360                         C = Cols [1];
 361                         Assert.IsFalse (C.AllowDBNull, "test#01");
 362                         Assert.IsFalse (C.AutoIncrement, "test#02");
 363                         Assert.AreEqual (0L, C.AutoIncrementSeed, "test#03");
 364                         Assert.AreEqual (1L, C.AutoIncrementStep, "test#04");
 365                         Assert.AreEqual ("Test_caption", C.Caption, "test#05");
 366                         Assert.AreEqual ("Element", C.ColumnMapping.ToString (), "test#06");
 367                         Assert.AreEqual ("test2", C.ColumnName, "test#07");
 368                         Assert.IsNull (C.Container, "test#08");
 369                         Assert.AreEqual (typeof (XmlReader), C.DataType, "test#09");
 370                         Assert.AreEqual (DBNull.Value, C.DefaultValue, "test#10");
 371                         Assert.IsFalse (C.DesignMode, "test#11");
 372                         Assert.AreEqual ("", C.Expression, "test#12");
 373                         Assert.AreEqual (0, C.ExtendedProperties.Count, "test#13");
 374                         Assert.AreEqual (-1, C.MaxLength, "test#14");
 375                         Assert.AreEqual ("", C.Namespace, "test#15");
 376                         Assert.AreEqual (1, C.Ordinal, "test#16");
 377                         Assert.AreEqual ("", C.Prefix, "test#17");
 378                         Assert.IsFalse (C.ReadOnly, "test#18");
 379                         Assert.IsNull (C.Site, "test#19");
 380                         Assert.AreEqual ("test_table", C.Table.TableName, "test#20");
 381                         Assert.AreEqual ("test2", C.ToString (), "test#21");
 382                         Assert.IsFalse (C.Unique, "test#22");
 383                 }
 384
 385                 [Test]
 386                 public void CanRemove ()
 387                 {
 388                         DataTable Table = new DataTable ("test_table");
 389                         DataTable Table2 = new DataTable ("test_table_2");
 390                         DataColumnCollection Cols = Table.Columns;
 391                         DataColumn C = new DataColumn ("test1");
 392                         Cols.Add ();
 393
 394                         // LAMESPEC: MSDN says that if C doesn't belong to Cols
 395                         // Exception is thrown.
 396                         Assert.IsFalse (Cols.CanRemove (C), "test#01");
 397
 398                         Cols.Add (C);
 399                         Assert.IsTrue (Cols.CanRemove (C), "test#02");
 400
 401                         C = new DataColumn ();
 402                         C.Expression = "test1 + 2";
 403                         Cols.Add (C);
 404
 405                         C = Cols ["test2"];
 406                         Assert.IsFalse (Cols.CanRemove (C), "test#03");
 407
 408                         C = new DataColumn ("t");
 409                         Table2.Columns.Add (C);
 410                         DataColumnCollection Cols2 = Table2.Columns;
 411                         Assert.IsTrue (Cols2.CanRemove (C), "test#04");
 412
 413                         DataSet Set = new DataSet ();
 414                         Set.Tables.Add (Table);
 415                         Set.Tables.Add (Table2);
 416                         DataRelation Rel = new DataRelation ("Rel", Table.Columns [0], Table2.Columns [0]);
 417                         Set.Relations.Add (Rel);
 418
 419                         Assert.IsFalse (Cols2.CanRemove (C), "test#05");
 420                         Assert.IsFalse (Cols.CanRemove (null), "test#06");
 421                 }
 422
 423                 [Test]
 424                 public void Clear ()
 425                 {
 426                         DataTable Table = new DataTable ("test_table");
 427                         DataTable Table2 = new DataTable ("test_table2");
 428                         DataSet Set = new DataSet ();
 429                         Set.Tables.Add (Table);
 430                         Set.Tables.Add (Table2);
 431                         DataColumnCollection Cols = Table.Columns;
 432                         DataColumnCollection Cols2 = Table2.Columns;
 433
 434                         Cols.Add ();
 435                         Cols.Add ("testi");
 436
 437                         Cols.Clear ();
 438                         Assert.AreEqual (0, Cols.Count, "test#01");
 439
 440                         Cols.Add ();
 441                         Cols.Add ("testi");
 442                         Cols2.Add ();
 443                         Cols2.Add ();
 444
 445                         DataRelation Rel = new DataRelation ("Rel", Cols [0], Cols2 [0]);
 446                         Set.Relations.Add (Rel);
 447                         try {
 448                                 Cols.Clear ();
 449                                 Assert.Fail ("test#02");
 450                         } catch (Exception e) {
 451                                 Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#03");
 452                                 // Never premise English.
 453                                 //Assert.AreEqual ("Cannot remove this column, because it is part of the parent key for relationship Rel.", e.Message, "test#04");
 454                         }
 455                 }
 456
 457                 [Test]
 458                 public void Clear_ExpressionColumn ()
 459                 {
 460                         DataTable table = new DataTable ("test");
 461                         table.Columns.Add ("col1", typeof(int));
 462                         table.Columns.Add ("col2", typeof (int), "sum(col1)");
 463
 464                         //shudnt throw an exception.
 465                         table.Columns.Clear ();
 466                         Assert.AreEqual (0, table.Columns.Count, "#1");
 467                 }
 468
 469                 [Test]
 470                 public void Contains ()
 471                 {
 472                         DataTable Table = new DataTable ("test_table");
 473                         DataColumnCollection Cols = Table.Columns;
 474
 475                         Cols.Add ("test");
 476                         Cols.Add ("tesT2");
 477
 478                         Assert.IsTrue (Cols.Contains ("test"), "test#01");
 479                         Assert.IsFalse (Cols.Contains ("_test"), "test#02");
 480                         Assert.IsTrue (Cols.Contains ("TEST"), "test#03");
 481                         Table.CaseSensitive = true;
 482                         Assert.IsTrue (Cols.Contains ("TEST"), "test#04");
 483                         Assert.IsTrue (Cols.Contains ("test2"), "test#05");
 484                         Assert.IsFalse (Cols.Contains ("_test2"), "test#06");
 485                         Assert.IsTrue (Cols.Contains ("TEST2"), "test#07");
 486                 }
 487
 488                 [Test]
 489                 public void CopyTo ()
 490                 {
 491                         DataTable Table = new DataTable ("test_table");
 492                         DataColumnCollection Cols = Table.Columns;
 493
 494                         Cols.Add ("test");
 495                         Cols.Add ("test2");
 496                         Cols.Add ("test3");
 497                         Cols.Add ("test4");
 498
 499                         DataColumn [] array = new DataColumn [4];
 500                         Cols.CopyTo (array, 0);
 501                         Assert.AreEqual (4, array.Length, "test#01");
 502                         Assert.AreEqual ("test", array [0].ColumnName, "test#02");
 503                         Assert.AreEqual ("test2", array [1].ColumnName, "test#03");
 504                         Assert.AreEqual ("test3", array [2].ColumnName, "test#04");
 505                         Assert.AreEqual ("test4", array [3].ColumnName, "test#05");
 506
 507                         array = new DataColumn [6];
 508                         Cols.CopyTo (array, 2);
 509                         Assert.AreEqual (6, array.Length, "test#06");
 510                         Assert.AreEqual ("test", array [2].ColumnName, "test#07");
 511                         Assert.AreEqual ("test2", array [3].ColumnName, "test#08");
 512                         Assert.AreEqual ("test3", array [4].ColumnName, "test#09");
 513                         Assert.AreEqual ("test4", array [5].ColumnName, "test#10");
 514                         Assert.IsNull (array [0], "test#11");
 515                         Assert.IsNull (array [1], "test#12");
 516                 }
 517
 518                 [Test]
 519                 public void Equals ()
 520                 {
 521                         DataTable Table = new DataTable ("test_table");
 522                         DataTable Table2 = new DataTable ("test_table");
 523                         DataColumnCollection Cols = Table.Columns;
 524                         DataColumnCollection Cols2 = Table2.Columns;
 525
 526                         Assert.IsFalse (Cols.Equals (Cols2), "test#01");
 527                         Assert.IsFalse (Cols2.Equals (Cols), "test#02");
 528                         Assert.IsFalse (Object.Equals (Cols, Cols2), "test#03");
 529                         Assert.IsTrue (Cols.Equals (Cols), "test#04");
 530                         Assert.IsTrue (Cols2.Equals (Cols2), "test#05");
 531                         Assert.IsTrue (Object.Equals (Cols2, Cols2), "test#06");
 532                 }
 533
 534                 [Test]
 535                 public void IndexOf ()
 536                 {
 537                         DataTable Table = new DataTable ("test_table");
 538                         DataColumnCollection Cols = Table.Columns;
 539
 540                         Cols.Add ("test");
 541                         Cols.Add ("test2");
 542                         Cols.Add ("test3");
 543                         Cols.Add ("test4");
 544
 545                         Assert.AreEqual (0, Cols.IndexOf ("test"), "test#01");
 546                         Assert.AreEqual (1, Cols.IndexOf ("TEST2"), "test#02");
 547                         Table.CaseSensitive = true;
 548                         Assert.AreEqual (1, Cols.IndexOf ("TEST2"), "test#03");
 549
 550                         Assert.AreEqual (3, Cols.IndexOf (Cols [3]), "test#04");
 551                         DataColumn C = new DataColumn ("error");
 552                         Assert.AreEqual (-1, Cols.IndexOf (C), "test#05");
 553                         Assert.AreEqual (-1, Cols.IndexOf ("_error_"), "test#06");
 554                 }
 555
 556                 [Test]
 557                 public void Remove ()
 558                 {
 559                         DataTable Table = new DataTable ("test_table");
 560                         DataColumnCollection Cols = Table.Columns;
 561
 562                         Cols.Add ("test");
 563                         Cols.Add ("test2");
 564                         Cols.Add ("test3");
 565                         Cols.Add ("test4");
 566
 567                         Assert.AreEqual (4, Cols.Count, "test#01");
 568                         Cols.Remove ("test2");
 569                         Assert.AreEqual (3, Cols.Count, "test#02");
 570                         Cols.Remove ("TEST3");
 571                         Assert.AreEqual (2, Cols.Count, "test#03");
 572
 573                         try {
 574                                 Cols.Remove ("_test_");
 575                                 Assert.Fail ("test#04");
 576                         } catch (Exception e) {
 577                                 Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#05");
 578                                 // Never premise English.
 579                                 //Assert.AreEqual ("Column '_test_' does not belong to table test_table.", e.Message, "test#06");
 580                         }
 581
 582                         Cols.Add ();
 583                         Cols.Add ();
 584                         Cols.Add ();
 585                         Cols.Add ();
 586
 587                         Assert.AreEqual (6, Cols.Count, "test#07");
 588                         Cols.Remove (Cols [0]);
 589                         Cols.Remove (Cols [0]);
 590                         Assert.AreEqual (4, Cols.Count, "test#08");
 591                         Assert.AreEqual ("Column1", Cols [0].ColumnName, "test#09");
 592
 593                         try {
 594                                 Cols.Remove (new DataColumn ("Column10"));
 595                                 Assert.Fail ("test#10");
 596                         } catch (Exception e) {
 597                                 Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#11");
 598                                 // Never premise English.
 599                                 //Assert.AreEqual ("Cannot remove a column that doesn't belong to this table.", e.Message, "test#12");
 600                         }
 601
 602                         Cols.Add ();
 603                         Cols.Add ();
 604                         Cols.Add ();
 605                         Cols.Add ();
 606
 607                         Assert.AreEqual (8, Cols.Count, "test#13");
 608                         Cols.RemoveAt (7);
 609                         Cols.RemoveAt (1);
 610                         Cols.RemoveAt (0);
 611                         Cols.RemoveAt (0);
 612                         Assert.AreEqual (4, Cols.Count, "test#14");
 613                         Assert.AreEqual ("Column4", Cols [0].ColumnName, "test#15");
 614                         Assert.AreEqual ("Column5", Cols [1].ColumnName, "test#16");
 615
 616                         try {
 617                                 Cols.RemoveAt (10);
 618                                 Assert.Fail ("test#17");
 619                         } catch (Exception e) {
 620                                 Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (), "test#18");
 621                                 // Never premise English.
 622                                 //Assert.AreEqual ("Cannot find column 10.", e.Message, "test#19");
 623                         }
 624                 }
 625
 626                 [Test]
 627                 [ExpectedException (typeof (ArgumentException))]
 628                 public void Remove_Dep_Rel_Col ()
 629                 {
 630                         DataSet ds = new DataSet ();
 631                         ds.Tables.Add ("test");
 632                         ds.Tables.Add ("test1");
 633                         ds.Tables[0].Columns.Add ("col1", typeof(int));
 634                         ds.Tables[1].Columns.Add ("col2", typeof(int));
 635
 636                         ds.Relations.Add ("rel1",  ds.Tables[0].Columns[0], ds.Tables[1].Columns[0]);
 637                         ds.Tables[0].Columns.RemoveAt (0);
 638                 }
 639
 640                 [Test]
 641                 public void ToStringTest ()
 642                 {
 643                         DataTable Table = new DataTable ("test_table");
 644                         DataColumnCollection Cols = Table.Columns;
 645
 646                         Cols.Add ("test");
 647                         Cols.Add ("test2");
 648                         Cols.Add ("test3");
 649                         Assert.AreEqual ("System.Data.DataColumnCollection", Cols.ToString (), "test#01");
 650                 }
 651
 652                 [Test]
 653                 public void CaseSensitiveIndexOfTest ()
 654                 {
 655                         DataTable dt = new DataTable ("TestCaseSensitiveIndexOf");
 656                         dt.Columns.Add ("nom_colonne1", typeof (string));
 657                         dt.Columns.Add ("NOM_COLONNE1", typeof (string));
 658                         dt.Columns.Remove ("nom_colonne1");
 659                         int i=dt.Columns.IndexOf ("nom_colonne1");
 660                         Assert.AreEqual (0, dt.Columns.IndexOf ("nom_colonne1"));
 661                 }
 662         }
 663 }