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

   1 #if NET_2_0
   2
   3 using System;
   4 using System.Data;
   5 using System.Data.Common;
   6 using System.Globalization;
   7 using System.IO;
   8 using System.Runtime.Serialization;
   9 using System.Runtime.Serialization.Formatters;
  10 using System.Runtime.Serialization.Formatters.Binary;
  11 using System.Threading;
  12
  13 using NUnit.Framework;
  14
  15 [TestFixture]
  16 public class BinarySerializationTest
  17 {
  18         private CultureInfo originalCulture;
  19
  20         [SetUp]
  21         public void SetUp ()
  22         {
  23                 originalCulture = Thread.CurrentThread.CurrentCulture;
  24                 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
  25         }
  26
  27         [TearDown]
  28         public void TearDown ()
  29         {
  30                 Thread.CurrentThread.CurrentCulture = originalCulture;
  31         }
  32
  33         [Test]
  34         public void RemotingFormatDataTableTest ()
  35         {
  36                 DataTable dt = new DataTable ();
  37                 //Test Default SerializationFormat
  38                 Assert.AreEqual (SerializationFormat.Xml, dt.RemotingFormat, "#1 Default value for RemotingFormat of DataTable is Xml");
  39                 //Test with Assigned value
  40                 dt.RemotingFormat = SerializationFormat.Binary;
  41                 Assert.AreEqual (SerializationFormat.Binary, dt.RemotingFormat, "#2 RemotingFormat Should be Binary");
  42         }
  43         [Test]
  44         public void RemotingFormatDataSetTest ()
  45         {
  46                 DataSet ds = new DataSet ();
  47                 DataTable dt = new DataTable ();
  48
  49                 //Test Default SerializationFormat
  50                 Assert.AreEqual (SerializationFormat.Xml, dt.RemotingFormat, "#1 Default value for RemotingFormat of DataTable is Xml");
  51                 Assert.AreEqual (SerializationFormat.Xml, ds.RemotingFormat, "#2 Default value for RemotingFormat of DataSet is Xml");
  52
  53                 //Test with Assigned value
  54                 ds.RemotingFormat = SerializationFormat.Binary;
  55                 Assert.AreEqual (SerializationFormat.Binary, ds.RemotingFormat, "#3 RemotingFormat Should be Binary");
  56
  57                 //Test After adding a Table to DataSet
  58                 ds.Tables.Add (dt);
  59                 Assert.AreEqual (SerializationFormat.Binary, ds.RemotingFormat, "#4 RemotingFormat should be Binary for DataSet");
  60                 Assert.AreEqual (SerializationFormat.Binary, dt.RemotingFormat, "#5 RemotingFormat should be Binary for DataTable");
  61
  62                 ds.RemotingFormat = SerializationFormat.Xml;
  63                 Assert.AreEqual (SerializationFormat.Xml, ds.RemotingFormat, "#6 RemotingFormat should be Xml for DataSet");
  64                 Assert.AreEqual (SerializationFormat.Xml, dt.RemotingFormat, "#7 RemotingFormat should be  Xml for DataTable");
  65
  66                 //Test for Exception when try t modify RemotingFormat of DataTable which belongs to a DataSet
  67
  68                 try {
  69                         dt.RemotingFormat = SerializationFormat.Binary;
  70                         Assert.Fail ("#8 It should throw an ArgumentException");
  71                 } catch (ArgumentException e) {
  72                         Assert.AreEqual (e.GetType (), typeof (ArgumentException), "#9 Invalid Exception");
  73                 } catch (Exception e) {
  74                         Assert.AreEqual (e.GetType (), typeof (ArgumentException), "#10 Invalid Exception");
  75                 }
  76
  77         }
  78         [Test]
  79         public void DataTableSerializationTest1 ()
  80         {
  81                 //Serialize Table
  82                 DataTable tb1 = new DataTable ("Test");
  83                 tb1.Columns.Add ("id", typeof (int));
  84                 tb1.Columns.Add ("name", typeof (string));
  85                 tb1.Rows.Add (new object[] {1, "A"});
  86                 tb1.Rows.Add (new object[] {2, "B"});
  87                 //Add Constraint
  88                 UniqueConstraint uniqueConstraint = new UniqueConstraint (tb1.Columns ["id"]);
  89                 tb1.Constraints.Add (uniqueConstraint);
  90                 tb1.RemotingFormat = SerializationFormat.Binary;
  91                 tb1.AcceptChanges();
  92
  93                 tb1.Rows[0][0] = 1;
  94                 tb1.Rows[1].Delete();
  95
  96                 MemoryStream ms = new MemoryStream ();
  97                 BinaryFormatter bf = new BinaryFormatter ();
  98                 bf.Serialize (ms,tb1);
  99                 byte [] serializedStream = ms.ToArray ();
 100                 ms.Close ();
 101                 //DserializeTable
 102                 ms = new MemoryStream (serializedStream);
 103                 DataTable dt = (DataTable)bf.Deserialize (ms);
 104                 ms.Close ();
 105
 106                 //Test Properties of table
 107                 //Assert.AreEqual (tb1.RemotingFormat, dt.RemotingFormat, "#1 RemotingFormat property is Different");
 108                 Assert.AreEqual (tb1.Columns.Count, dt.Columns.Count, "#2 ColumnCount property is Different");
 109                 Assert.AreEqual (tb1.TableName, dt.TableName, "#3 TableName property is Different");
 110                 Assert.AreEqual (tb1.Prefix, dt.Prefix, "#4 Prefix propertyis Different");
 111                 Assert.AreEqual (tb1.Namespace, dt.Namespace, "#5 NameSpace property is Different");
 112                 Assert.AreEqual (tb1.CaseSensitive, dt.CaseSensitive, "#6 CaseSensitive property is Different");
 113                 Assert.AreEqual (tb1.Locale.LCID, dt.Locale.LCID, "#7 LocaleLCID property is Different");
 114                 Assert.AreEqual (tb1.MinimumCapacity, dt.MinimumCapacity, "#8 NameSpace property is Different");
 115                 //Test Constraints
 116                 Assert.AreEqual (tb1.Constraints.Count, dt.Constraints.Count, "#9 No. of Constraints is Different");
 117                 for (int i = 0; i < tb1.Constraints.Count; i++)
 118                         Assert.AreEqual (tb1.Constraints [i].GetType (), dt.Constraints [i].GetType (), "#10 Constraint : {0} is Different", tb1.Constraints [i]);
 119                 //Test for Table Data
 120                 Assert.AreEqual (tb1.Rows.Count, dt.Rows.Count, "#11 RowCount propertyis Different");
 121                 //RowStates
 122                 for (int i = 0; i < tb1.Rows.Count; i++) {
 123                         Assert.AreEqual (tb1.Rows [i].RowState, dt.Rows [i].RowState, "#12 RowState is Different");
 124                 }
 125                 //Table Data
 126                 for (int i = 0; i < tb1.Rows.Count; i++)
 127                         for (int j = 0; j < tb1.Columns.Count; j++) {
 128                           if (tb1.Rows[i].RowState != DataRowState.Deleted)
 129                                 Assert.AreEqual (tb1.Rows [i][j], dt.Rows [i][j], "#13 Elements differ at Row :{0} Column :{1}", i, j);
 130                         }
 131                 dt.Rows[0].RejectChanges();
 132                 dt.Rows[1].RejectChanges();
 133         }
 134         [Test]
 135         public void DataTableSerializationTest2 ()
 136         {
 137                 //Serialize Table
 138                 DataTable tb1 = new DataTable ("Test");
 139                 tb1.Columns.Add ("id", typeof (int));
 140                 tb1.Columns.Add ("name", typeof (string));
 141                 tb1.Rows.Add (new object[] {1, "A"});
 142                 tb1.Rows.Add (new object[] {2, "B"});
 143                 //Add Constraint
 144                 UniqueConstraint uniqueConstraint = new UniqueConstraint (tb1.Columns ["id"]);
 145                 tb1.Constraints.Add (uniqueConstraint);
 146                 tb1.RemotingFormat = SerializationFormat.Binary;
 147                 tb1.AcceptChanges();
 148
 149                 tb1.Rows[0][0] = 1;
 150                 tb1.Rows[1].Delete();
 151
 152                 BinaryFormatter bf = new BinaryFormatter ();
 153                 FileStream fs = new FileStream ("Test/System.Data/binserialize/BS-tb1.bin", FileMode.Open, FileAccess.Read);
 154                 BinaryReader r = new BinaryReader (fs);
 155                 byte [] serializedStream = r.ReadBytes ((int)fs.Length);
 156                 r.Close ();
 157                 fs.Close ();
 158                 //DserializeTable
 159                 MemoryStream ms = new MemoryStream (serializedStream);
 160                 DataTable dt = (DataTable)bf.Deserialize (ms);
 161                 ms.Close ();
 162
 163                 //Test Properties of table
 164                 //Assert.AreEqual (tb1.RemotingFormat, dt.RemotingFormat, "#1 RemotingFormat property is Different");
 165                 Assert.AreEqual (tb1.Columns.Count, dt.Columns.Count, "#2 ColumnCount property is Different");
 166                 Assert.AreEqual (tb1.TableName, dt.TableName, "#3 TableName property is Different");
 167                 Assert.AreEqual (tb1.Prefix, dt.Prefix, "#4 Prefix propertyis Different");
 168                 Assert.AreEqual (tb1.Namespace, dt.Namespace, "#5 NameSpace property is Different");
 169                 Assert.AreEqual (tb1.CaseSensitive, dt.CaseSensitive, "#6 CaseSensitive property is Different");
 170                 Assert.AreEqual (tb1.Locale.LCID, dt.Locale.LCID, "#7 LocaleLCID property is Different");
 171                 Assert.AreEqual (tb1.MinimumCapacity, dt.MinimumCapacity, "#8 NameSpace property is Different");
 172                 //Test Constraints
 173                 Assert.AreEqual (tb1.Constraints.Count, dt.Constraints.Count, "#9 No. of Constraints is Different");
 174                 for (int i = 0; i < tb1.Constraints.Count; i++)
 175                         Assert.AreEqual (tb1.Constraints [i].GetType (), dt.Constraints [i].GetType (), "#10 Constraint : {0} is Different", tb1.Constraints [i]);
 176                 //Test for Table Data
 177                 Assert.AreEqual (tb1.Rows.Count, dt.Rows.Count, "#11 RowCount propertyis Different");
 178                 //RowStates
 179                 for (int i = 0; i < tb1.Rows.Count; i++) {
 180                         Assert.AreEqual (tb1.Rows [i].RowState, dt.Rows [i].RowState, "#12 RowState is Different");
 181                 }
 182                 //Table Data
 183                 for (int i = 0; i < tb1.Rows.Count; i++)
 184                         for (int j = 0; j < tb1.Columns.Count; j++) {
 185                           if (tb1.Rows[i].RowState != DataRowState.Deleted)
 186                                 Assert.AreEqual (tb1.Rows [i][j], dt.Rows [i][j], "#13 Elements differ at Row :{0} Column :{1}", i, j);
 187                         }
 188                 dt.Rows[0].RejectChanges();
 189                 dt.Rows[1].RejectChanges();
 190         }
 191
 192         [Test]
 193         public void TestDefaultValues ()
 194         {
 195                 //Serialize Table
 196                 DataTable tb1 = new DataTable ();
 197                 tb1.Columns.Add ("id", typeof (int));
 198                 tb1.Columns.Add ("Date", typeof (string));
 199                 tb1.Columns["id"].DefaultValue = 10;
 200                 tb1.Columns["Date"].DefaultValue = "9/15/2008";
 201                 tb1.Rows.Add (tb1.NewRow());
 202
 203                 MemoryStream ms = new MemoryStream ();
 204                 BinaryFormatter bf = new BinaryFormatter ();
 205                 tb1.RemotingFormat = SerializationFormat.Binary;
 206                 bf.Serialize (ms,tb1);
 207                 byte [] serializedStream = ms.ToArray ();
 208                 ms.Close ();
 209                 //DserializeTable
 210                 ms = new MemoryStream (serializedStream);
 211                 DataTable dt = (DataTable)bf.Deserialize (ms);
 212                 ms.Close ();
 213
 214                 //Table Data
 215                 for (int i = 0; i < tb1.Rows.Count; i++)
 216                         for (int j = 0; j < tb1.Columns.Count; j++) {
 217                                 Assert.AreEqual (tb1.Columns[j].DefaultValue, dt.Rows [i][j], "#1 Element differs from DefaultValue at Row :{0} Column :{1}", i, j);
 218                                 Assert.AreEqual (tb1.Rows [i][j], dt.Rows [i][j], "#2 Elements differ at Row :{0} Column :{1}", i, j);
 219                         }
 220         }
 221
 222         [Test]
 223         public void TestEmptyTable ()
 224         {
 225                 //Serialize Table
 226                 DataTable tb1 = new DataTable ();
 227                 tb1.Columns.Add ("id", typeof (int));
 228                 tb1.Columns.Add ("Date", typeof (string));
 229
 230                 MemoryStream ms = new MemoryStream ();
 231                 BinaryFormatter bf = new BinaryFormatter ();
 232                 tb1.RemotingFormat = SerializationFormat.Binary;
 233                 bf.Serialize (ms,tb1);
 234                 byte [] serializedStream = ms.ToArray ();
 235                 ms.Close ();
 236                 //DserializeTable
 237                 ms = new MemoryStream (serializedStream);
 238                 DataTable dt = (DataTable)bf.Deserialize (ms);
 239                 ms.Close ();
 240
 241                 Assert.AreEqual(tb1.Rows.Count, dt.Rows.Count);
 242         }
 243
 244         [Test]
 245         public void Test_With_Null_Values1 ()
 246         {
 247                 //Serialize Table
 248                 DataTable tb1 = new DataTable ();
 249                 tb1.Columns.Add ("id", typeof (int));
 250                 tb1.Columns.Add ("Date", typeof (string));
 251                 tb1.Rows.Add (new object[] {1, "A"});
 252                 tb1.Rows.Add (new object[] {2, null});
 253                 tb1.Rows.Add (new object[] {null, "B"});
 254                 tb1.Rows.Add (new object[] {null, null});
 255
 256                 MemoryStream ms = new MemoryStream ();
 257                 BinaryFormatter bf = new BinaryFormatter ();
 258                 tb1.RemotingFormat = SerializationFormat.Binary;
 259                 bf.Serialize (ms,tb1);
 260                 byte [] serializedStream = ms.ToArray ();
 261                 ms.Close ();
 262                 //DserializeTable
 263                 ms = new MemoryStream (serializedStream);
 264                 DataTable dt = (DataTable)bf.Deserialize (ms);
 265                 ms.Close ();
 266                 //Table Data
 267                 for (int i = 0; i < tb1.Rows.Count; i++)
 268                         for (int j = 0; j < tb1.Columns.Count; j++) {
 269                                 Assert.AreEqual (tb1.Rows [i][j], dt.Rows [i][j], "#1 Elements differ at Row :{0} Column :{1}", i, j);
 270                         }
 271
 272         }
 273         [Test]
 274         public void Test_With_Null_Values2 ()
 275         {
 276                 //Serialize Table
 277                 DataTable tb1 = new DataTable ();
 278                 tb1.Columns.Add ("id", typeof (int));
 279                 tb1.Columns.Add ("Date", typeof (string));
 280                 tb1.Rows.Add (new object[] {1, "A"});
 281                 tb1.Rows.Add (new object[] {2, null});
 282                 tb1.Rows.Add (new object[] {null, "B"});
 283                 tb1.Rows.Add (new object[] {null, null});
 284
 285                 BinaryFormatter bf = new BinaryFormatter ();
 286                 tb1.RemotingFormat = SerializationFormat.Binary;
 287                 FileStream fs = new FileStream ("Test/System.Data/binserialize/BS-tb2.bin", FileMode.Open, FileAccess.Read);
 288                 BinaryReader r = new BinaryReader (fs);
 289                 byte [] serializedStream = r.ReadBytes ((int)fs.Length);
 290                 r.Close ();
 291                 fs.Close ();
 292                 //DserializeTable
 293                 MemoryStream ms = new MemoryStream (serializedStream);
 294                 DataTable dt = (DataTable)bf.Deserialize (ms);
 295                 ms.Close ();
 296                 //Table Data
 297                 for (int i = 0; i < tb1.Rows.Count; i++)
 298                         for (int j = 0; j < tb1.Columns.Count; j++) {
 299                                 Assert.AreEqual (tb1.Rows [i][j], dt.Rows [i][j], "#1 Elements differ at Row :{0} Column :{1}", i, j);
 300                         }
 301
 302         }
 303         [Test]
 304         public void Test_With_DateTime_Values1 ()
 305         {
 306                 //Serialize Table
 307                 DataTable tb1 = new DataTable ();
 308                 DateTime dateTime = DateTime.UtcNow;
 309                 tb1.Columns.Add ("id", typeof (int));
 310                 tb1.Columns.Add ("Date", typeof (DateTime));
 311                 tb1.Rows.Add (new object[] {1, "12-09-07"});
 312                 tb1.Rows.Add (new object[] {2, "12-09-06"});
 313                 //tb1.Rows.Add (new object[] {3, dateTime});
 314                 MemoryStream ms = new MemoryStream ();
 315                 BinaryFormatter bf = new BinaryFormatter ();
 316                 tb1.RemotingFormat = SerializationFormat.Binary;
 317                 bf.Serialize (ms,tb1);
 318                 byte [] serializedStream = ms.ToArray ();
 319                 ms.Close ();
 320                 //DserializeTable
 321                 ms = new MemoryStream (serializedStream);
 322                 DataTable dt = (DataTable)bf.Deserialize (ms);
 323                 ms.Close ();
 324                 //Table Data
 325                 for (int i = 0; i < tb1.Rows.Count; i++)
 326                         for (int j = 0; j < tb1.Columns.Count; j++) {
 327                                 Assert.AreEqual (tb1.Rows [i][j], dt.Rows [i][j], "#1 Elements differ at Row :{0} Column :{1}", i, j);
 328                         }
 329         }
 330         [Test]
 331         [Category ("NotWorking")]
 332         public void Test_With_DateTime_Values2 ()
 333         {
 334                 //Serialize Table
 335                 DataTable tb1 = new DataTable ();
 336                 DateTime dateTime = DateTime.UtcNow;
 337                 tb1.Columns.Add ("id", typeof (int));
 338                 tb1.Columns.Add ("Date", typeof (DateTime));
 339                 tb1.Rows.Add (new object[] {1, "12-09-07"});
 340                 tb1.Rows.Add (new object[] {2, "12-09-06"});
 341                 //tb1.Rows.Add (new object[] {3, dateTime});
 342                 BinaryFormatter bf = new BinaryFormatter ();
 343                 tb1.RemotingFormat = SerializationFormat.Binary;
 344                 FileStream fs = new FileStream ("Test/System.Data/binserialize/BS-tb3.bin", FileMode.Open, FileAccess.Read);
 345                 BinaryReader r = new BinaryReader (fs);
 346                 byte [] serializedStream = r.ReadBytes ((int) fs.Length);
 347                 r.Close ();
 348                 fs.Close ();
 349                 //DserializeTable
 350                 MemoryStream ms = new MemoryStream (serializedStream);
 351                 DataTable dt = (DataTable)bf.Deserialize (ms);
 352                 ms.Close ();
 353                 //Table Data
 354                 for (int i = 0; i < tb1.Rows.Count; i++)
 355                         for (int j = 0; j < tb1.Columns.Count; j++) {
 356                                 Assert.AreEqual (tb1.Rows [i][j], dt.Rows [i][j], "#1 Elements differ at Row :{0} Column :{1}", i, j);
 357                         }
 358         }
 359         [Test]
 360         public void DataSetSerializationTest1 ()
 361         {
 362                 DataSet ds = new DataSet ();
 363                 //Table1
 364                 DataTable tb1 = new DataTable ();
 365                 tb1.Columns.Add ("id", typeof (int));
 366                 tb1.Columns.Add ("name", typeof (string));
 367                 tb1.Rows.Add (new object[] {1, "A"});
 368                 tb1.Rows.Add (new object[] {2, "B"});
 369                 ds.Tables.Add (tb1);
 370                 //Table2
 371                 DataTable tb2 = new DataTable ();
 372                 tb2.Columns.Add ("RollNO", typeof (int));
 373                 tb2.Columns.Add ("Name", typeof (string));
 374                 tb2.Rows.Add (new object[] {1, "A"});
 375                 tb2.Rows.Add (new object[] {2, "B"});
 376                 ds.Tables.Add (tb2);
 377                 //Constraints and relations
 378                 ForeignKeyConstraint fKey = new ForeignKeyConstraint (tb2.Columns ["RollNO"],
 379                                                                       tb1.Columns ["id"]);
 380                 tb1.Constraints.Add (fKey);
 381                 DataRelation rel = new DataRelation ("Relation1", tb1.Columns ["name"],
 382                                                     tb2.Columns ["Name"]);
 383                 ds.Relations.Add (rel);
 384                 //SerializeDataSet
 385                 MemoryStream ms = new MemoryStream ();
 386                 BinaryFormatter bf = new BinaryFormatter ();
 387                 ds.RemotingFormat = SerializationFormat.Binary;
 388                 bf.Serialize (ms,ds);
 389                 byte [] serializedStream = ms.ToArray ();
 390                 ms.Close ();
 391                 //DserializeDataSet
 392                 ms = new MemoryStream (serializedStream);
 393                 DataSet ds1 = (DataSet)bf.Deserialize (ms);
 394                 ms.Close ();
 395                 //Test DataSet Properties
 396                 //Assert.AreEqual (ds.RemotingFormat, ds1.RemotingFormat, "#1 RemotingFormat is different");
 397                 Assert.AreEqual (ds.DataSetName, ds1.DataSetName, "#2 DataSetName is different");
 398                 Assert.AreEqual (ds.Namespace, ds1.Namespace, "#3 Namespace is different");
 399                 Assert.AreEqual (ds.Prefix, ds1.Prefix, "#4 Prefix is different");
 400                 Assert.AreEqual (ds.CaseSensitive, ds1.CaseSensitive, "#5 CaseSensitive property value is different");
 401                 Assert.AreEqual (ds.Locale.LCID, ds1.Locale.LCID, "#6 DataSet LocaleLCID is different");
 402                 Assert.AreEqual (ds.EnforceConstraints, ds1.EnforceConstraints, "#7 EnforceConstraints property value is different");
 403                 Assert.AreEqual (ds.Tables.Count, ds1.Tables.Count, "#7 Table Count is different");
 404
 405                 //Test Constraints & relations
 406
 407                 //Table1
 408                 Assert.AreEqual (ds.Tables [0].Constraints.Count, ds1.Tables [0].Constraints.Count, "#8 Number of constraint is different for Table :{0}", ds.Tables [0].TableName);
 409
 410                 for (int i = 0; i < ds.Tables [0].Constraints.Count; i++)
 411                         Assert.AreEqual (ds.Tables [0].Constraints [i].GetType (),
 412                                          ds1.Tables [0].Constraints [i].GetType (),
 413                                          "#9 Constraint : {0} is Different", ds.Tables [0].Constraints [i]);
 414
 415                 //Table2
 416                 Assert.AreEqual (ds.Tables [1].Constraints.Count, ds1.Tables [1].Constraints.Count, "#10 Number of constraint is different for Table :{0}", ds.Tables [1].TableName);
 417
 418                 for (int i = 0; i < ds.Tables [1].Constraints.Count; i++)
 419                         Assert.AreEqual (ds.Tables [1].Constraints [i].GetType (),
 420                                          ds1.Tables [1].Constraints [i].GetType (),
 421                                          "#11 Constraint : {0} is Different", ds.Tables [1].Constraints [i]);
 422                 //Relations
 423                 Assert.AreEqual (ds.Relations.Count, ds1.Relations.Count, "#12 Relation count is different");
 424                 for (int i = 0; i < ds.Relations.Count; i++)
 425                         Assert.AreEqual (ds.Relations [i].RelationName, ds1.Relations [i].RelationName, "#13 Relation Name is different for relation :{0}", ds.Relations [i].RelationName);
 426
 427                 for (int i = 0; i < ds.Relations.Count; i++)
 428                         Assert.AreEqual (ds.Relations [i].ParentTable.TableName,
 429                                          ds1.Relations[i].ParentTable.TableName, "#14 Relation Name is different for relation :{0}", ds.Relations [i].ParentTable.TableName);
 430
 431                 for (int i = 0; i < ds.Relations.Count; i++)
 432                         Assert.AreEqual (ds.Relations [i].ChildTable.TableName,
 433                                          ds1.Relations[i].ChildTable.TableName, "#15 Relation Name is different for relation :{0}", ds.Relations [i].ChildTable.TableName);
 434
 435                 //Table Data
 436                 //Table1
 437                 for (int i = 0; i < ds.Tables [0].Rows.Count; i++)
 438                         for (int j = 0; j < ds.Tables [0].Columns.Count; j++) {
 439                                 Assert.AreEqual (ds.Tables [0].Rows [i][j], ds1.Tables [0].Rows [i][j],
 440                                                  "#16 Elements differ at Row :{0} Column :{1}", i, j);
 441                         }
 442                 //Table2
 443                 for (int i = 0; i < ds.Tables [0].Rows.Count; i++)
 444                         for (int j = 0; j < ds.Tables [1].Columns.Count; j++) {
 445                                 Assert.AreEqual (ds.Tables [1].Rows [i][j], ds1.Tables [1].Rows [i][j],
 446                                                  "#17 Elements differ at Row :{0} Column :{1}", i, j);
 447                         }
 448
 449         }
 450         [Test]
 451         public void DataSetSerializationTest2 ()
 452         {
 453                 DataSet ds = new DataSet ();
 454                 //Table1
 455                 DataTable tb1 = new DataTable ();
 456                 tb1.Columns.Add ("id", typeof (int));
 457                 tb1.Columns.Add ("name", typeof (string));
 458                 tb1.Rows.Add (new object[] {1, "A"});
 459                 tb1.Rows.Add (new object[] {2, "B"});
 460                 ds.Tables.Add (tb1);
 461                 //Table2
 462                 DataTable tb2 = new DataTable ();
 463                 tb2.Columns.Add ("RollNO", typeof (int));
 464                 tb2.Columns.Add ("Name", typeof (string));
 465                 tb2.Rows.Add (new object[] {1, "A"});
 466                 tb2.Rows.Add (new object[] {2, "B"});
 467                 ds.Tables.Add (tb2);
 468                 //Constraints and relations
 469                 ForeignKeyConstraint fKey = new ForeignKeyConstraint (tb2.Columns ["RollNO"],
 470                                                                       tb1.Columns ["id"]);
 471                 tb1.Constraints.Add (fKey);
 472                 DataRelation rel = new DataRelation ("Relation1", tb1.Columns ["name"],
 473                                                     tb2.Columns ["Name"]);
 474                 ds.Relations.Add (rel);
 475                 //SerializeDataSet
 476                 BinaryFormatter bf = new BinaryFormatter ();
 477                 ds.RemotingFormat = SerializationFormat.Binary;
 478                 FileStream fs = new FileStream ("Test/System.Data/binserialize/BS-tb4.bin", FileMode.Open, FileAccess.Read);
 479                 BinaryReader r = new BinaryReader (fs);
 480                 byte [] serializedStream = r.ReadBytes ((int) fs.Length);
 481                 r.Close ();
 482                 fs.Close ();
 483                 //DserializeDataSet
 484                 MemoryStream ms = new MemoryStream (serializedStream);
 485                 DataSet ds1 = (DataSet)bf.Deserialize (ms);
 486                 ms.Close ();
 487                 //Test DataSet Properties
 488                 //Assert.AreEqual (ds.RemotingFormat, ds1.RemotingFormat, "#1 RemotingFormat is different");
 489                 Assert.AreEqual (ds.DataSetName, ds1.DataSetName, "#2 DataSetName is different");
 490                 Assert.AreEqual (ds.Namespace, ds1.Namespace, "#3 Namespace is different");
 491                 Assert.AreEqual (ds.Prefix, ds1.Prefix, "#4 Prefix is different");
 492                 Assert.AreEqual (ds.CaseSensitive, ds1.CaseSensitive, "#5 CaseSensitive property value is different");
 493                 Assert.AreEqual (ds.Locale.LCID, ds1.Locale.LCID, "#6 DataSet LocaleLCID is different");
 494                 Assert.AreEqual (ds.EnforceConstraints, ds1.EnforceConstraints, "#7 EnforceConstraints property value is different");
 495                 Assert.AreEqual (ds.Tables.Count, ds1.Tables.Count, "#7 Table Count is different");
 496
 497                 //Test Constraints & relations
 498
 499                 //Table1
 500                 Assert.AreEqual (ds.Tables [0].Constraints.Count, ds1.Tables [0].Constraints.Count, "#8 Number of constraint is different for Table :{0}", ds.Tables [0].TableName);
 501
 502                 for (int i = 0; i < ds.Tables [0].Constraints.Count; i++)
 503                         Assert.AreEqual (ds.Tables [0].Constraints [i].GetType (),
 504                                          ds1.Tables [0].Constraints [i].GetType (),
 505                                          "#9 Constraint : {0} is Different", ds.Tables [0].Constraints [i]);
 506
 507                 //Table2
 508                 Assert.AreEqual (ds.Tables [1].Constraints.Count, ds1.Tables [1].Constraints.Count, "#10 Number of constraint is different for Table :{0}", ds.Tables [1].TableName);
 509
 510                 for (int i = 0; i < ds.Tables [1].Constraints.Count; i++)
 511                         Assert.AreEqual (ds.Tables [1].Constraints [i].GetType (),
 512                                          ds1.Tables [1].Constraints [i].GetType (),
 513                                          "#11 Constraint : {0} is Different", ds.Tables [1].Constraints [i]);
 514                 //Relations
 515                 Assert.AreEqual (ds.Relations.Count, ds1.Relations.Count, "#12 Relation count is different");
 516                 for (int i = 0; i < ds.Relations.Count; i++)
 517                         Assert.AreEqual (ds.Relations [i].RelationName, ds1.Relations [i].RelationName, "#13 Relation Name is different for relation :{0}", ds.Relations [i].RelationName);
 518
 519                 for (int i = 0; i < ds.Relations.Count; i++)
 520                         Assert.AreEqual (ds.Relations [i].ParentTable.TableName,
 521                                          ds1.Relations[i].ParentTable.TableName, "#14 Relation Name is different for relation :{0}", ds.Relations [i].ParentTable.TableName);
 522
 523                 for (int i = 0; i < ds.Relations.Count; i++)
 524                         Assert.AreEqual (ds.Relations [i].ChildTable.TableName,
 525                                          ds1.Relations[i].ChildTable.TableName, "#15 Relation Name is different for relation :{0}", ds.Relations [i].ChildTable.TableName);
 526
 527                 //Table Data
 528                 //Table1
 529                 for (int i = 0; i < ds.Tables [0].Rows.Count; i++)
 530                         for (int j = 0; j < ds.Tables [0].Columns.Count; j++) {
 531                                 Assert.AreEqual (ds.Tables [0].Rows [i][j], ds1.Tables [0].Rows [i][j],
 532                                                  "#16 Elements differ at Row :{0} Column :{1}", i, j);
 533                         }
 534                 //Table2
 535                 for (int i = 0; i < ds.Tables [0].Rows.Count; i++)
 536                         for (int j = 0; j < ds.Tables [1].Columns.Count; j++) {
 537                                 Assert.AreEqual (ds.Tables [1].Rows [i][j], ds1.Tables [1].Rows [i][j],
 538                                                  "#17 Elements differ at Row :{0} Column :{1}", i, j);
 539                         }
 540
 541         }
 542         [Test]
 543         public void Constraint_Relations_Test1 ()
 544         {
 545                 //Serialize DataSet
 546                 DataSet ds = new DataSet ();
 547
 548                 DataTable tb1 = new DataTable ();
 549                 tb1.Columns.Add ("id", typeof (int));
 550                 tb1.Columns.Add ("name", typeof (string));
 551                 tb1.Rows.Add (new object[] {1, "A"});
 552                 tb1.Rows.Add (new object[] {2, "B"});
 553                 ds.Tables.Add (tb1);
 554                 //Table2
 555                 DataTable tb2 = new DataTable ();
 556                 tb2.Columns.Add ("eid", typeof (int));
 557                 tb2.Columns.Add ("SSN", typeof (int));
 558                 tb2.Columns.Add ("DOJ", typeof (DateTime));
 559                 tb2.Rows.Add (new object[] {1, 111, "07-25-06"});
 560                 tb2.Rows.Add (new object[] {2, 112, "07-19-06"});
 561                 tb2.Rows.Add (new object[] {3, 113, "07-22-06"});
 562                 ds.Tables.Add (tb2);
 563                 //Table3
 564                 DataTable tb3 = new DataTable ();
 565                 tb3.Columns.Add ("eid", typeof (int));
 566                 tb3.Columns.Add ("Salary", typeof (long));
 567                 tb3.Rows.Add (new object[] {1, 20000});
 568                 tb3.Rows.Add (new object[] {2, 30000});
 569                 ds.Tables.Add (tb3);
 570                 //Table4
 571                 DataTable tb4 = new DataTable ();
 572                 tb4.Columns.Add ("ssn", typeof (int));
 573                 tb4.Columns.Add ("Name", typeof (string));
 574                 tb4.Columns.Add ("DOB", typeof (DateTime));
 575                 tb4.Rows.Add (new object[] {112, "A", "09-12-81"});
 576                 tb4.Rows.Add (new object[] {113, "B", "09-12-82"});
 577                 ds.Tables.Add (tb4);
 578
 579                 //Constraints
 580                 UniqueConstraint uKey = new UniqueConstraint (tb1.Columns ["id"]);
 581                 /*
 582                 DataColumn[] parentColumns = new DataColumn[2];
 583                 parentColumns[0] = tb1.Columns["id"];
 584                 parentColumns[1] = tb1.Columns["name"];
 585                 DataColumn[] childColumns = new DataColumn[2];
 586                 childColumns[0] = tb4.Columns["ssn"];
 587                 childColumns[1] = tb4.Columns["Name"];
 588                 ForeignKeyConstraint fKey1 = new ForeignKeyConstraint(childColumns,
 589                                                                       parentColumns);
 590                 */
 591                 ForeignKeyConstraint fKey1 = new ForeignKeyConstraint (tb2.Columns ["eid"],
 592                                                                         tb1.Columns ["id"]);
 593                 ForeignKeyConstraint fKey2 = new ForeignKeyConstraint (tb2.Columns ["eid"],
 594                                                                         tb3.Columns ["eid"]);
 595                 DataRelation rel = new DataRelation ("Relation1", tb1.Columns ["name"], tb4.Columns ["Name"]);
 596                 DataRelation rel1 = new DataRelation ("Relation2", tb2.Columns ["SSN"], tb4.Columns ["ssn"]);
 597                 tb1.Constraints.Add (uKey);
 598                 tb1.Constraints.Add (fKey1);
 599                 tb3.Constraints.Add (fKey2);
 600                 ds.Relations.Add (rel);
 601                 ds.Relations.Add (rel1);
 602                 ds.AcceptChanges();
 603
 604                 //SerializeDataSet
 605                 MemoryStream ms = new MemoryStream ();
 606                 BinaryFormatter bf = new BinaryFormatter ();
 607                 ds.RemotingFormat = SerializationFormat.Binary;
 608                 bf.Serialize (ms,ds);
 609                 byte [] serializedStream = ms.ToArray ();
 610                 ms.Close();
 611                 //DserializeDataSet
 612                 ms = new MemoryStream (serializedStream);
 613                 DataSet ds1 = (DataSet)bf.Deserialize (ms);
 614                 ms.Close ();
 615                 Assert.AreEqual (ds.Tables.Count, ds1.Tables.Count, "#1 Number of Table differs");
 616                 //Test Constraints
 617                 //Table1
 618                 Assert.AreEqual (ds.Tables [0].Constraints.Count, ds1.Tables [0].Constraints.Count, "#2 Number of Constraints differs in Table :{0}", ds.Tables [0]);
 619                 for (int i = 0; i < ds.Tables [0].Constraints.Count; i++)
 620                         Assert.AreEqual (ds.Tables [0].Constraints [i].GetType (),
 621                                          ds1.Tables [0].Constraints [i].GetType (),
 622                                          "#3 Constraint : {0} is Different", ds.Tables [0].Constraints [i]);
 623                 //Table2
 624                 Assert.AreEqual (ds.Tables [1].Constraints.Count, ds1.Tables [1].Constraints.Count, "#4 Number of Constraints differs in Table :{0}", ds.Tables [1]);
 625                 for (int i = 0; i < ds.Tables [1].Constraints.Count; i++)
 626                         Assert.AreEqual (ds.Tables [1].Constraints [i].GetType (),
 627                                          ds1.Tables [1].Constraints [i].GetType (),
 628                                          "#5 Constraint : {0} is Different", ds.Tables [1].Constraints [i]);
 629                 //Table3
 630                 Assert.AreEqual (ds.Tables [2].Constraints.Count, ds1.Tables [2].Constraints.Count, "#5 Number of Constraints differs in Table :{0}", ds.Tables [2]);
 631                 for (int i = 0; i < ds.Tables [2].Constraints.Count; i++)
 632                         Assert.AreEqual (ds.Tables [2].Constraints [i].GetType (),
 633                                          ds1.Tables [2].Constraints [i].GetType (),
 634                                          "#6 Constraint : {0} is Different", ds.Tables [2].Constraints [i]);
 635                 //Table4
 636                 Assert.AreEqual (ds.Tables [3].Constraints.Count, ds1.Tables [3].Constraints.Count, "#7 Number of Constraints differs in Table :{0}", ds.Tables [3]);
 637                 for (int i = 0; i < ds.Tables [3].Constraints.Count; i++)
 638                         Assert.AreEqual (ds.Tables [3].Constraints [i].GetType (),
 639                                          ds1.Tables [3].Constraints [i].GetType (),
 640                                          "#8 Constraint : {0} is Different", ds.Tables [3].Constraints [i]);
 641                 //Relations
 642                 Assert.AreEqual (ds.Relations.Count, ds1.Relations.Count, "#8 Number of realtions differ");
 643                 for (int i = 0; i < ds.Relations.Count; i++)
 644                         Assert.AreEqual (ds.Relations [i].RelationName, ds.Relations [i].RelationName, "#9 Relation : {0} differs", ds.Relations [i]);
 645         }
 646         [Test]
 647         public void Constraint_Relations_Test2 ()
 648         {
 649                 //Serialize DataSet
 650                 DataSet ds = new DataSet ();
 651
 652                 DataTable tb1 = new DataTable ();
 653                 tb1.Columns.Add ("id", typeof (int));
 654                 tb1.Columns.Add ("name", typeof (string));
 655                 tb1.Rows.Add (new object[] {1, "A"});
 656                 tb1.Rows.Add (new object[] {2, "B"});
 657                 ds.Tables.Add (tb1);
 658                 //Table2
 659                 DataTable tb2 = new DataTable ();
 660                 tb2.Columns.Add ("eid", typeof (int));
 661                 tb2.Columns.Add ("SSN", typeof (int));
 662                 tb2.Columns.Add ("DOJ", typeof (DateTime));
 663                 tb2.Rows.Add (new object[] {1, 111, "07-25-06"});
 664                 tb2.Rows.Add (new object[] {2, 112, "07-19-06"});
 665                 tb2.Rows.Add (new object[] {3, 113, "07-22-06"});
 666                 ds.Tables.Add (tb2);
 667                 //Table3
 668                 DataTable tb3 = new DataTable ();
 669                 tb3.Columns.Add ("eid", typeof (int));
 670                 tb3.Columns.Add ("Salary", typeof (long));
 671                 tb3.Rows.Add (new object[] {1, 20000});
 672                 tb3.Rows.Add (new object[] {2, 30000});
 673                 ds.Tables.Add (tb3);
 674                 //Table4
 675                 DataTable tb4 = new DataTable ();
 676                 tb4.Columns.Add ("ssn", typeof (int));
 677                 tb4.Columns.Add ("Name", typeof (string));
 678                 tb4.Columns.Add ("DOB", typeof (DateTime));
 679                 tb4.Rows.Add (new object[] {112, "A", "09-12-81"});
 680                 tb4.Rows.Add (new object[] {113, "B", "09-12-82"});
 681                 ds.Tables.Add (tb4);
 682
 683                 //Constraints
 684                 UniqueConstraint uKey = new UniqueConstraint (tb1.Columns ["id"]);
 685                 /*
 686                 DataColumn[] parentColumns = new DataColumn[2];
 687                 parentColumns[0] = tb1.Columns["id"];
 688                 parentColumns[1] = tb1.Columns["name"];
 689                 DataColumn[] childColumns = new DataColumn[2];
 690                 childColumns[0] = tb4.Columns["ssn"];
 691                 childColumns[1] = tb4.Columns["Name"];
 692                 ForeignKeyConstraint fKey1 = new ForeignKeyConstraint(childColumns,
 693                                                                       parentColumns);
 694                 */
 695                 ForeignKeyConstraint fKey1 = new ForeignKeyConstraint (tb2.Columns ["eid"],
 696                                                                         tb1.Columns ["id"]);
 697                 ForeignKeyConstraint fKey2 = new ForeignKeyConstraint (tb2.Columns ["eid"],
 698                                                                         tb3.Columns ["eid"]);
 699                 DataRelation rel = new DataRelation ("Relation1", tb1.Columns ["name"], tb4.Columns ["Name"]);
 700                 DataRelation rel1 = new DataRelation ("Relation2", tb2.Columns ["SSN"], tb4.Columns ["ssn"]);
 701                 tb1.Constraints.Add (uKey);
 702                 tb1.Constraints.Add (fKey1);
 703                 tb3.Constraints.Add (fKey2);
 704                 ds.Relations.Add (rel);
 705                 ds.Relations.Add (rel1);
 706                 ds.AcceptChanges();
 707
 708                 //SerializeDataSet
 709                 BinaryFormatter bf = new BinaryFormatter ();
 710                 ds.RemotingFormat = SerializationFormat.Binary;
 711                 FileStream fs = new FileStream ("Test/System.Data/binserialize/BS-tb5.bin", FileMode.Open, FileAccess.Read);
 712                 BinaryReader r = new BinaryReader (fs);
 713                 byte [] serializedStream = r.ReadBytes ((int)fs.Length);
 714                 r.Close ();
 715                 fs.Close ();
 716                 //DserializeDataSet
 717                 MemoryStream ms = new MemoryStream (serializedStream);
 718                 DataSet ds1 = (DataSet)bf.Deserialize (ms);
 719                 ms.Close ();
 720                 Assert.AreEqual (ds.Tables.Count, ds1.Tables.Count, "#1 Number of Table differs");
 721                 //Test Constraints
 722                 //Table1
 723                 Assert.AreEqual (ds.Tables [0].Constraints.Count, ds1.Tables [0].Constraints.Count, "#2 Number of Constraints differs in Table :{0}", ds.Tables [0]);
 724                 for (int i = 0; i < ds.Tables [0].Constraints.Count; i++)
 725                         Assert.AreEqual (ds.Tables [0].Constraints [i].GetType (),
 726                                          ds1.Tables [0].Constraints [i].GetType (),
 727                                          "#3 Constraint : {0} is Different", ds.Tables [0].Constraints [i]);
 728                 //Table2
 729                 Assert.AreEqual (ds.Tables [1].Constraints.Count, ds1.Tables [1].Constraints.Count, "#4 Number of Constraints differs in Table :{0}", ds.Tables [1]);
 730                 for (int i = 0; i < ds.Tables [1].Constraints.Count; i++)
 731                         Assert.AreEqual (ds.Tables [1].Constraints [i].GetType (),
 732                                          ds1.Tables [1].Constraints [i].GetType (),
 733                                          "#5 Constraint : {0} is Different", ds.Tables [1].Constraints [i]);
 734                 //Table3
 735                 Assert.AreEqual (ds.Tables [2].Constraints.Count, ds1.Tables [2].Constraints.Count, "#5 Number of Constraints differs in Table :{0}", ds.Tables [2]);
 736                 for (int i = 0; i < ds.Tables [2].Constraints.Count; i++)
 737                         Assert.AreEqual (ds.Tables [2].Constraints [i].GetType (),
 738                                          ds1.Tables [2].Constraints [i].GetType (),
 739                                          "#6 Constraint : {0} is Different", ds.Tables [2].Constraints [i]);
 740                 //Table4
 741                 Assert.AreEqual (ds.Tables [3].Constraints.Count, ds1.Tables [3].Constraints.Count, "#7 Number of Constraints differs in Table :{0}", ds.Tables [3]);
 742                 for (int i = 0; i < ds.Tables [3].Constraints.Count; i++)
 743                         Assert.AreEqual (ds.Tables [3].Constraints [i].GetType (),
 744                                          ds1.Tables [3].Constraints [i].GetType (),
 745                                          "#8 Constraint : {0} is Different", ds.Tables [3].Constraints [i]);
 746                 //Relations
 747                 Assert.AreEqual (ds.Relations.Count, ds1.Relations.Count, "#8 Number of realtions differ");
 748                 for (int i = 0; i < ds.Relations.Count; i++)
 749                         Assert.AreEqual (ds.Relations [i].RelationName, ds.Relations [i].RelationName, "#9 Relation : {0} differs", ds.Relations [i]);
 750         }
 751 }
 752
 753 #endif