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

   1 // DataTableMappingCollectionTest.cs - NUnit Test Cases for Testing the
   2 // DataTableMappingCollection class
   3 //
   4 // Author: Ameya Sailesh Gargesh (ameya_13@yahoo.com)
   5 //
   6 // (C) Ameya Gargesh
   7 // (C) Novell Inc.
   8
   9 using NUnit.Framework;
  10 using System;
  11 using System.Data;
  12 using System.Data.Common;
  13 namespace MonoTests.System.Data.Common
  14 {
  15         [TestFixture]
  16         public class DataTableMappingCollectionTest : Assertion
  17         {
  18                 DataTableMappingCollection tableMapCollection;
  19                 DataTableMapping [] tabs;
  20                 [SetUp]
  21                 public void GetReady()
  22                 {
  23                         tabs=new DataTableMapping[5];
  24                         tabs[0]=new DataTableMapping("sourceCustomers","dataSetCustomers");
  25                         tabs[1]=new DataTableMapping("sourceEmployees","dataSetEmployees");
  26                         tabs[2]=new DataTableMapping("sourceBooks","dataSetBooks");
  27                         tabs[3]=new DataTableMapping("sourceStore","dataSetStore");
  28                         tabs[4]=new DataTableMapping("sourceInventory","dataSetInventory");
  29                         tableMapCollection=new DataTableMappingCollection();
  30                 }
  31
  32                 [TearDown]
  33                 public void Clean()
  34                 {
  35                         tableMapCollection.Clear();
  36                 }
  37
  38                 [Test]
  39                 public void Add()
  40                 {
  41                         int t=tableMapCollection.Add((Object)tabs[0]);
  42                         AssertEquals("test1",0,t);
  43                         bool eq1=tabs[0].Equals(tableMapCollection[0]);
  44                         AssertEquals("test2",true,eq1);
  45                         AssertEquals("test3",1,tableMapCollection.Count);
  46                         DataTableMapping tab2;
  47                         tab2=tableMapCollection.Add("sourceEmployees","dataSetEmployees");
  48                         bool eq2=tab2.Equals(tableMapCollection[1]);
  49                         AssertEquals("test4",true,eq2);
  50                         AssertEquals("test5",2,tableMapCollection.Count);
  51                 }
  52
  53                 [Test]
  54                 [ExpectedException(typeof(InvalidCastException))]
  55                 public void AddException1()
  56                 {
  57                         DataTableMappingCollection c=new DataTableMappingCollection();
  58                         tableMapCollection.Add((Object)c);
  59                 }
  60
  61                 [Test]
  62                 public void AddRange()
  63                 {
  64                         tableMapCollection.Add(new DataTableMapping("sourceFactory","dataSetFactory"));
  65                         AssertEquals("test1",1,tableMapCollection.Count);
  66                         tableMapCollection.AddRange(tabs);
  67                         AssertEquals("test2",6,tableMapCollection.Count);
  68                         bool eq;
  69                         eq=tabs[0].Equals(tableMapCollection[1]);
  70                         AssertEquals("test3",true,eq);
  71                         eq=tabs[1].Equals(tableMapCollection[2]);
  72                         AssertEquals("test4",true,eq);
  73                         eq=tabs[0].Equals(tableMapCollection[0]);
  74                         AssertEquals("test5",false,eq);
  75                         eq=tabs[1].Equals(tableMapCollection[0]);
  76                         AssertEquals("test6",false,eq);
  77                 }
  78
  79                 [Test]
  80                 public void Clear()
  81                 {
  82                         DataTableMapping tab1=new DataTableMapping("sourceSuppliers","dataSetSuppliers");
  83                         tableMapCollection.Add((Object)tab1);
  84                         AssertEquals("test1",1,tableMapCollection.Count);
  85                         tableMapCollection.Clear();
  86                         AssertEquals("test2",0,tableMapCollection.Count);
  87                         tableMapCollection.AddRange(tabs);
  88                         AssertEquals("test3",5,tableMapCollection.Count);
  89                         tableMapCollection.Clear();
  90                         AssertEquals("test4",0,tableMapCollection.Count);
  91                 }
  92
  93                 [Test]
  94                 public void Contains()
  95                 {
  96                         DataTableMapping tab1=new DataTableMapping("sourceCustomers","dataSetCustomers");
  97                         tableMapCollection.AddRange(tabs);
  98                         bool eq;
  99                         eq=tableMapCollection.Contains((Object)tabs[0]);
 100                         AssertEquals("test1",true,eq);
 101                         eq=tableMapCollection.Contains((Object)tabs[1]);
 102                         AssertEquals("test2",true,eq);
 103                         eq=tableMapCollection.Contains((Object)tab1);
 104                         AssertEquals("test3",false,eq);
 105                         eq=tableMapCollection.Contains(tabs[0].SourceTable);
 106                         AssertEquals("test4",true,eq);
 107                         eq=tableMapCollection.Contains(tabs[1].SourceTable);
 108                         AssertEquals("test5",true,eq);
 109                         eq=tableMapCollection.Contains(tab1.SourceTable);
 110                         AssertEquals("test6",true,eq);
 111                         eq=tableMapCollection.Contains(tabs[0].DataSetTable);
 112                         AssertEquals("test7",false,eq);
 113                         eq=tableMapCollection.Contains(tabs[1].DataSetTable);
 114                         AssertEquals("test8",false,eq);
 115                         eq=tableMapCollection.Contains(tab1.DataSetTable);
 116                         AssertEquals("test9",false,eq);
 117                 }
 118
 119                 [Test]
 120                 public void CopyTo()
 121                 {
 122                         DataTableMapping [] tabcops=new DataTableMapping[5];
 123                         tableMapCollection.AddRange(tabs);
 124                         tableMapCollection.CopyTo(tabcops,0);
 125                         bool eq;
 126                         for (int i=0;i<5;i++)
 127                         {
 128                                 eq=tableMapCollection[i].Equals(tabcops[i]);
 129                                 AssertEquals("test1"+i,true,eq);
 130                         }
 131                         tabcops=null;
 132                         tabcops=new DataTableMapping[7];
 133                         tableMapCollection.CopyTo(tabcops,2);
 134                         for (int i=0;i<5;i++)
 135                         {
 136                                 eq=tableMapCollection[i].Equals(tabcops[i+2]);
 137                                 AssertEquals("test2"+i,true,eq);
 138                         }
 139                         eq=tableMapCollection[0].Equals(tabcops[0]);
 140                         AssertEquals("test31",false,eq);
 141                         eq=tableMapCollection[0].Equals(tabcops[1]);
 142                         AssertEquals("test32",false,eq);
 143                 }
 144
 145                 [Test]
 146                 public void Equals()
 147                 {
 148                         DataTableMappingCollection collect2=new DataTableMappingCollection();
 149                         tableMapCollection.AddRange(tabs);
 150                         collect2.AddRange(tabs);
 151                         DataTableMappingCollection copy1;
 152                         copy1=tableMapCollection;
 153
 154                         AssertEquals("test1",false,tableMapCollection.Equals(collect2));
 155                         AssertEquals("test2",true,tableMapCollection.Equals(copy1));
 156                         AssertEquals("test3",false,collect2.Equals(tableMapCollection));
 157                         AssertEquals("test4",true,copy1.Equals(tableMapCollection));
 158                         AssertEquals("test5",false,collect2.Equals(copy1));
 159                         AssertEquals("test6",true,copy1.Equals(tableMapCollection));
 160                         AssertEquals("test7",true,tableMapCollection.Equals(tableMapCollection));
 161                         AssertEquals("test8",true,collect2.Equals(collect2));
 162                         AssertEquals("test9",true,copy1.Equals(copy1));
 163
 164                         AssertEquals("test10",false,Object.Equals(collect2,tableMapCollection));
 165                         AssertEquals("test11",true,Object.Equals(copy1,tableMapCollection));
 166                         AssertEquals("test12",false,Object.Equals(tableMapCollection,collect2));
 167                         AssertEquals("test13",true,Object.Equals(tableMapCollection,copy1));
 168                         AssertEquals("test14",false,Object.Equals(copy1,collect2));
 169                         AssertEquals("test15",true,Object.Equals(tableMapCollection,copy1));
 170                         AssertEquals("test16",true,Object.Equals(tableMapCollection,tableMapCollection));
 171                         AssertEquals("test17",true,Object.Equals(collect2,collect2));
 172                         AssertEquals("test18",true,Object.Equals(copy1,copy1));
 173                         AssertEquals("test10",false,Object.Equals(tableMapCollection,collect2));
 174                         AssertEquals("test11",true,Object.Equals(tableMapCollection,copy1));
 175                         AssertEquals("test12",false,Object.Equals(collect2,tableMapCollection));
 176                         AssertEquals("test13",true,Object.Equals(copy1,tableMapCollection));
 177                         AssertEquals("test14",false,Object.Equals(collect2,copy1));
 178                         AssertEquals("test15",true,Object.Equals(copy1,tableMapCollection));
 179                 }
 180
 181                 [Test]
 182                 public void GetByDataSetTable()
 183                 {
 184                         tableMapCollection.AddRange(tabs);
 185                         bool eq;
 186                         DataTableMapping tab1;
 187                         tab1=tableMapCollection.GetByDataSetTable("dataSetCustomers");
 188                         eq=(tab1.DataSetTable.Equals("dataSetCustomers") && tab1.SourceTable.Equals("sourceCustomers"));
 189                         AssertEquals("test1",true,eq);
 190                         tab1=tableMapCollection.GetByDataSetTable("dataSetEmployees");
 191                         eq=(tab1.DataSetTable.Equals("dataSetEmployees") && tab1.SourceTable.Equals("sourceEmployees"));
 192                         AssertEquals("test2",true,eq);
 193
 194                         tab1=tableMapCollection.GetByDataSetTable("datasetcustomers");
 195                         eq=(tab1.DataSetTable.Equals("dataSetCustomers") && tab1.SourceTable.Equals("sourceCustomers"));
 196                         AssertEquals("test3",true,eq);
 197                         tab1=tableMapCollection.GetByDataSetTable("datasetemployees");
 198                         eq=(tab1.DataSetTable.Equals("dataSetEmployees") && tab1.SourceTable.Equals("sourceEmployees"));
 199                         AssertEquals("test4",true,eq);
 200
 201                 }
 202
 203                 [Test]
 204                 public void GetTableMappingBySchemaAction()
 205                 {
 206                         tableMapCollection.AddRange(tabs);
 207                         bool eq;
 208                         DataTableMapping tab1;
 209                         tab1=DataTableMappingCollection.GetTableMappingBySchemaAction(tableMapCollection,"sourceCustomers","dataSetCustomers",MissingMappingAction.Passthrough);
 210                         eq=(tab1.DataSetTable.Equals("dataSetCustomers") && tab1.SourceTable.Equals("sourceCustomers"));
 211                         AssertEquals("test1",true,eq);
 212                         tab1=DataTableMappingCollection.GetTableMappingBySchemaAction(tableMapCollection,"sourceEmployees","dataSetEmployees",MissingMappingAction.Passthrough);
 213                         eq=(tab1.DataSetTable.Equals("dataSetEmployees") && tab1.SourceTable.Equals("sourceEmployees"));
 214                         AssertEquals("test2",true,eq);
 215
 216                         tab1=DataTableMappingCollection.GetTableMappingBySchemaAction(tableMapCollection,"sourceData","dataSetData",MissingMappingAction.Passthrough);
 217                         eq=(tab1.DataSetTable.Equals("sourceData") && tab1.SourceTable.Equals("dataSetData"));
 218                         AssertEquals("test3",true,eq);
 219                         eq=tableMapCollection.Contains(tab1);
 220                         AssertEquals("test4",false,eq);
 221                         tab1=DataTableMappingCollection.GetTableMappingBySchemaAction(tableMapCollection,"sourceData","dataSetData",MissingMappingAction.Ignore);
 222                         AssertEquals("test5",null,tab1);
 223                 }
 224
 225                 [Test]
 226                 [ExpectedException(typeof(InvalidOperationException))]
 227                 public void GetTableMappingBySchemaActionException1()
 228                 {
 229                         DataTableMappingCollection.GetTableMappingBySchemaAction(tableMapCollection,"sourceCustomers","dataSetCustomers",MissingMappingAction.Error);
 230                 }
 231
 232                 [Test]
 233                 public void IndexOf()
 234                 {
 235                         tableMapCollection.AddRange(tabs);
 236                         int ind;
 237                         ind=tableMapCollection.IndexOf(tabs[0]);
 238                         AssertEquals("test1",0,ind);
 239                         ind=tableMapCollection.IndexOf(tabs[1]);
 240                         AssertEquals("test2",1,ind);
 241
 242                         ind=tableMapCollection.IndexOf(tabs[0].SourceTable);
 243                         AssertEquals("test3",0,ind);
 244                         ind=tableMapCollection.IndexOf(tabs[1].SourceTable);
 245                         AssertEquals("test4",1,ind);
 246                 }
 247
 248                 [Test]
 249                 public void IndexOfDataSetTable()
 250                 {
 251                         tableMapCollection.AddRange(tabs);
 252                         int ind;
 253                         ind=tableMapCollection.IndexOfDataSetTable(tabs[0].DataSetTable);
 254                         AssertEquals("test1",0,ind);
 255                         ind=tableMapCollection.IndexOfDataSetTable(tabs[1].DataSetTable);
 256                         AssertEquals("test2",1,ind);
 257
 258                         ind=tableMapCollection.IndexOfDataSetTable("datasetcustomers");
 259                         AssertEquals("test3",0,ind);
 260                         ind=tableMapCollection.IndexOfDataSetTable("datasetemployees");
 261                         AssertEquals("test4",1,ind);
 262
 263                         ind=tableMapCollection.IndexOfDataSetTable("sourcedeter");
 264                         AssertEquals("test5",-1,ind);
 265                 }
 266
 267                 [Test]
 268                 public void Insert()
 269                 {
 270                         tableMapCollection.AddRange(tabs);
 271                         DataTableMapping mymap=new DataTableMapping("sourceTestAge","datatestSetAge");
 272                         tableMapCollection.Insert(3,mymap);
 273                         int ind=tableMapCollection.IndexOfDataSetTable("datatestSetAge");
 274                         AssertEquals("test1",3,ind);
 275                 }
 276
 277                 [Test]
 278                 public void Remove()
 279                 {
 280                         tableMapCollection.AddRange(tabs);
 281                         DataTableMapping mymap=new DataTableMapping("sourceCustomers","dataSetCustomers");
 282                         tableMapCollection.Add(mymap);
 283                         tableMapCollection.Remove((Object)mymap);
 284                         bool eq=tableMapCollection.Contains((Object)mymap);
 285                         AssertEquals("test1",false,eq);
 286                 }
 287
 288                 [Test]
 289                 [ExpectedException(typeof(InvalidCastException))]
 290                 public void RemoveException1()
 291                 {
 292                         String te="testingdata";
 293                         tableMapCollection.AddRange(tabs);
 294                         tableMapCollection.Remove(te);
 295                 }
 296
 297                 [Test]
 298                 [ExpectedException(typeof(ArgumentException))]
 299                 public void RemoveException2()
 300                 {
 301                         tableMapCollection.AddRange(tabs);
 302                         DataTableMapping mymap=new DataTableMapping("sourceAge","dataSetAge");
 303                         tableMapCollection.Remove(mymap);
 304                 }
 305
 306                 [Test]
 307                 public void RemoveAt()
 308                 {
 309                         tableMapCollection.AddRange(tabs);
 310                         bool eq;
 311                         tableMapCollection.RemoveAt(0);
 312                         eq=tableMapCollection.Contains(tabs[0]);
 313                         AssertEquals("test1",false,eq);
 314                         eq=tableMapCollection.Contains(tabs[1]);
 315                         AssertEquals("test2",true,eq);
 316
 317                         tableMapCollection.RemoveAt("sourceEmployees");
 318                         eq=tableMapCollection.Contains(tabs[1]);
 319                         AssertEquals("test3",false,eq);
 320                         eq=tableMapCollection.Contains(tabs[2]);
 321                         AssertEquals("test4",true,eq);
 322                 }
 323
 324                 [Test]
 325                 [ExpectedException(typeof(IndexOutOfRangeException))]
 326                 public void RemoveAtException1()
 327                 {
 328                         tableMapCollection.RemoveAt(3);
 329                 }
 330
 331                 [Test]
 332                 [ExpectedException(typeof(IndexOutOfRangeException))]
 333                 public void RemoveAtException2()
 334                 {
 335                         tableMapCollection.RemoveAt("sourceAge");
 336                 }
 337
 338                 [Test]
 339                 public void ToStringTest()
 340                 {
 341                         AssertEquals("test1","System.Data.Common.DataTableMappingCollection",tableMapCollection.ToString());
 342                 }
 343         }
 344 }