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

   1 // Authors:
   2 //   Rafael Mizrahi   <rafim@mainsoft.com>
   3 //   Erez Lotan       <erezl@mainsoft.com>
   4 //   Oren Gurfinkel   <oreng@mainsoft.com>
   5 //   Ofer Borstein
   6 //
   7 // Copyright (c) 2004 Mainsoft Co.
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using NUnit.Framework;
  30 using System;
  31 using System.ComponentModel;
  32 using System.Collections;
  33 using System.Data;
  34 using MonoTests.System.Data.Utils;
  35
  36 namespace MonoTests.System.Data
  37 {
  38         [TestFixture] public class DataRelationCollectionTest2
  39         {
  40                 private int changesCounter = 0;
  41
  42                 private void Relations_CollectionChanged(object sender, CollectionChangeEventArgs e)
  43                 {
  44                         changesCounter++;
  45                 }
  46
  47                 private DataSet getDataSet()
  48                 {
  49                         DataSet ds = new DataSet();
  50                         DataTable dt1 = DataProvider.CreateParentDataTable();
  51                         DataTable dt2 = DataProvider.CreateChildDataTable();
  52
  53                         ds.Tables.Add(dt1);
  54                         ds.Tables.Add(dt2);
  55                         return ds;
  56                 }
  57
  58                 [SetUp]
  59                 public void SetUp()
  60                 {
  61                         changesCounter = 0;
  62                 }
  63
  64                 [Test] public void AddRange()
  65                 {
  66                         DataSet ds = getDataSet();
  67                         DataRelation[] relArray = new DataRelation[2];
  68
  69                         relArray[0] = new DataRelation("rel1",ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]);
  70                         relArray[1] = new DataRelation("rel2",ds.Tables[0].Columns["String1"],ds.Tables[1].Columns["String1"]);
  71
  72                         ds.Relations.AddRange(relArray);
  73
  74                         Assert.AreEqual(2, ds.Relations.Count, "DRC1");
  75                         Assert.AreEqual("rel1", ds.Relations[0].RelationName, "DRC2");
  76                         Assert.AreEqual("rel2", ds.Relations[1].RelationName, "DRC3");
  77
  78                         ds.Relations.AddRange(null);
  79                 }
  80
  81                 [Test] public void Add_ByDataColumns()
  82                 {
  83                         DataSet ds = getDataSet();
  84                         ds.Relations.Add(ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]);
  85
  86                         Assert.AreEqual(1, ds.Relations.Count, "DRC4");
  87
  88                         Assert.AreEqual(1, ds.Tables[0].ChildRelations.Count, "DRC5"); //When adding a relation,it's also added on the tables
  89                         Assert.AreEqual(1, ds.Tables[1].ParentRelations.Count, "DRC6");
  90
  91                         Assert.AreEqual(typeof(UniqueConstraint), ds.Tables[0].Constraints[0].GetType(), "DRC7");
  92                         Assert.AreEqual(typeof(ForeignKeyConstraint), ds.Tables[1].Constraints[0].GetType(), "DRC8");
  93                 }
  94
  95                 [Test] public void Add_ByNameDataColumns()
  96                 {
  97                         DataSet ds = getDataSet();
  98                         ds.Relations.Add("rel1",ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]);
  99
 100                         Assert.AreEqual(1, ds.Relations.Count, "DRC9");
 101
 102                         Assert.AreEqual(1, ds.Tables[0].ChildRelations.Count, "DRC10"); //When adding a relation,it's also added on the tables
 103                         Assert.AreEqual(1, ds.Tables[1].ParentRelations.Count, "DRC11");
 104
 105                         Assert.AreEqual(typeof(UniqueConstraint), ds.Tables[0].Constraints[0].GetType(), "DRC12");
 106                         Assert.AreEqual(typeof(ForeignKeyConstraint), ds.Tables[1].Constraints[0].GetType(), "DRC13");
 107
 108                         Assert.AreEqual("rel1", ds.Relations[0].RelationName, "DRC14");
 109                         Assert.AreEqual("rel1", ds.Tables[0].ChildRelations[0].RelationName, "DRC15");
 110                         Assert.AreEqual("rel1", ds.Tables[1].ParentRelations[0].RelationName, "DRC16");
 111                 }
 112
 113                 [Test] public void Add_ByNameDataColumnsWithConstraint()
 114                 {
 115                         DataSet ds = getDataSet();
 116                         ds.Relations.Add("rel1",ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"],true);
 117
 118                         Assert.AreEqual(1, ds.Relations.Count, "DRC17");
 119
 120                         Assert.AreEqual(1, ds.Tables[0].ChildRelations.Count, "DRC18"); //When adding a relation,it's also added on the tables
 121                         Assert.AreEqual(1, ds.Tables[1].ParentRelations.Count, "DRC19");
 122
 123                         Assert.AreEqual(typeof(UniqueConstraint), ds.Tables[0].Constraints[0].GetType(), "DRC20");
 124                         Assert.AreEqual(typeof(ForeignKeyConstraint), ds.Tables[1].Constraints[0].GetType(), "DRC21");
 125
 126                         Assert.AreEqual("rel1", ds.Relations[0].RelationName, "DRC22");
 127                         Assert.AreEqual("rel1", ds.Tables[0].ChildRelations[0].RelationName, "DRC23");
 128                         Assert.AreEqual("rel1", ds.Tables[1].ParentRelations[0].RelationName, "DRC24");
 129                 }
 130                 [Test] public void Add_ByNameDataColumnsWithOutConstraint()
 131                 {
 132                         DataSet ds = getDataSet();
 133                         ds.Relations.Add("rel1",ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"],false);
 134
 135                         Assert.AreEqual(1, ds.Relations.Count, "DRC25");
 136
 137                         Assert.AreEqual(1, ds.Tables[0].ChildRelations.Count, "DRC26"); //When adding a relation,it's also added on the tables
 138                         Assert.AreEqual(1, ds.Tables[1].ParentRelations.Count, "DRC27");
 139
 140                         Assert.AreEqual(0, ds.Tables[0].Constraints.Count, "DRC28");
 141                         Assert.AreEqual(0, ds.Tables[1].Constraints.Count, "DRC29");
 142
 143                         Assert.AreEqual("rel1", ds.Relations[0].RelationName, "DRC30");
 144                         Assert.AreEqual("rel1", ds.Tables[0].ChildRelations[0].RelationName, "DRC31");
 145                         Assert.AreEqual("rel1", ds.Tables[1].ParentRelations[0].RelationName, "DRC32");
 146                 }
 147
 148                 [Test] public void CanRemove()
 149                 {
 150                         DataSet ds = getDataSet();
 151                         ds.Relations.Add(ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]);
 152                         Assert.AreEqual(true, ds.Relations.CanRemove(ds.Relations[0]), "DRC33");
 153                         Assert.AreEqual(true, ds.Tables[0].ChildRelations.CanRemove(ds.Tables[0].ChildRelations[0]), "DRC34");
 154                         Assert.AreEqual(true, ds.Tables[1].ParentRelations.CanRemove(ds.Tables[1].ParentRelations[0]), "DRC35");
 155                         Assert.AreEqual(false, ds.Relations.CanRemove(null), "DRC36");
 156                 }
 157                 [Test] public void CanRemove_DataRelation()
 158                 {
 159                         DataSet ds = getDataSet();
 160                         DataSet ds1 = getDataSet();
 161
 162                         DataRelation rel = new DataRelation("rel1",
 163                                 ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]);
 164
 165                         Assert.AreEqual(false, ds1.Relations.CanRemove(rel), "DRC37");
 166                 }
 167
 168                 [Test] public void Clear()
 169                 {
 170                         DataSet ds = getDataSet();
 171
 172                         ds.Relations.Add(ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]);
 173                         ds.Relations.CollectionChanged+=new CollectionChangeEventHandler(Relations_CollectionChanged);
 174                         ds.Relations.Clear();
 175                         Assert.AreEqual(0, ds.Relations.Count, "DRC38");
 176                         Assert.AreEqual(1, changesCounter, "DRC39");
 177                 }
 178
 179                 /// <summary>
 180                 /// Clear was already checked at the clear sub test
 181                 /// </summary>
 182                 [Test] public void CollectionChanged()
 183                 {
 184                         DataSet ds = getDataSet();
 185
 186                         ds.Relations.CollectionChanged+=new CollectionChangeEventHandler(Relations_CollectionChanged);
 187
 188                         DataRelation rel = new DataRelation("rel1",ds.Tables[0].Columns["ParentId"]
 189                                 ,ds.Tables[1].Columns["ParentId"]);
 190
 191                         ds.Relations.Add(rel);
 192
 193                         ds.Relations.Remove(rel);
 194
 195                         Assert.AreEqual(2, changesCounter, "DRC40");
 196                 }
 197
 198                 [Test] public void Contains()
 199                 {
 200                         DataSet ds = getDataSet();
 201                         ds.Relations.Add("rel1",ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]);
 202
 203                         Assert.AreEqual(true, ds.Relations.Contains("rel1"), "DRC41");
 204                         Assert.AreEqual(false, ds.Relations.Contains("RelL"), "DRC42");
 205                         Assert.AreEqual(false, ds.Relations.Contains("rel2"), "DRC43");
 206                 }
 207
 208                 [Test] public void CopyTo()
 209                 {
 210                         DataSet ds = getDataSet();
 211
 212                         DataRelation[] dataRelArray = new DataRelation[2];
 213
 214                         ds.Relations.Add(new DataRelation("rel1",ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]));
 215
 216                         ds.Relations.CopyTo(dataRelArray,1);
 217
 218                         Assert.AreEqual("rel1", dataRelArray[1].RelationName, "DRC44");
 219
 220                         ds.Relations.CopyTo(dataRelArray,0);
 221
 222                         Assert.AreEqual("rel1", dataRelArray[0].RelationName, "DRC45");
 223                 }
 224
 225                 [Test] public void Count()
 226                 {
 227                         DataSet ds = getDataSet();
 228                         Assert.AreEqual(0, ds.Relations.Count, "DRC46");
 229                         ds.Relations.Add("rel1",ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]);
 230                         Assert.AreEqual(1, ds.Relations.Count, "DRC47");
 231                         ds.Relations.Add("rel2",ds.Tables[0].Columns["String1"],ds.Tables[1].Columns["String1"]);
 232                         Assert.AreEqual(2, ds.Relations.Count, "DRC48");
 233                         ds.Relations.Remove("rel2");
 234                         Assert.AreEqual(1, ds.Relations.Count, "DRC49");
 235                         ds.Relations.Remove("rel1");
 236                         Assert.AreEqual(0, ds.Relations.Count, "DRC50");
 237                 }
 238
 239                 [Test] public void GetEnumerator()
 240                 {
 241                         DataSet ds = getDataSet();
 242                         int counter=0;
 243                         ds.Relations.Add("rel1",ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]);
 244                         ds.Relations.Add("rel2",ds.Tables[0].Columns["String1"],ds.Tables[1].Columns["String1"]);
 245
 246                         IEnumerator myEnumerator =  ds.Relations.GetEnumerator();
 247
 248                         while (myEnumerator.MoveNext())
 249                         {
 250                                 counter++;
 251                                 Assert.AreEqual("rel",  ((DataRelation)myEnumerator.Current).RelationName.Substring(0,3), "DRC51");
 252                         }
 253                         Assert.AreEqual(2, counter, "DRC52");
 254                 }
 255
 256                 [Test] public void IndexOf_ByDataRelation()
 257                 {
 258                         DataSet ds = getDataSet();
 259                         DataSet ds1 = getDataSet();
 260
 261                         DataRelation rel1 = new DataRelation("rel1",ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]);
 262                         DataRelation rel2 = new DataRelation("rel2",ds.Tables[0].Columns["String1"],ds.Tables[1].Columns["String1"]);
 263                         DataRelation rel3 = new DataRelation("rel3",ds1.Tables[0].Columns["ParentId"],ds1.Tables[1].Columns["ParentId"]);
 264
 265                         ds.Relations.Add(rel1);
 266                         ds.Relations.Add(rel2);
 267
 268                         Assert.AreEqual(1, ds.Relations.IndexOf(rel2), "DRC53");
 269                         Assert.AreEqual(0, ds.Relations.IndexOf(rel1), "DRC54");
 270                         Assert.AreEqual(-1, ds.Relations.IndexOf((DataRelation)null), "DRC55");
 271                         Assert.AreEqual(-1, ds.Relations.IndexOf(rel3), "DRC56");
 272                 }
 273
 274                 [Test] public void IndexOf_ByDataRelationName()
 275                 {
 276                         DataSet ds = getDataSet();
 277                         DataSet ds1 = getDataSet();
 278
 279                         DataRelation rel1 = new DataRelation("rel1",ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]);
 280                         DataRelation rel2 = new DataRelation("rel2",ds.Tables[0].Columns["String1"],ds.Tables[1].Columns["String1"]);
 281                         DataRelation rel3 = new DataRelation("rel3",ds1.Tables[0].Columns["ParentId"],ds1.Tables[1].Columns["ParentId"]);
 282
 283                         ds.Relations.Add(rel1);
 284                         ds.Relations.Add(rel2);
 285
 286                         Assert.AreEqual(1, ds.Relations.IndexOf("rel2"), "DRC57");
 287                         Assert.AreEqual(0, ds.Relations.IndexOf("rel1"), "DRC58");
 288                         Assert.AreEqual(-1, ds.Relations.IndexOf((string)null), "DRC59");
 289                         Assert.AreEqual(-1, ds.Relations.IndexOf("rel3"), "DRC60");
 290                 }
 291
 292                 [Test] public void Item()
 293                 {
 294                         DataSet ds = getDataSet();
 295                         DataRelation rel1 = new DataRelation("rel1",ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]);
 296                         DataRelation rel2 = new DataRelation("rel2",ds.Tables[0].Columns["String1"],ds.Tables[1].Columns["String1"]);
 297
 298                         ds.Relations.Add(rel1);
 299                         ds.Relations.Add(rel2);
 300
 301                         Assert.AreEqual("rel1", ds.Relations["rel1"].RelationName, "DRC61");
 302                         Assert.AreEqual("rel2", ds.Relations["rel2"].RelationName, "DRC62");
 303                         Assert.AreEqual("rel1", ds.Relations[0].RelationName, "DRC63");
 304                         Assert.AreEqual("rel2", ds.Relations[1].RelationName, "DRC64");
 305                 }
 306
 307                 [Test]
 308                 public void Add_DataColumn1()\r
 309                 {\r
 310                         DataSet ds = DataProvider.CreateForigenConstraint();\r
 311                         int originalRelationsCount = ds.Relations.Count;\r
 312 \r
 313                         DataRelation rel = new DataRelation("rel1",ds.Tables[0].Columns["ParentId"]\r
 314                                 ,ds.Tables[1].Columns["ParentId"]);\r
 315 \r
 316                         ds.Relations.Add(rel);\r
 317 \r
 318                         Assert.AreEqual(originalRelationsCount+1,ds.Relations.Count,"DRC70");\r
 319                         \r
 320                         Assert.AreEqual(1,ds.Tables[0].ChildRelations.Count,"DRC71"); //When adding a relation,it's also added on the tables\r
 321                         Assert.AreEqual(1,ds.Tables[1].ParentRelations.Count,"DRC72");\r
 322 \r
 323                         Assert.AreEqual(typeof(UniqueConstraint),ds.Tables[0].Constraints[0].GetType(),"DRC73");\r
 324                         Assert.AreEqual(typeof(ForeignKeyConstraint),ds.Tables[1].Constraints[0].GetType(),"DRC74"); \r
 325 \r
 326                         try\r
 327                         {\r
 328                                 ds.Relations.Add(rel);\r
 329                                 Assert.Fail("DR75: Add failed to throw ArgumentException");\r
 330                         }\r
 331                         catch (ArgumentException) {}\r
 332                         catch (AssertionException exc) {throw  exc;}\r
 333                         catch (Exception exc)\r
 334                         {\r
 335                                 Assert.Fail("DR76: Add. Wrong exception type. Got:" + exc);\r
 336                         }\r
 337                         \r
 338                         ds.Relations.Add(null);                 \r
 339                 }\r
 340 \r
 341                 [Test]
 342                 public void Add_DataColumn2()\r
 343                 {\r
 344                         DataSet ds = GetDataSet();\r
 345                         DataTable dt1 = ds.Tables[0];\r
 346                         DataTable dt2 = ds.Tables[1];\r
 347 \r
 348                         dt1.ChildRelations.Add(new DataRelation("rel1",dt1.Columns["ParentId"],dt2.Columns["ParentId"]));\r
 349 \r
 350                         Assert.AreEqual(1,dt1.ChildRelations.Count,"DRC77"); \r
 351                         Assert.AreEqual(1,dt2.ParentRelations.Count,"DRC78");\r
 352                         Assert.AreEqual(1,ds.Relations.Count,"DRC79"); //When adding relationship,it's also added on the dataset\r
 353                 }\r
 354 \r
 355                 [Test]
 356                 public void Add_DataColumn3()\r
 357                 {\r
 358                         DataSet ds = GetDataSet();\r
 359 \r
 360                         ds.Tables[1].ParentRelations.Add(new DataRelation("rel1",ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]));\r
 361 \r
 362                         Assert.AreEqual(1,ds.Tables[0].ChildRelations.Count,"DRC80"); \r
 363                         Assert.AreEqual(1,ds.Tables[1].ParentRelations.Count,"DRC81");\r
 364                         Assert.AreEqual(1,ds.Relations.Count,"DRC82");\r
 365                 }\r
 366 \r
 367                 [Test]
 368                 public void Add_DataColumn4()\r
 369                 {\r
 370                         DataSet ds = GetDataSet();\r
 371                         DataTable dt = new DataTable();\r
 372                         dt.Columns.Add("ParentId");\r
 373                         try\r
 374                         {\r
 375                                 ds.Relations.Add(new DataRelation("rel1",dt.Columns[0],ds.Tables[0].Columns[0]));\r
 376                                 Assert.Fail("DRC82: Add failed to throw InvalidConstraintException");\r
 377                         }\r
 378                         catch (InvalidConstraintException) {}\r
 379                         catch (AssertionException exc) {throw  exc;}\r
 380                         catch (Exception exc)\r
 381                         {\r
 382                                 Assert.Fail("DRC83: Add. Wrong exception type. Got:" + exc);\r
 383                         }\r
 384                 }\r
 385 \r
 386                 [Test]
 387                 public void Add_DataColumn5()\r
 388                 {\r
 389                         DataSet ds = GetDataSet();\r
 390                 }\r
 391 \r
 392                 private DataSet GetDataSet()\r
 393                 {\r
 394                         DataSet ds = new DataSet();\r
 395                         DataTable dt1 = DataProvider.CreateParentDataTable();\r
 396                         DataTable dt2 = DataProvider.CreateChildDataTable();\r
 397 \r
 398                         ds.Tables.Add(dt1);\r
 399                         ds.Tables.Add(dt2);\r
 400                         return ds;\r
 401                 }
 402
 403                 [Test]
 404                 public void Remove_DataColumn()\r
 405                 {\r
 406                         DataSet ds = getDataSet();\r
 407                         DataSet ds1 = getDataSet();\r
 408                         DataRelation rel1 = new DataRelation("rel1",ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]); \r
 409                         DataRelation rel2 = new DataRelation("rel2",ds.Tables[0].Columns["String1"],ds.Tables[1].Columns["String1"]); \r
 410 \r
 411                         ds.Relations.Add(rel1);\r
 412                         ds.Relations.Add(rel2);\r
 413 \r
 414                         Assert.AreEqual(2,ds.Relations.Count,"DRC84");\r
 415 \r
 416                         ds.Relations.CollectionChanged+=new CollectionChangeEventHandler(Relations_CollectionChanged);\r
 417                         //Perform remove\r
 418 \r
 419                         ds.Relations.Remove(rel1);\r
 420                         Assert.AreEqual(1,ds.Relations.Count,"DRC85");\r
 421                         Assert.AreEqual("rel2",ds.Relations[0].RelationName,"DRC86");\r
 422                         ds.Relations.Remove(rel2);\r
 423                         Assert.AreEqual(0,ds.Relations.Count,"DRC87");\r
 424                         Assert.AreEqual(2,changesCounter,"DRC88"); //How many times the event fired\r
 425                         ds.Relations.Remove((DataRelation)null);\r
 426 \r
 427                         try\r
 428                         {\r
 429                                 DataRelation rel3 = new DataRelation("rel3",ds1.Tables[0].Columns["ParentId"],ds1.Tables[1].Columns["ParentId"]); \r
 430                                 ds.Relations.Remove(rel3);\r
 431                                 Assert.Fail("DRC89: Remove failed to throw ArgumentException");\r
 432                         }\r
 433                         catch (ArgumentException) {}\r
 434                         catch (AssertionException exc) {throw  exc;}\r
 435                         catch (Exception exc)\r
 436                         {\r
 437                                 Assert.Fail("DRC90: Remove. Wrong exception type. Got:" + exc);\r
 438                         }\r
 439                 }
 440
 441                 [Test]
 442                 public void Remove_String()\r
 443                 {\r
 444                         DataSet ds = getDataSet();\r
 445                         DataSet ds1 = getDataSet();\r
 446                         DataRelation rel1 = new DataRelation("rel1",ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]); \r
 447                         DataRelation rel2 = new DataRelation("rel2",ds.Tables[0].Columns["String1"],ds.Tables[1].Columns["String1"]); \r
 448 \r
 449                         ds.Relations.Add(rel1);\r
 450                         ds.Relations.Add(rel2);\r
 451 \r
 452                         Assert.AreEqual(ds.Relations.Count,2,"DRC91");\r
 453 \r
 454                         ds.Relations.CollectionChanged+=new CollectionChangeEventHandler(Relations_CollectionChanged);\r
 455                         //Perform remove\r
 456 \r
 457                         ds.Relations.Remove("rel1");\r
 458                         Assert.AreEqual(1,ds.Relations.Count,"DRC92");\r
 459                         Assert.AreEqual("rel2",ds.Relations[0].RelationName,"DRC93");\r
 460                         ds.Relations.Remove("rel2");\r
 461                         Assert.AreEqual(0,ds.Relations.Count,"DRC94");\r
 462                         Assert.AreEqual(2,changesCounter,"DRC95"); //How many times the event fired\r
 463 \r
 464                         try\r
 465                         {\r
 466                                 ds.Relations.Remove((string)null);\r
 467                                 Assert.Fail("DRC96: Remove failed to throw ArgumentException");\r
 468                         }\r
 469                         catch (ArgumentException) {}\r
 470                         catch (AssertionException exc) {throw  exc;}\r
 471                         catch (Exception exc)\r
 472                         {\r
 473                                 Assert.Fail("DRC97: Remove. Wrong exception type. Got:" + exc);\r
 474                         }\r
 475                         \r
 476 \r
 477                         try\r
 478                         {\r
 479                                 //DataRelation rel3 = new DataRelation("rel3",ds1.Tables[0].Columns["ParentId"],ds1.Tables[1].Columns["ParentId"]); \r
 480                                 ds.Relations.Remove("rel3");\r
 481                                 Assert.Fail("DRC98: Remove failed to throw ArgumentException");\r
 482                         }\r
 483                         catch (ArgumentException) {}\r
 484                         catch (AssertionException exc) {throw  exc;}\r
 485                         catch (Exception exc)\r
 486                         {\r
 487                                 Assert.Fail("DRC99: Remove. Wrong exception type. Got:" + exc);\r
 488                         }\r
 489                 }
 490
 491                 private void RemoveAt()\r
 492                 {\r
 493                         DataSet ds = getDataSet();\r
 494                         DataSet ds1 = getDataSet();\r
 495                         DataRelation rel1 = new DataRelation("rel1",ds.Tables[0].Columns["ParentId"],ds.Tables[1].Columns["ParentId"]); \r
 496                         DataRelation rel2 = new DataRelation("rel2",ds.Tables[0].Columns["String1"],ds.Tables[1].Columns["String1"]); \r
 497 \r
 498                         ds.Relations.Add(rel1);\r
 499                         ds.Relations.Add(rel2);\r
 500 \r
 501                         Assert.AreEqual(2,ds.Relations.Count,"DRC100");\r
 502 \r
 503                         ds.Relations.CollectionChanged+=new CollectionChangeEventHandler(Relations_CollectionChanged);\r
 504                         //Perform remove\r
 505 \r
 506                         ds.Relations.RemoveAt(0);\r
 507                         Assert.AreEqual(1,ds.Relations.Count,"DRC101");\r
 508                         Assert.AreEqual("rel2",ds.Relations[0].RelationName,"DRC102");\r
 509                         ds.Relations.RemoveAt(0);\r
 510                         Assert.AreEqual(0,ds.Relations.Count,"DRC103");\r
 511                         Assert.AreEqual(2,changesCounter,"DRC104"); //How many times the event fired\r
 512                         \r
 513 \r
 514                         try\r
 515                         {\r
 516                                 //DataRelation rel3 = new DataRelation("rel3",ds1.Tables[0].Columns["ParentId"],ds1.Tables[1].Columns["ParentId"]); \r
 517                                 ds.Relations.RemoveAt(-1);\r
 518                                 Assert.Fail("DRC105: RemoveAt failed to throw IndexOutOfRangeException");\r
 519                         }\r
 520                         catch (IndexOutOfRangeException) {}\r
 521                         catch (AssertionException exc) {throw  exc;}\r
 522                         catch (Exception exc)\r
 523                         {\r
 524                                 Assert.Fail("DRC106: RemoveAt. Wrong exception type. Got:" + exc);\r
 525                         }\r
 526                 }
 527         }
 528 }