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

   1 //\r
   2 // DataRelationTest.cs - NUnit Test Cases for  DataRelation\r
   3 //\r
   4 // Authors:\r
   5 //   Ville Palo (vi64pa@koti.soon.fi)\r
   6 //   Martin Willemoes Hansen (mwh@sysrq.dk)\r
   7 //\r
   8 // (C) 2003 Ville Palo\r
   9 // (C) 2003 Martin Willemoes Hansen\r
  10 // \r
  11
  12 //
  13 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  14 //
  15 // Permission is hereby granted, free of charge, to any person obtaining
  16 // a copy of this software and associated documentation files (the
  17 // "Software"), to deal in the Software without restriction, including
  18 // without limitation the rights to use, copy, modify, merge, publish,
  19 // distribute, sublicense, and/or sell copies of the Software, and to
  20 // permit persons to whom the Software is furnished to do so, subject to
  21 // the following conditions:
  22 //
  23 // The above copyright notice and this permission notice shall be
  24 // included in all copies or substantial portions of the Software.
  25 //
  26 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  30 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  31 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  32 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  33 //
  34 \r
  35 using NUnit.Framework;\r
  36 using System;\r
  37 using System.Data;\r
  38 \r
  39 namespace MonoTests.System.Data\r
  40 {\r
  41         [TestFixture]\r
  42         public class DataRelationTest : Assertion\r
  43         {\r
  44                 private DataSet Set = null;\r
  45                 private DataTable Mom = null;\r
  46                 private DataTable Child = null;         \r
  47 \r
  48                 [SetUp]\r
  49                 public void GetReady() \r
  50                 {\r
  51                         Set = new DataSet ();\r
  52                         Mom = new DataTable ("Mom");\r
  53                         Child = new DataTable ("Child");\r
  54                         Set.Tables.Add (Mom);\r
  55                         Set.Tables.Add (Child);\r
  56                         \r
  57                         DataColumn Col = new DataColumn ("Name");\r
  58                         DataColumn Col2 = new DataColumn ("ChildName");\r
  59                         Mom.Columns.Add (Col);\r
  60                         Mom.Columns.Add (Col2);\r
  61                         \r
  62                         DataColumn Col3 = new DataColumn ("Name");\r
  63                         DataColumn Col4 = new DataColumn ("Age");\r
  64                         Col4.DataType = Type.GetType ("System.Int16");\r
  65                         Child.Columns.Add (Col3);\r
  66                         Child.Columns.Add (Col4);\r
  67                 }  \r
  68                 \r
  69                 [Test]\r
  70                 public void Foreign ()\r
  71                 {\r
  72                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);\r
  73                         Set.Relations.Add (Relation);\r
  74 \r
  75                         DataRow Row = Mom.NewRow ();\r
  76                         Row [0] = "Teresa";\r
  77                         Row [1] = "Jack";\r
  78                         Mom.Rows.Add (Row);\r
  79                         \r
  80                         Row = Mom.NewRow ();\r
  81                         Row [0] = "Teresa";\r
  82                         Row [1] = "Dick";\r
  83                         Mom.Rows.Add (Row);\r
  84                         \r
  85                         Row = Mom.NewRow ();\r
  86                         Row [0] = "Mary";\r
  87                         Row [1] = "Harry";\r
  88                         \r
  89                         Row = Child.NewRow ();\r
  90                         Row [0] = "Jack";\r
  91                         Row [1] = 16;\r
  92                         Child.Rows.Add (Row);\r
  93                         \r
  94                         Row = Child.NewRow ();\r
  95                         Row [0] = "Dick";\r
  96                         Row [1] = 56;\r
  97                         Child.Rows.Add (Row);\r
  98                         \r
  99                         AssertEquals ("test#01", 2, Child.Rows.Count);\r
 100                         \r
 101                         Row = Mom.Rows [0];\r
 102                         Row.Delete ();\r
 103                         \r
 104                         AssertEquals ("test#02", 1, Child.Rows.Count);\r
 105                         \r
 106                         Row = Mom.NewRow ();\r
 107                         Row [0] = "Teresa";\r
 108                         Row [1] = "Dick";\r
 109                         \r
 110                         try {\r
 111                                 Mom.Rows.Add (Row);\r
 112                                 Fail ("test#03");\r
 113                         } catch (Exception e) {\r
 114                                 AssertEquals ("test#04", typeof (ConstraintException), e.GetType ());\r
 115                                 AssertEquals ("test#05", "Column 'ChildName' is constrained to be unique.  Value 'Dick' is already present.", e.Message);\r
 116                         }                       \r
 117 \r
 118                         Row = Mom.NewRow ();                                 \r
 119                         Row [0] = "Teresa";                                  \r
 120                         Row [1] = "Mich";                                    \r
 121                         Mom.Rows.Add (Row);                                  \r
 122                         AssertEquals ("test#06", 1, Child.Rows.Count);       \r
 123                         \r
 124                         Row = Child.NewRow ();                               \r
 125                         Row [0] = "Jack";                                    \r
 126                         Row [1] = 16;                                        \r
 127                         \r
 128                         try {                                                \r
 129                                 Child.Rows.Add (Row);                               \r
 130                                 Fail ("test#07");                                   \r
 131                         } catch (Exception e) {                              \r
 132                                 AssertEquals ("test#08", typeof (InvalidConstraintException), e.GetType ());\r
 133                                 AssertEquals ("test#09", "ForeignKeyConstraint Rel requires the child key values (Jack) to exist in the parent table.", e.Message);                                                                      \r
 134                         }                                                    \r
 135 \r
 136                 }\r
 137 \r
 138                 [Test]\r
 139                 [ExpectedException (typeof(InvalidConstraintException))]\r
 140                 public void InvalidConstraintException ()\r
 141                 {\r
 142                         // Parent Columns and Child Columns don't have type-matching columns.\r
 143                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [1], true);\r
 144                 }\r
 145 \r
 146                 [Test]\r
 147                 [ExpectedException (typeof (InvalidConstraintException))]\r
 148                 public void InvalidConstraintException2 ()\r
 149                 {\r
 150                         // Parent Columns and Child Columns don't have type-matching columns.\r
 151                         Child.Columns [1].DataType = Mom.Columns [1].DataType;\r
 152                         \r
 153                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [1], true);\r
 154                         Set.Relations.Add (Relation);\r
 155                         AssertEquals("test#01", 1, Set.Relations.Count);
 156                         \r
 157                         Child.Columns [1].DataType = Type.GetType ("System.Double");\r
 158                 }\r
 159                 \r
 160                 [Test]\r
 161                 public void DataSetRelations ()\r
 162                 {\r
 163                         DataRelation Relation;\r
 164                         AssertEquals ("test#01", 0, Set.Relations.Count);\r
 165                         AssertEquals ("test#02", 0, Mom.ParentRelations.Count);\r
 166                         AssertEquals ("test#03", 0, Mom.ChildRelations.Count);\r
 167                         AssertEquals ("test#04", 0, Child.ParentRelations.Count);\r
 168                         AssertEquals ("test#05", 0, Child.ChildRelations.Count);\r
 169                         \r
 170                         Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);\r
 171                         Set.Relations.Add (Relation);\r
 172                         \r
 173                         AssertEquals ("test#06", 1, Set.Relations.Count);\r
 174                         AssertEquals ("test#07", 0, Mom.ParentRelations.Count);\r
 175                         AssertEquals ("test#08", 1, Mom.ChildRelations.Count);\r
 176                         AssertEquals ("test#09", 1, Child.ParentRelations.Count);\r
 177                         AssertEquals ("test#10", 0, Child.ChildRelations.Count);\r
 178                                                 \r
 179                         Relation = Set.Relations [0];\r
 180                         AssertEquals ("test#11", 1, Relation.ParentColumns.Length);\r
 181                         AssertEquals ("test#12", 1, Relation.ChildColumns.Length);\r
 182                         AssertEquals ("test#13", "Rel", Relation.ChildKeyConstraint.ConstraintName);\r
 183                         AssertEquals ("test#14", "Constraint1", Relation.ParentKeyConstraint.ConstraintName);\r
 184                 }\r
 185                 \r
 186                 [Test]\r
 187                 public void Constraints ()\r
 188                 {\r
 189                                 \r
 190                         AssertEquals ("test#01", 0, Mom.Constraints.Count);\r
 191                         AssertEquals ("test#02", 0, Child.Constraints.Count);\r
 192 \r
 193                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);\r
 194                         Set.Relations.Add (Relation);\r
 195                         \r
 196                         AssertEquals ("test#03", 1, Mom.Constraints.Count);\r
 197                         AssertEquals ("test#04", 1, Child.Constraints.Count);\r
 198                         AssertEquals ("test#05", typeof (ForeignKeyConstraint), Child.Constraints [0].GetType ());\r
 199                         AssertEquals ("test#05", typeof (UniqueConstraint), Mom.Constraints [0].GetType ());\r
 200                         \r
 201                 }\r
 202 \r
 203                 [Test]\r
 204                 public void Creation ()\r
 205                 {\r
 206                         \r
 207                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);\r
 208                         Set.Relations.Add (Relation);\r
 209                         DataRelation Test = null;\r
 210                         AssertEquals ("test#01", 1, Mom.ChildRelations.Count);\r
 211                         AssertEquals ("test#02", 0, Child.ChildRelations.Count);\r
 212                         AssertEquals ("test#03", 0, Mom.ParentRelations.Count);\r
 213                         AssertEquals ("test#04", 1, Child.ParentRelations.Count);\r
 214                                 \r
 215                         Test = Child.ParentRelations [0];\r
 216                         AssertEquals ("test#05", "Rel", Test.ToString ());\r
 217                         AssertEquals ("test#06", "Rel", Test.RelationName);\r
 218                         AssertEquals ("test#07", "Mom", Test.ParentTable.TableName);\r
 219                         AssertEquals ("test#08", 1, Test.ParentKeyConstraint.Columns.Length);\r
 220                         AssertEquals ("test#09", false, Test.ParentKeyConstraint.IsPrimaryKey);\r
 221                         AssertEquals ("test#10", 1, Test.ParentColumns.Length);\r
 222                         AssertEquals ("test#11", false, Test.Nested);\r
 223                         AssertEquals ("test#12", 0, Test.ExtendedProperties.Count);\r
 224                         AssertEquals ("test#13", "Child", Test.ChildTable.TableName);\r
 225                         AssertEquals ("test#14", "Rel", Test.ChildKeyConstraint.ConstraintName);\r
 226                         AssertEquals ("test#15", 1, Test.ChildColumns.Length);\r
 227                 }\r
 228                 \r
 229                 [Test]\r
 230                 public void Creation2 ()\r
 231                 {\r
 232                         DataSet Set = new DataSet ();\r
 233                         DataTable Mom2 = new DataTable ("Mom");\r
 234                         DataTable Child2 = new DataTable ("Child");\r
 235                         DataTable Hubby = new DataTable ("Hubby");\r
 236                         Set.Tables.Add (Mom2);\r
 237                         Set.Tables.Add (Child2);\r
 238                         Set.Tables.Add (Hubby);\r
 239                                                 \r
 240                         DataColumn Col = new DataColumn ("Name");\r
 241                         DataColumn Col2 = new DataColumn ("ChildName");\r
 242                         DataColumn Col3 = new DataColumn ("hubby");\r
 243                         Mom2.Columns.Add (Col);\r
 244                         Mom2.Columns.Add (Col2);\r
 245                         Mom2.Columns.Add (Col3);\r
 246                         \r
 247                         DataColumn Col4 = new DataColumn ("Name");\r
 248                         DataColumn Col5 = new DataColumn ("Age");\r
 249                         DataColumn Col6 = new DataColumn ("father");\r
 250                         Child2.Columns.Add (Col4);\r
 251                         Child2.Columns.Add (Col5);\r
 252                         Child2.Columns.Add (Col6);\r
 253                         \r
 254                         \r
 255                         DataColumn Col7 = new DataColumn ("Name");\r
 256                         DataColumn Col8 = new DataColumn ("Age");\r
 257                         Hubby.Columns.Add (Col7);\r
 258                         Hubby.Columns.Add (Col8);\r
 259                         \r
 260                         \r
 261                         DataColumn [] Parents = new DataColumn [2];\r
 262                         Parents [0] = Col2;\r
 263                         Parents [1] = Col3;\r
 264                         DataColumn [] Childs = new DataColumn [2];\r
 265                         Childs [0] = Col4;\r
 266                         Childs [1] = Col7;\r
 267                         \r
 268                         DataRelation Relation = null;\r
 269                         try {\r
 270                                 Relation = new DataRelation ("Rel", Parents, Childs);\r
 271                                 Fail ("test#01");\r
 272                         } catch (InvalidConstraintException e) {\r
 273 //                              AssertEquals ("test#02", typeof (InvalidConstraintException), e.GetType ());                            \r
 274 //                              AssertEquals ("test#03", "Cannot create a Key from Columns that belong to different tables.", e.Message);\r
 275                         }\r
 276                         \r
 277                         Childs [1] = Col6;\r
 278                         Relation = new DataRelation ("Rel", Parents, Childs);\r
 279                         \r
 280                         Set.Relations.Add (Relation);\r
 281                         \r
 282                         DataRelation Test = null;\r
 283                         AssertEquals ("test#01", 1, Mom2.ChildRelations.Count);\r
 284                         AssertEquals ("test#02", 0, Child2.ChildRelations.Count);\r
 285                         AssertEquals ("test#03", 0, Mom2.ParentRelations.Count);\r
 286                         AssertEquals ("test#04", 1, Child2.ParentRelations.Count);\r
 287                                 \r
 288                         Test = Child2.ParentRelations [0];\r
 289                         AssertEquals ("test#05", "Rel", Test.ToString ());\r
 290                         AssertEquals ("test#06", "Rel", Test.RelationName);\r
 291                         AssertEquals ("test#07", "Mom", Test.ParentTable.TableName);\r
 292                         AssertEquals ("test#08", 2, Test.ParentKeyConstraint.Columns.Length);\r
 293                         AssertEquals ("test#09", false, Test.ParentKeyConstraint.IsPrimaryKey);\r
 294                         AssertEquals ("test#10", 2, Test.ParentColumns.Length);\r
 295                         AssertEquals ("test#11", false, Test.Nested);\r
 296                         AssertEquals ("test#12", 0, Test.ExtendedProperties.Count);\r
 297                         AssertEquals ("test#13", "Child", Test.ChildTable.TableName);\r
 298                         AssertEquals ("test#14", "Rel", Test.ChildKeyConstraint.ConstraintName);\r
 299                         AssertEquals ("test#15", 2, Test.ChildColumns.Length);\r
 300                         AssertEquals ("test#16", 1, Mom2.Constraints.Count);\r
 301                         AssertEquals ("test#17", "Constraint1", Mom2.Constraints [0].ToString ());\r
 302                         AssertEquals ("test#18", 1, Child2.Constraints.Count);                  \r
 303                         AssertEquals ("test#19", 0, Hubby.Constraints.Count);\r
 304                 }\r
 305                 \r
 306                 [Test]\r
 307                 public void Creation3 ()\r
 308                 {\r
 309 \r
 310                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0], false);\r
 311                         Set.Relations.Add (Relation);\r
 312                         DataRelation Test = null;\r
 313         \r
 314                         AssertEquals ("test#01", 1, Mom.ChildRelations.Count);\r
 315                         AssertEquals ("test#02", 0, Child.ChildRelations.Count);\r
 316                         AssertEquals ("test#03", 0, Mom.ParentRelations.Count);\r
 317                         AssertEquals ("test#04", 1, Child.ParentRelations.Count);\r
 318                                 \r
 319                         Test = Child.ParentRelations [0];\r
 320                         \r
 321                         AssertEquals ("test#05", "Rel", Test.ToString ());\r
 322                         \r
 323                         AssertEquals ("test#06", "Rel", Test.RelationName);\r
 324                         AssertEquals ("test#07", "Mom", Test.ParentTable.TableName);\r
 325                         \r
 326                         Assert ("test#08", Test.ParentKeyConstraint == null);\r
 327                         \r
 328                         Assert ("test#09", Test.ParentKeyConstraint == null);\r
 329                         \r
 330                         AssertEquals ("test#10", 1, Test.ParentColumns.Length);\r
 331                         AssertEquals ("test#11", false, Test.Nested);\r
 332                         AssertEquals ("test#12", 0, Test.ExtendedProperties.Count);\r
 333                         AssertEquals ("test#13", "Child", Test.ChildTable.TableName);\r
 334                         \r
 335                         Assert ("test#14", Test.ChildKeyConstraint == null);\r
 336                         AssertEquals ("test#15", 1, Test.ChildColumns.Length);\r
 337                         AssertEquals ("test#16", 0, Mom.Constraints.Count);                     \r
 338                         AssertEquals ("test#17", 0, Child.Constraints.Count);                   \r
 339 \r
 340                 }\r
 341 \r
 342                 [Test]\r
 343                 public void Creation4 ()\r
 344                 {\r
 345                         \r
 346                         DataRelation Relation = new DataRelation ("Rel", "Mom", "Child", \r
 347                                                                   new string [] {"ChildName"},\r
 348                                                                   new string [] {"Name"}, true);\r
 349                         \r
 350                         try {\r
 351                                 Set.Relations.Add (Relation);\r
 352                                 Fail ("test#01");\r
 353                         } catch (Exception e) {\r
 354                                 AssertEquals ("test#02", typeof (NullReferenceException), e.GetType ());\r
 355                         }\r
 356                         \r
 357                         try {\r
 358                                 Set.Relations.AddRange (new DataRelation [] {Relation});\r
 359                                 Fail ("test#03");\r
 360                         } catch (Exception e) {\r
 361                                 AssertEquals ("test#04", typeof (NullReferenceException), e.GetType ());\r
 362                         }\r
 363                         \r
 364                         Set.BeginInit ();\r
 365                         Set.Relations.AddRange (new DataRelation [] {Relation});\r
 366                         Set.EndInit ();\r
 367                         \r
 368                         DataRelation Test = null;\r
 369                         AssertEquals ("test#01", 1, Mom.ChildRelations.Count);\r
 370                         AssertEquals ("test#02", 0, Child.ChildRelations.Count);\r
 371                         AssertEquals ("test#03", 0, Mom.ParentRelations.Count);\r
 372                         AssertEquals ("test#04", 1, Child.ParentRelations.Count);\r
 373                                 \r
 374                         Test = Child.ParentRelations [0];\r
 375                         AssertEquals ("test#05", "Rel", Test.ToString ());\r
 376                         AssertEquals ("test#06", "Rel", Test.RelationName);\r
 377                         AssertEquals ("test#07", "Mom", Test.ParentTable.TableName);\r
 378                         \r
 379                         AssertEquals ("test#08", true, Test.ParentKeyConstraint == null);\r
 380                                                 \r
 381                         AssertEquals ("test#10", 1, Test.ParentColumns.Length);\r
 382                         AssertEquals ("test#11", true, Test.Nested);\r
 383                         AssertEquals ("test#12", 0, Test.ExtendedProperties.Count);\r
 384                         AssertEquals ("test#13", "Child", Test.ChildTable.TableName);\r
 385                         AssertEquals ("test#14", true, Test.ChildKeyConstraint == null);\r
 386                         AssertEquals ("test#15", 1, Test.ChildColumns.Length);\r
 387                         \r
 388                 }\r
 389 \r
 390                 [Test]\r
 391                 public void RelationFromSchema ()\r
 392                 {\r
 393                         DataSet Set = new DataSet ();\r
 394                         Set.ReadXmlSchema ("Test/System.Data/store.xsd");\r
 395                         DataTable Table = Set.Tables [0];\r
 396                         \r
 397                         AssertEquals ("test#01", false, Table.CaseSensitive);\r
 398                         AssertEquals ("test#02", 1, Table.ChildRelations.Count);\r
 399                         AssertEquals ("test#03", 0, Table.ParentRelations.Count);\r
 400                         AssertEquals ("test#04", 1, Table.Constraints.Count);\r
 401                         AssertEquals ("test#05", 1, Table.PrimaryKey.Length);\r
 402                         AssertEquals ("test#06", 0, Table.Rows.Count);\r
 403                         AssertEquals ("test#07", "bookstore", Table.TableName);\r
 404                         AssertEquals ("test#08", 1, Table.Columns.Count);\r
 405                                                 \r
 406                         DataRelation Relation = Table.ChildRelations [0];\r
 407                         AssertEquals ("test#09", 1, Relation.ChildColumns.Length);\r
 408                         AssertEquals ("test#10", "bookstore_book", Relation.ChildKeyConstraint.ConstraintName);\r
 409                         AssertEquals ("test#11", 1, Relation.ChildKeyConstraint.Columns.Length);\r
 410                         AssertEquals ("test#12", "book", Relation.ChildTable.TableName);\r
 411                         AssertEquals ("test#13", "NewDataSet", Relation.DataSet.DataSetName);\r
 412                         AssertEquals ("test#14", 0, Relation.ExtendedProperties.Count);\r
 413                         AssertEquals ("test#15", true, Relation.Nested);\r
 414                         AssertEquals ("test#16", 1, Relation.ParentColumns.Length);\r
 415                         AssertEquals ("test#17", "Constraint1", Relation.ParentKeyConstraint.ConstraintName);\r
 416                         AssertEquals ("test#18", "bookstore", Relation.ParentTable.TableName);\r
 417                         AssertEquals ("test#19", "bookstore_book", Relation.RelationName);\r
 418 \r
 419                         Table = Set.Tables [1];\r
 420                         \r
 421                         AssertEquals ("test#20", false, Table.CaseSensitive);\r
 422                         AssertEquals ("test#21", 1, Table.ChildRelations.Count);\r
 423                         AssertEquals ("test#22", 1, Table.ParentRelations.Count);\r
 424                         AssertEquals ("test#23", 2, Table.Constraints.Count);\r
 425                         AssertEquals ("test#24", 1, Table.PrimaryKey.Length);\r
 426                         AssertEquals ("test#25", 0, Table.Rows.Count);\r
 427                         AssertEquals ("test#26", "book", Table.TableName);\r
 428                         AssertEquals ("test#27", 5, Table.Columns.Count);\r
 429                 \r
 430                         Relation = Table.ChildRelations [0];\r
 431                         AssertEquals ("test#28", 1, Relation.ChildColumns.Length);\r
 432                         AssertEquals ("test#29", "book_author", Relation.ChildKeyConstraint.ConstraintName);\r
 433                         AssertEquals ("test#30", 1, Relation.ChildKeyConstraint.Columns.Length);\r
 434                         AssertEquals ("test#31", "author", Relation.ChildTable.TableName);\r
 435                         AssertEquals ("test#32", "NewDataSet", Relation.DataSet.DataSetName);\r
 436                         AssertEquals ("test#33", 0, Relation.ExtendedProperties.Count);\r
 437                         AssertEquals ("test#34", true, Relation.Nested);\r
 438                         AssertEquals ("test#35", 1, Relation.ParentColumns.Length);\r
 439                         AssertEquals ("test#36", "Constraint1", Relation.ParentKeyConstraint.ConstraintName);\r
 440                         AssertEquals ("test#37", "book", Relation.ParentTable.TableName);\r
 441                         AssertEquals ("test#38", "book_author", Relation.RelationName);\r
 442                         \r
 443                         Table = Set.Tables [2];\r
 444                         AssertEquals ("test#39", false, Table.CaseSensitive);\r
 445                         AssertEquals ("test#40", 0, Table.ChildRelations.Count);\r
 446                         AssertEquals ("test#41", 1, Table.ParentRelations.Count);\r
 447                         AssertEquals ("test#42", 1, Table.Constraints.Count);\r
 448                         AssertEquals ("test#43", 0, Table.PrimaryKey.Length);\r
 449                         AssertEquals ("test#44", 0, Table.Rows.Count);\r
 450                         AssertEquals ("test#45", "author", Table.TableName);\r
 451                         AssertEquals ("test#46", 3, Table.Columns.Count);\r
 452                 }\r
 453                 \r
 454                 [Test]\r
 455                 public void ChildRows ()\r
 456                 {\r
 457                         \r
 458                         DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);\r
 459                         Set.Relations.Add (Relation);\r
 460                         \r
 461                         DataRow TempRow = Mom.NewRow ();\r
 462                         TempRow [0] = "teresa";\r
 463                         TempRow [1] = "john";\r
 464                         Mom.Rows.Add (TempRow);\r
 465                         \r
 466                         TempRow = Mom.NewRow ();\r
 467                         TempRow [0] = "teresa";\r
 468                         TempRow [1] = "Dick";\r
 469                         Mom.Rows.Add (TempRow);\r
 470                                                 \r
 471                         TempRow = Child.NewRow ();\r
 472                         TempRow [0] = "john";\r
 473                         TempRow [1] = "15";\r
 474                         Child.Rows.Add (TempRow);\r
 475                         \r
 476                         TempRow = Child.NewRow ();\r
 477                         TempRow [0] = "Dick";\r
 478                         TempRow [1] = "10";\r
 479                         Child.Rows.Add (TempRow);\r
 480                         \r
 481                         DataRow Row = Mom.Rows [1];                     \r
 482                         TempRow = Row.GetChildRows ("Rel") [0];\r
 483                         AssertEquals ("test#01", "Dick", TempRow [0]);\r
 484                         AssertEquals ("test#02", "10", TempRow [1].ToString ());\r
 485                         TempRow = TempRow.GetParentRow ("Rel");\r
 486                         AssertEquals ("test#03", "teresa", TempRow [0]);\r
 487                         AssertEquals ("test#04", "Dick", TempRow [1]);\r
 488                         \r
 489                         Row = Child.Rows [0];\r
 490                         TempRow = Row.GetParentRows ("Rel") [0];\r
 491                         AssertEquals ("test#05", "teresa", TempRow [0]);\r
 492                         AssertEquals ("test#06", "john", TempRow [1]);                                          \r
 493                 }\r
 494 \r
 495         }\r
 496 }\r