mcs/class/System.Data/Test/System.Data.Common/DataColumnMappingCollectionTest.cs

   1 // DataColumnMappingCollectionTest.cs - NUnit Test Cases for Testing the
   2 // DataColumnMappingCollection class
   3 //
   4 // Author: Ameya Sailesh Gargesh (ameya_13@yahoo.com)
   5 //
   6 // (C) Ameya Gargesh
   7
   8 //
   9 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30
  31
  32 using NUnit.Framework;
  33 using System;
  34 using System.Data;
  35 using System.Data.Common;
  36 namespace MonoTests.System.Data.Common
  37 {
  38         [TestFixture]
  39         public class DataColumnMappingCollectionTest
  40         {
  41                 //DataTableMapping tableMap;
  42                 DataColumnMappingCollection columnMapCollection;
  43                 DataColumnMapping [] cols;
  44
  45                 [SetUp]
  46                 public void GetReady()
  47                 {
  48                         cols=new DataColumnMapping[5];
  49                         cols[0]=new DataColumnMapping("sourceName", "dataSetName");
  50                         cols[1]=new DataColumnMapping("sourceID", "dataSetID");
  51                         cols[2]=new DataColumnMapping("sourceAddress", "dataSetAddress");
  52                         cols[3]=new DataColumnMapping("sourcePhone", "dataSetPhone");
  53                         cols[4]=new DataColumnMapping("sourcePIN", "dataSetPIN");
  54                         columnMapCollection=new DataColumnMappingCollection();
  55                 }
  56
  57                 [TearDown]
  58                 public void Clean()
  59                 {
  60                         columnMapCollection.Clear();
  61                 }
  62
  63                 [Test]
  64                 public void Add()
  65                 {
  66                         DataColumnMapping col1=new DataColumnMapping("sourceName", "dataSetName");
  67                         int t=columnMapCollection.Add((Object)col1);
  68                         Assert.AreEqual (0, t, "test1");
  69                         bool eq1=col1.Equals(columnMapCollection[0]);
  70                         Assert.AreEqual (true, eq1, "test2");
  71                         Assert.AreEqual (1, columnMapCollection.Count, "test3");
  72                         DataColumnMapping col2;
  73                         col2=columnMapCollection.Add("sourceID", "dataSetID");
  74                         bool eq2=col2.Equals(columnMapCollection[1]);
  75                         Assert.AreEqual (true, eq2, "test4");
  76                         Assert.AreEqual (2, columnMapCollection.Count, "test5");
  77                 }
  78
  79                 [Test]
  80                 [ExpectedException(typeof(InvalidCastException))]
  81                 public void AddException1()
  82                 {
  83                         DataColumnMappingCollection c=new DataColumnMappingCollection();
  84                         columnMapCollection.Add((Object)c);
  85                 }
  86
  87                 [Test]
  88                 public void AddRange()
  89                 {
  90                         columnMapCollection.Add(new DataColumnMapping("sourceAge", "dataSetAge"));
  91                         Assert.AreEqual (1, columnMapCollection.Count, "test1");
  92                         columnMapCollection.AddRange(cols);
  93                         Assert.AreEqual (6, columnMapCollection.Count, "test2");
  94                         bool eq;
  95                         eq=cols[0].Equals(columnMapCollection[1]);
  96                         Assert.AreEqual (true, eq, "test3");
  97                         eq=cols[1].Equals(columnMapCollection[2]);
  98                         Assert.AreEqual (true, eq, "test4");
  99
 100                         eq=cols[0].Equals(columnMapCollection[0]);
 101                         Assert.AreEqual (false, eq, "test5");
 102                         eq=cols[1].Equals(columnMapCollection[0]);
 103                         Assert.AreEqual (false, eq, "test6");
 104                 }
 105
 106                 [Test]
 107                 public void Clear()
 108                 {
 109                         DataColumnMapping col1=new DataColumnMapping("sourceName", "dataSetName");
 110                         columnMapCollection.Add((Object)col1);
 111                         Assert.AreEqual (1, columnMapCollection.Count, "test1");
 112                         columnMapCollection.Clear();
 113                         Assert.AreEqual (0, columnMapCollection.Count, "test2");
 114                         columnMapCollection.AddRange(cols);
 115                         Assert.AreEqual (5, columnMapCollection.Count, "test3");
 116                         columnMapCollection.Clear();
 117                         Assert.AreEqual (0, columnMapCollection.Count, "test4");
 118                 }
 119
 120                 [Test]
 121                 public void Contains()
 122                 {
 123                         DataColumnMapping col1=new DataColumnMapping("sourceName", "dataSetName");
 124                         columnMapCollection.AddRange(cols);
 125                         bool eq;
 126                         eq=columnMapCollection.Contains((Object)cols[0]);
 127                         Assert.AreEqual (true, eq, "test1");
 128                         eq=columnMapCollection.Contains((Object)cols[1]);
 129                         Assert.AreEqual (true, eq, "test2");
 130
 131                         eq=columnMapCollection.Contains((Object)col1);
 132                         Assert.AreEqual (false, eq, "test3");
 133
 134                         eq=columnMapCollection.Contains(cols[0].SourceColumn);
 135                         Assert.AreEqual (true, eq, "test4");
 136                         eq=columnMapCollection.Contains(cols[1].SourceColumn);
 137                         Assert.AreEqual (true, eq, "test5");
 138
 139                         eq=columnMapCollection.Contains(col1.SourceColumn);
 140                         Assert.AreEqual (true, eq, "test6");
 141
 142                         eq=columnMapCollection.Contains(cols[0].DataSetColumn);
 143                         Assert.AreEqual (false, eq, "test7");
 144                         eq=columnMapCollection.Contains(cols[1].DataSetColumn);
 145                         Assert.AreEqual (false, eq, "test8");
 146
 147                         eq=columnMapCollection.Contains(col1.DataSetColumn);
 148                         Assert.AreEqual (false, eq, "test9");
 149                 }
 150
 151                 [Test]
 152                 [ExpectedException(typeof(InvalidCastException))]
 153                 public void ContainsException1()
 154                 {
 155                         Object o = new Object();
 156                         bool a = columnMapCollection.Contains(o);
 157                 }
 158
 159                 [Test]
 160                 public void CopyTo()
 161                 {
 162                         DataColumnMapping [] colcops=new DataColumnMapping[5];
 163                         columnMapCollection.AddRange(cols);
 164                         columnMapCollection.CopyTo(colcops, 0);
 165                         bool eq;
 166                         for (int i=0;i<5;i++)
 167                         {
 168                                 eq=columnMapCollection[i].Equals(colcops[i]);
 169                                 Assert.AreEqual (true, eq, "test1" + i);
 170                         }
 171                         colcops=null;
 172                         colcops=new DataColumnMapping[7];
 173                         columnMapCollection.CopyTo(colcops, 2);
 174                         for (int i=0;i<5;i++)
 175                         {
 176                                 eq=columnMapCollection[i].Equals(colcops[i+2]);
 177                                 Assert.AreEqual (true, eq, "test2" + i);
 178                         }
 179                         eq=columnMapCollection[0].Equals(colcops[0]);
 180                         Assert.AreEqual (false, eq, "test31");
 181                         eq=columnMapCollection[0].Equals(colcops[1]);
 182                         Assert.AreEqual (false, eq, "test32");
 183                 }
 184
 185                 [Test]
 186                 public void Equals()
 187                 {
 188 //                      DataColumnMappingCollection collect2=new DataColumnMappingCollection();
 189                         columnMapCollection.AddRange(cols);
 190 //                      collect2.AddRange(cols);
 191                         DataColumnMappingCollection copy1;
 192                         copy1=columnMapCollection;
 193
 194 //                      Assert.AreEqual (false, columnMapCollection.Equals(collect2), "test1");
 195                         Assert.AreEqual (true, columnMapCollection.Equals(copy1), "test2");
 196 //                      Assert.AreEqual (false, collect2.Equals(columnMapCollection), "test3");
 197                         Assert.AreEqual (true, copy1.Equals(columnMapCollection), "test4");
 198 //                      Assert.AreEqual (false, collect2.Equals(copy1), "test5");
 199                         Assert.AreEqual (true, copy1.Equals(columnMapCollection), "test6");
 200                         Assert.AreEqual (true, columnMapCollection.Equals(columnMapCollection), "test7");
 201 //                      Assert.AreEqual (true, collect2.Equals(collect2), "test8");
 202                         Assert.AreEqual (true, copy1.Equals(copy1), "test9");
 203
 204 //                      Assert.AreEqual (false, Object.Equals(collect2, columnMapCollection), "test10");
 205                         Assert.AreEqual (true, Object.Equals(copy1, columnMapCollection), "test11");
 206 //                      Assert.AreEqual (false, Object.Equals(columnMapCollection, collect2), "test12");
 207                         Assert.AreEqual (true, Object.Equals(columnMapCollection, copy1), "test13");
 208 //                      Assert.AreEqual (false, Object.Equals(copy1, collect2), "test14");
 209                         Assert.AreEqual (true, Object.Equals(columnMapCollection, copy1), "test15");
 210                         Assert.AreEqual (true, Object.Equals(columnMapCollection, columnMapCollection), "test16");
 211 //                      Assert.AreEqual (true, Object.Equals(collect2, collect2), "test17");
 212                         Assert.AreEqual (true, Object.Equals(copy1, copy1), "test18");
 213 //                      Assert.AreEqual (false, Object.Equals(columnMapCollection, collect2), "test10");
 214                         Assert.AreEqual (true, Object.Equals(columnMapCollection, copy1), "test11");
 215 //                      Assert.AreEqual (false, Object.Equals(collect2, columnMapCollection), "test12");
 216                         Assert.AreEqual (true, Object.Equals(copy1, columnMapCollection), "test13");
 217 //                      Assert.AreEqual (false, Object.Equals(collect2, copy1), "test14");
 218                         Assert.AreEqual (true, Object.Equals(copy1, columnMapCollection), "test15");
 219                 }
 220
 221                 [Test]
 222                 public void GetByDataSetColumn()
 223                 {
 224                         columnMapCollection.AddRange(cols);
 225                         bool eq;
 226                         DataColumnMapping col1;
 227                         col1=columnMapCollection.GetByDataSetColumn("dataSetName");
 228                         eq=(col1.DataSetColumn.Equals("dataSetName") && col1.SourceColumn.Equals("sourceName"));
 229                         Assert.AreEqual (true, eq, "test1");
 230                         col1=columnMapCollection.GetByDataSetColumn("dataSetID");
 231                         eq=(col1.DataSetColumn.Equals("dataSetID") && col1.SourceColumn.Equals("sourceID"));
 232                         Assert.AreEqual (true, eq, "test2");
 233
 234                         col1=columnMapCollection.GetByDataSetColumn("datasetname");
 235                         eq=(col1.DataSetColumn.Equals("dataSetName") && col1.SourceColumn.Equals("sourceName"));
 236                         Assert.AreEqual (true, eq, "test3");
 237                         col1=columnMapCollection.GetByDataSetColumn("datasetid");
 238                         eq=(col1.DataSetColumn.Equals("dataSetID") && col1.SourceColumn.Equals("sourceID"));
 239                         Assert.AreEqual (true, eq, "test4");
 240                 }
 241
 242                 [Test]
 243                 public void GetColumnMappingBySchemaAction()
 244                 {
 245                         columnMapCollection.AddRange(cols);
 246                         bool eq;
 247                         DataColumnMapping col1;
 248                         col1=DataColumnMappingCollection.GetColumnMappingBySchemaAction(columnMapCollection, "sourceName", MissingMappingAction.Passthrough);
 249                         eq=(col1.DataSetColumn.Equals("dataSetName") && col1.SourceColumn.Equals("sourceName"));
 250                         Assert.AreEqual (true, eq, "test1");
 251                         col1=DataColumnMappingCollection.GetColumnMappingBySchemaAction(columnMapCollection, "sourceID", MissingMappingAction.Passthrough);
 252                         eq=(col1.DataSetColumn.Equals("dataSetID") && col1.SourceColumn.Equals("sourceID"));
 253                         Assert.AreEqual (true, eq, "test2");
 254
 255                         col1=DataColumnMappingCollection.GetColumnMappingBySchemaAction(columnMapCollection, "sourceData", MissingMappingAction.Passthrough);
 256                         eq=(col1.DataSetColumn.Equals("sourceData") && col1.SourceColumn.Equals("sourceData"));
 257                         Assert.AreEqual (true, eq, "test3");
 258                         eq=columnMapCollection.Contains(col1);
 259                         Assert.AreEqual (false, eq, "test4");
 260                         col1=DataColumnMappingCollection.GetColumnMappingBySchemaAction(columnMapCollection, "sourceData", MissingMappingAction.Ignore);
 261                         Assert.AreEqual (null, col1, "test5");
 262                 }
 263
 264                 [Test]
 265                 [ExpectedException(typeof(InvalidOperationException))]
 266                 public void GetColumnMappingBySchemaActionException1()
 267                 {
 268                         DataColumnMappingCollection.GetColumnMappingBySchemaAction(columnMapCollection, "sourceName", MissingMappingAction.Error);
 269                 }
 270
 271                 [Test]
 272                 public void IndexOf()
 273                 {
 274                         columnMapCollection.AddRange(cols);
 275                         int ind;
 276                         ind=columnMapCollection.IndexOf(cols[0]);
 277                         Assert.AreEqual (0, ind, "test1");
 278                         ind=columnMapCollection.IndexOf(cols[1]);
 279                         Assert.AreEqual (1, ind, "test2");
 280
 281                         ind=columnMapCollection.IndexOf(cols[0].SourceColumn);
 282                         Assert.AreEqual (0, ind, "test3");
 283                         ind=columnMapCollection.IndexOf(cols[1].SourceColumn);
 284                         Assert.AreEqual (1, ind, "test4");
 285                 }
 286
 287                 [Test]
 288                 public void IndexOfDataSetColumn()
 289                 {
 290                         columnMapCollection.AddRange(cols);
 291                         int ind;
 292                         ind=columnMapCollection.IndexOfDataSetColumn(cols[0].DataSetColumn);
 293                         Assert.AreEqual (0, ind, "test1");
 294                         ind=columnMapCollection.IndexOfDataSetColumn(cols[1].DataSetColumn);
 295                         Assert.AreEqual (1, ind, "test2");
 296
 297                         ind=columnMapCollection.IndexOfDataSetColumn("datasetname");
 298                         Assert.AreEqual (0, ind, "test3");
 299                         ind=columnMapCollection.IndexOfDataSetColumn("datasetid");
 300                         Assert.AreEqual (1, ind, "test4");
 301
 302                         ind=columnMapCollection.IndexOfDataSetColumn("sourcedeter");
 303                         Assert.AreEqual (-1, ind, "test5");
 304                 }
 305
 306                 [Test]
 307                 public void Insert()
 308                 {
 309                         columnMapCollection.AddRange(cols);
 310                         DataColumnMapping mymap=new DataColumnMapping("sourceAge", "dataSetAge");
 311                         columnMapCollection.Insert(3, mymap);
 312                         int ind=columnMapCollection.IndexOfDataSetColumn("dataSetAge");
 313                         Assert.AreEqual (3, ind, "test1");
 314                 }
 315
 316                 [Test]
 317                 [Ignore ("This test is wrong. A mapping in a DataColumnMappingCollection must be identical.")]
 318                 public void Remove()
 319                 {
 320                         columnMapCollection.AddRange(cols);
 321                         DataColumnMapping mymap=new DataColumnMapping("sourceName", "dataSetName");
 322                         columnMapCollection.Add(mymap);
 323                         columnMapCollection.Remove((Object)mymap);
 324                         bool eq=columnMapCollection.Contains((Object)mymap);
 325                         Assert.AreEqual (false, eq, "test1");
 326                 }
 327
 328                 [Test]
 329                 [ExpectedException(typeof(InvalidCastException))]
 330                 public void RemoveException1()
 331                 {
 332                         String te="testingdata";
 333                         columnMapCollection.AddRange(cols);
 334                         columnMapCollection.Remove(te);
 335                 }
 336
 337                 [Test]
 338                 [ExpectedException(typeof(ArgumentException))]
 339                 public void RemoveException2()
 340                 {
 341                         columnMapCollection.AddRange(cols);
 342                         DataColumnMapping mymap=new DataColumnMapping("sourceAge", "dataSetAge");
 343                         columnMapCollection.Remove(mymap);
 344                 }
 345
 346                 [Test]
 347                 public void RemoveAt()
 348                 {
 349                         columnMapCollection.AddRange(cols);
 350                         bool eq;
 351                         columnMapCollection.RemoveAt(0);
 352                         eq=columnMapCollection.Contains(cols[0]);
 353                         Assert.AreEqual (false, eq, "test1");
 354                         eq=columnMapCollection.Contains(cols[1]);
 355                         Assert.AreEqual (true, eq, "test2");
 356
 357                         columnMapCollection.RemoveAt("sourceID");
 358                         eq=columnMapCollection.Contains(cols[1]);
 359                         Assert.AreEqual (false, eq, "test3");
 360                         eq=columnMapCollection.Contains(cols[2]);
 361                         Assert.AreEqual (true, eq, "test4");
 362                 }
 363
 364                 [Test]
 365                 [ExpectedException(typeof(IndexOutOfRangeException))]
 366                 public void RemoveAtException1()
 367                 {
 368                         columnMapCollection.RemoveAt(3);
 369                 }
 370
 371                 [Test]
 372                 [ExpectedException(typeof(IndexOutOfRangeException))]
 373                 public void RemoveAtException2()
 374                 {
 375                         columnMapCollection.RemoveAt("sourceAge");
 376                 }
 377
 378                 [Test]
 379 #if TARGET_JVM
 380                 [Ignore ("Does not work with TARGET_JVM")]
 381 #endif
 382                 public void ToStringTest()
 383                 {
 384                         Assert.AreEqual ("System.Data.Common.DataColumnMappingCollection", columnMapCollection.ToString(), "test1");
 385                 }
 386         }
 387 }