2 // Nagappan A <anagappan@novell.com>
4 // Copyright (c) 2007 Novell, Inc
6 // Permission is hereby granted, free of charge, to any person obtaining
7 // a copy of this software and associated documentation files (the
8 // "Software"), to deal in the Software without restriction, including
9 // without limitation the rights to use, copy, modify, merge, publish,
10 // distribute, sublicense, and/or sell copies of the Software, and to
11 // permit persons to whom the Software is furnished to do so, subject to
12 // the following conditions:
14 // The above copyright notice and this permission notice shall be
15 // included in all copies or substantial portions of the Software.
17 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
21 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
22 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
23 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28 using System.Collections;
31 using NUnit.Framework;
33 namespace MonoTests.System.Data
36 public class DataTableTest4
41 DataTable parentTable1;
43 DataTable secondChildTable;
48 tempFile = Path.GetTempFileName ();
52 public void TearDown ()
55 File.Delete (tempFile);
58 private void MakeParentTable1 ()
61 parentTable1 = new DataTable ("ParentTable");
62 dataSet = new DataSet ("XmlDataSet");
66 // Create new DataColumn, set DataType,
67 // ColumnName and add to Table.
68 column = new DataColumn ();
69 column.DataType = typeof (int);
70 column.ColumnName = "id";
72 // Add the Column to the DataColumnCollection.
73 parentTable1.Columns.Add (column);
75 // Create second column
76 column = new DataColumn ();
77 column.DataType = typeof (string);
78 column.ColumnName = "ParentItem";
79 column.AutoIncrement = false;
80 column.Caption = "ParentItem";
81 column.Unique = false;
82 // Add the column to the table
83 parentTable1.Columns.Add (column);
85 // Create third column.
86 column = new DataColumn ();
87 column.DataType = typeof (int);
88 column.ColumnName = "DepartmentID";
89 column.Caption = "DepartmentID";
90 // Add the column to the table.
91 parentTable1.Columns.Add (column);
93 // Make the ID column the primary key column.
94 DataColumn [] PrimaryKeyColumns = new DataColumn [2];
95 PrimaryKeyColumns [0] = parentTable1.Columns ["id"];
96 PrimaryKeyColumns [1] = parentTable1.Columns ["DepartmentID"];
97 parentTable1.PrimaryKey = PrimaryKeyColumns;
98 dataSet.Tables.Add (parentTable1);
100 // Create three new DataRow objects and add
101 // them to the DataTable
102 for (int i = 0; i <= 2; i++) {
103 row = parentTable1.NewRow ();
105 row ["ParentItem"] = "ParentItem " + (i + 1);
106 row ["DepartmentID"] = i + 1;
107 parentTable1.Rows.Add (row);
111 private void MakeDummyTable ()
113 // Create a new Table
114 dataSet = new DataSet ();
115 dummyTable = new DataTable ("DummyTable");
119 // Create new DataColumn, set DataType,
120 // ColumnName and add to Table.
121 column = new DataColumn ();
122 column.DataType = typeof (int);
123 column.ColumnName = "id";
124 column.Unique = true;
125 // Add the Column to the DataColumnCollection.
126 dummyTable.Columns.Add (column);
128 // Create second column
129 column = new DataColumn ();
130 column.DataType = typeof (string);
131 column.ColumnName = "DummyItem";
132 column.AutoIncrement = false;
133 column.Caption = "DummyItem";
134 column.Unique = false;
135 // Add the column to the table
136 dummyTable.Columns.Add (column);
137 dataSet.Tables.Add (dummyTable);
139 // Create three new DataRow objects and add
140 // them to the DataTable
141 for (int i=0; i<=2; i++) {
142 row = dummyTable.NewRow ();
144 row ["DummyItem"] = "DummyItem " + (i + 1);
145 dummyTable.Rows.Add (row);
148 DataRow row1 = dummyTable.Rows [1];
149 dummyTable.AcceptChanges ();
151 row1 [1] = "Changed_DummyItem " + 2;
155 private void MakeChildTable ()
157 // Create a new Table
158 childTable = new DataTable ("ChildTable");
162 // Create first column and add to the DataTable.
163 column = new DataColumn ();
164 column.DataType= typeof (int);
165 column.ColumnName = "ChildID";
166 column.AutoIncrement = true;
167 column.Caption = "ID";
168 column.Unique = true;
170 // Add the column to the DataColumnCollection
171 childTable.Columns.Add (column);
173 // Create second column
174 column = new DataColumn ();
175 column.DataType= typeof (string);
176 column.ColumnName = "ChildItem";
177 column.AutoIncrement = false;
178 column.Caption = "ChildItem";
179 column.Unique = false;
180 childTable.Columns.Add (column);
182 //Create third column
183 column = new DataColumn ();
184 column.DataType= typeof (int);
185 column.ColumnName = "ParentID";
186 column.AutoIncrement = false;
187 column.Caption = "ParentID";
188 column.Unique = false;
189 childTable.Columns.Add (column);
190 dataSet.Tables.Add (childTable);
192 // Create three sets of DataRow objects,
193 // five rows each, and add to DataTable.
194 for (int i = 0; i <= 1; i ++) {
195 row = childTable.NewRow ();
196 row ["childID"] = i + 1;
197 row ["ChildItem"] = "ChildItem " + (i + 1);
198 row ["ParentID"] = 1 ;
199 childTable.Rows.Add (row);
202 for (int i=0; i<=1; i ++) {
203 row = childTable.NewRow ();
204 row ["childID"] = i + 5;
205 row ["ChildItem"] = "ChildItem " + (i + 1);
206 row ["ParentID"] = 2 ;
207 childTable.Rows.Add (row);
210 for (int i = 0; i <= 1; i ++) {
211 row = childTable.NewRow ();
212 row ["childID"] = i + 10;
213 row ["ChildItem"] = "ChildItem " + (i + 1);
214 row ["ParentID"] = 3 ;
215 childTable.Rows.Add (row);
219 private void MakeSecondChildTable ()
221 // Create a new Table
222 secondChildTable = new DataTable ("SecondChildTable");
226 // Create first column and add to the DataTable.
227 column = new DataColumn ();
228 column.DataType= typeof (int);
229 column.ColumnName = "ChildID";
230 column.AutoIncrement = true;
231 column.Caption = "ID";
232 column.ReadOnly = true;
233 column.Unique = true;
235 // Add the column to the DataColumnCollection.
236 secondChildTable.Columns.Add (column);
238 // Create second column.
239 column = new DataColumn ();
240 column.DataType= typeof (string);
241 column.ColumnName = "ChildItem";
242 column.AutoIncrement = false;
243 column.Caption = "ChildItem";
244 column.ReadOnly = false;
245 column.Unique = false;
246 secondChildTable.Columns.Add (column);
248 //Create third column.
249 column = new DataColumn ();
250 column.DataType= typeof (int);
251 column.ColumnName = "ParentID";
252 column.AutoIncrement = false;
253 column.Caption = "ParentID";
254 column.ReadOnly = false;
255 column.Unique = false;
256 secondChildTable.Columns.Add (column);
258 //Create fourth column.
259 column = new DataColumn ();
260 column.DataType= typeof (int);
261 column.ColumnName = "DepartmentID";
262 column.Caption = "DepartmentID";
263 column.Unique = false;
264 secondChildTable.Columns.Add (column);
265 dataSet.Tables.Add (secondChildTable);
267 // Create three sets of DataRow objects,
268 // five rows each, and add to DataTable.
269 for (int i = 0; i <= 1; i ++) {
270 row = secondChildTable.NewRow ();
271 row ["childID"] = i + 1;
272 row ["ChildItem"] = "SecondChildItem " + (i + 1);
273 row ["ParentID"] = 1 ;
274 row ["DepartmentID"] = 1;
275 secondChildTable.Rows.Add (row);
278 for (int i = 0; i <= 1; i++) {
279 row = secondChildTable.NewRow ();
280 row ["childID"] = i + 5;
281 row ["ChildItem"] = "SecondChildItem " + (i + 1);
282 row ["ParentID"] = 2;
283 row ["DepartmentID"] = 2;
284 secondChildTable.Rows.Add (row);
287 for (int i = 0; i <= 1; i++) {
288 row = secondChildTable.NewRow ();
289 row ["childID"] = i + 10;
290 row ["ChildItem"] = "SecondChildItem " + (i + 1);
291 row ["ParentID"] = 3 ;
292 row ["DepartmentID"] = 3;
293 secondChildTable.Rows.Add (row);
297 private void MakeDataRelation ()
299 DataColumn parentColumn = dataSet.Tables ["ParentTable"].Columns ["id"];
300 DataColumn childColumn = dataSet.Tables ["ChildTable"].Columns ["ParentID"];
301 DataRelation relation = new DataRelation ("ParentChild_Relation1", parentColumn, childColumn);
302 dataSet.Tables ["ChildTable"].ParentRelations.Add (relation);
304 DataColumn [] parentColumn1 = new DataColumn [2];
305 DataColumn [] childColumn1 = new DataColumn [2];
307 parentColumn1 [0] = dataSet.Tables ["ParentTable"].Columns ["id"];
308 parentColumn1 [1] = dataSet.Tables ["ParentTable"].Columns ["DepartmentID"];
310 childColumn1 [0] = dataSet.Tables ["SecondChildTable"].Columns ["ParentID"];
311 childColumn1 [1] = dataSet.Tables ["SecondChildTable"].Columns ["DepartmentID"];
313 DataRelation secondRelation = new DataRelation("ParentChild_Relation2", parentColumn1, childColumn1);
314 dataSet.Tables ["SecondChildTable"].ParentRelations.Add (secondRelation);
317 //Test properties of a table which does not belongs to a DataSet
318 private void VerifyTableSchema (DataTable table, string tableName, DataSet ds)
321 //Check Properties of Table
322 Assert.AreEqual (string.Empty, table.Namespace, "#1");
323 Assert.AreEqual (ds, table.DataSet, "#2");
324 Assert.AreEqual (3, table.Columns.Count, "#3");
325 Assert.AreEqual (false, table.CaseSensitive, "#5");
326 Assert.AreEqual (tableName, table.TableName, "#6");
327 Assert.AreEqual (2, table.Constraints.Count, "#7");
328 Assert.AreEqual (string.Empty, table.Prefix, "#8");
329 Assert.AreEqual ("Constraint2", table.Constraints [0].ToString (), "#9");
330 Assert.AreEqual ("Constraint1", table.Constraints [1].ToString (), "#10");
331 Assert.AreEqual (typeof (UniqueConstraint), table.Constraints [0].GetType (), "#11");
332 Assert.AreEqual (typeof (UniqueConstraint), table.Constraints [1].GetType (), "#12");
333 Assert.AreEqual (2, table.PrimaryKey.Length, "#13");
334 Assert.AreEqual ("id", table.PrimaryKey [0].ToString (), "#14");
335 Assert.AreEqual ("DepartmentID", table.PrimaryKey [1].ToString (), "#15");
336 Assert.AreEqual (0, table.ParentRelations.Count, "#16");
337 Assert.AreEqual (0, table.ChildRelations.Count, "#17");
339 //Check properties of each column
341 DataColumn col = table.Columns [0];
342 Assert.AreEqual (false, col.AllowDBNull, "#18");
343 Assert.AreEqual (false, col.AutoIncrement, "#19");
344 Assert.AreEqual (0, col.AutoIncrementSeed, "#20");
345 Assert.AreEqual (1, col.AutoIncrementStep, "#21");
346 Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#22");
347 Assert.AreEqual ("id", col.Caption, "#23");
348 Assert.AreEqual ("id", col.ColumnName, "#24");
349 Assert.AreEqual ("System.Int32", col.DataType.ToString (), "#25");
350 Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#26");
351 Assert.AreEqual (false, col.DesignMode, "#27");
352 Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#28");
353 Assert.AreEqual (-1, col.MaxLength, "#29");
354 Assert.AreEqual (0, col.Ordinal, "#30");
355 Assert.AreEqual (string.Empty, col.Prefix, "#31");
356 Assert.AreEqual ("ParentTable", col.Table.ToString (), "#32");
357 Assert.AreEqual (true, col.Unique, "#33");
360 col = table.Columns [1];
361 Assert.AreEqual (true, col.AllowDBNull, "#34");
362 Assert.AreEqual (false, col.AutoIncrement, "#35");
363 Assert.AreEqual (0, col.AutoIncrementSeed, "#36");
364 Assert.AreEqual (1, col.AutoIncrementStep, "#37");
365 Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#38");
366 Assert.AreEqual ("ParentItem", col.Caption, "#39");
367 Assert.AreEqual ("ParentItem", col.ColumnName, "#40");
368 Assert.AreEqual ("System.String", col.DataType.ToString (), "#41");
369 Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#42");
370 Assert.AreEqual (false, col.DesignMode, "#43");
371 Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#44");
372 Assert.AreEqual (-1, col.MaxLength, "#45");
373 Assert.AreEqual (1, col.Ordinal, "#46");
374 Assert.AreEqual (string.Empty, col.Prefix, "#47");
375 Assert.AreEqual ("ParentTable", col.Table.ToString (), "#48");
376 Assert.AreEqual (false, col.Unique, "#49");
379 col = table.Columns [2];
380 Assert.AreEqual (false, col.AllowDBNull, "#50");
381 Assert.AreEqual (false, col.AutoIncrement, "#51");
382 Assert.AreEqual (0, col.AutoIncrementSeed, "#52");
383 Assert.AreEqual (1, col.AutoIncrementStep, "#53");
384 Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#54");
385 Assert.AreEqual ("DepartmentID", col.Caption, "#55");
386 Assert.AreEqual ("DepartmentID", col.ColumnName, "#56");
387 Assert.AreEqual ("System.Int32", col.DataType.ToString (), "#57");
388 Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#58");
389 Assert.AreEqual (false, col.DesignMode, "#59");
390 Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#60");
391 Assert.AreEqual (-1, col.MaxLength, "#61");
392 Assert.AreEqual (2, col.Ordinal, "#62");
393 Assert.AreEqual (string.Empty, col.Prefix, "#63");
394 Assert.AreEqual ("ParentTable", col.Table.ToString (), "#64");
395 Assert.AreEqual (false, col.Unique, "#65");
398 Assert.AreEqual (3, table.Rows.Count, "#66");
399 //Test values of each row
400 DataRow row = table.Rows [0];
401 Assert.AreEqual (1, row ["id"], "#67");
402 Assert.AreEqual ("ParentItem 1", row ["ParentItem"], "#68");
403 Assert.AreEqual (1, row ["DepartmentID"], "#69");
405 row = table.Rows [1];
406 Assert.AreEqual (2, row ["id"], "#70");
407 Assert.AreEqual ("ParentItem 2", row ["ParentItem"], "#71");
408 Assert.AreEqual (2, row ["DepartmentID"], "#72");
410 row = table.Rows [2];
411 Assert.AreEqual (3, row ["id"], "#73");
412 Assert.AreEqual ("ParentItem 3", row ["ParentItem"], "#74");
413 Assert.AreEqual (3, row ["DepartmentID"], "#75");
416 private void VerifyTable_WithChildren (DataTable table, string tableName, DataSet ds)
419 //Check Properties of Table
420 Assert.AreEqual (string.Empty, table.Namespace, "#1");
421 Assert.AreEqual (ds.DataSetName, table.DataSet.DataSetName, "#2");
422 Assert.AreEqual (3, table.Columns.Count, "#3");
423 Assert.AreEqual (false, table.CaseSensitive, "#5");
424 Assert.AreEqual (tableName, table.TableName, "#6");
425 Assert.AreEqual (2, table.Constraints.Count, "#7");
426 Assert.AreEqual (string.Empty, table.Prefix, "#8");
427 Assert.AreEqual ("Constraint2", table.Constraints [0].ToString (), "#9");
428 Assert.AreEqual ("Constraint1", table.Constraints [1].ToString (), "#10");
429 Assert.AreEqual ("System.Data.UniqueConstraint", table.Constraints [0].GetType ().ToString (), "#11");
430 Assert.AreEqual ("System.Data.UniqueConstraint", table.Constraints [1].GetType ().ToString (), "#12");
431 Assert.AreEqual (2, table.PrimaryKey.Length, "#13");
432 Assert.AreEqual ("id", table.PrimaryKey [0].ToString (), "#14");
433 Assert.AreEqual ("DepartmentID", table.PrimaryKey [1].ToString (), "#15");
434 Assert.AreEqual (0, table.ParentRelations.Count, "#16");
435 Assert.AreEqual (2, table.ChildRelations.Count, "#17");
437 //Check properties of each column
439 DataColumn col = table.Columns [0];
440 Assert.AreEqual (false, col.AllowDBNull, "#18");
441 Assert.AreEqual (false, col.AutoIncrement, "#19");
442 Assert.AreEqual (0, col.AutoIncrementSeed, "#20");
443 Assert.AreEqual (1, col.AutoIncrementStep, "#21");
444 Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#22");
445 Assert.AreEqual ("id", col.Caption, "#23");
446 Assert.AreEqual ("id", col.ColumnName, "#24");
447 Assert.AreEqual (typeof (int), col.DataType, "#25");
448 Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#26");
449 Assert.AreEqual (false, col.DesignMode, "#27");
450 Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#28");
451 Assert.AreEqual (-1, col.MaxLength, "#29");
452 Assert.AreEqual (0, col.Ordinal, "#30");
453 Assert.AreEqual (string.Empty, col.Prefix, "#31");
454 Assert.AreEqual ("ParentTable", col.Table.ToString (), "#32");
455 Assert.AreEqual (true, col.Unique, "#33");
458 col = table.Columns [1];
459 Assert.AreEqual (true, col.AllowDBNull, "#34");
460 Assert.AreEqual (false, col.AutoIncrement, "#35");
461 Assert.AreEqual (0, col.AutoIncrementSeed, "#36");
462 Assert.AreEqual (1, col.AutoIncrementStep, "#37");
463 Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#38");
464 Assert.AreEqual ("ParentItem", col.Caption, "#39");
465 Assert.AreEqual ("ParentItem", col.ColumnName, "#40");
466 Assert.AreEqual (typeof (string), col.DataType, "#41");
467 Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#42");
468 Assert.AreEqual (false, col.DesignMode, "#43");
469 Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#44");
470 Assert.AreEqual (-1, col.MaxLength, "#45");
471 Assert.AreEqual (1, col.Ordinal, "#46");
472 Assert.AreEqual (string.Empty, col.Prefix, "#47");
473 Assert.AreEqual ("ParentTable", col.Table.ToString (), "#48");
474 Assert.AreEqual (false, col.Unique, "#49");
477 col = table.Columns [2];
478 Assert.AreEqual (false, col.AllowDBNull, "#50");
479 Assert.AreEqual (false, col.AutoIncrement, "#51");
480 Assert.AreEqual (0, col.AutoIncrementSeed, "#52");
481 Assert.AreEqual (1, col.AutoIncrementStep, "#53");
482 Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#54");
483 Assert.AreEqual ("DepartmentID", col.Caption, "#55");
484 Assert.AreEqual ("DepartmentID", col.ColumnName, "#56");
485 Assert.AreEqual (typeof (int), col.DataType, "#57");
486 Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#58");
487 Assert.AreEqual (false, col.DesignMode, "#59");
488 Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#60");
489 Assert.AreEqual (-1, col.MaxLength, "#61");
490 Assert.AreEqual (2, col.Ordinal, "#62");
491 Assert.AreEqual (string.Empty, col.Prefix, "#63");
492 Assert.AreEqual ("ParentTable", col.Table.ToString (), "#64");
493 Assert.AreEqual (false, col.Unique, "#65");
496 Assert.AreEqual (3, table.Rows.Count, "#66");
497 //Test values of each row
498 DataRow row = table.Rows [0];
499 Assert.AreEqual (1, row ["id"], "#67");
500 Assert.AreEqual ("ParentItem 1", row ["ParentItem"], "#68");
501 Assert.AreEqual (1, row ["DepartmentID"], "#69");
503 row = table.Rows [1];
504 Assert.AreEqual (2, row ["id"], "#70");
505 Assert.AreEqual ("ParentItem 2", row ["ParentItem"], "#71");
506 Assert.AreEqual (2, row ["DepartmentID"], "#72");
508 row = table.Rows [2];
509 Assert.AreEqual (3, row ["id"], "#73");
510 Assert.AreEqual ("ParentItem 3", row ["ParentItem"], "#74");
511 Assert.AreEqual (3, row ["DepartmentID"], "#75");
514 private void VerifyDiffGramElement1 (XmlReader reader)
516 //This method checks the properties of the <id> element
517 Assert.AreEqual (true, reader.IsStartElement (), "#1");
518 Assert.AreEqual (3, reader.Depth, "#2");
519 Assert.AreEqual (false, reader.HasAttributes, "#3");
520 Assert.AreEqual (false, reader.HasValue, "#4");
521 Assert.AreEqual (false, reader.IsDefault, "#5");
522 Assert.AreEqual (false, reader.IsEmptyElement, "#6");
523 Assert.AreEqual ("id", reader.Name, "#7");
524 Assert.AreEqual ("id", reader.LocalName, "#8");
525 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#9");
528 private void VerifyDiffGramElement3 (XmlReader reader)
530 //This method checks the property of </id> end elem
531 Assert.AreEqual (false, reader.IsStartElement (), "#1");
532 Assert.AreEqual ("id", reader.Name, "#2");
533 Assert.AreEqual ("id", reader.LocalName, "#3");
534 Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#4");
537 private void VerifyDiffGramElement2 (XmlReader reader)
539 //This method tests the properties of the <DummyItem> elemnent
540 Assert.AreEqual (true, reader.IsStartElement (), "#1");
541 Assert.AreEqual (3, reader.Depth, "#2");
542 Assert.AreEqual (false, reader.HasAttributes, "#3");
543 Assert.AreEqual (false, reader.HasValue, "#4");
544 Assert.AreEqual (false, reader.IsDefault, "#5");
545 Assert.AreEqual (false, reader.IsEmptyElement, "#6");
546 Assert.AreEqual ("DummyItem", reader.Name, "#7");
547 Assert.AreEqual ("DummyItem", reader.LocalName, "#8");
548 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#9");
551 private void VerifyDiffGramElement4 (XmlReader reader)
553 //This method checks the properties of </DummyItem> end element
554 Assert.AreEqual (false, reader.IsStartElement (), "#1");
555 Assert.AreEqual ("DummyItem", reader.Name, "#2");
556 Assert.AreEqual ("DummyItem", reader.LocalName, "#3");
557 Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#4");
560 private void VerifyDiffGramElement5 (XmlReader reader)
562 //This method check the properties of </DummyTable> end element
563 Assert.AreEqual (false, reader.IsStartElement (), "#1");
564 Assert.AreEqual ("DummyTable", reader.Name, "#2");
565 Assert.AreEqual ("DummyTable", reader.LocalName, "#3");
566 Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#4");
570 public void XmlTest1 ()
573 dataSet.Tables.Remove (parentTable1);
575 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
576 //Write the XML without any Schema information
577 parentTable1.WriteXml (stream);
580 DataTable table = new DataTable ();
582 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
584 table.ReadXml (stream);
585 //Should throw an exception if the Xml
586 // File has no schema and target table
587 // too does not define any schema
589 } catch (InvalidOperationException ex) {
590 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
591 Assert.IsNull (ex.InnerException, "#3");
592 Assert.IsNotNull (ex.Message, "#4");
598 public void XmlTest2 ()
600 //Make a table without any relations
602 dataSet.Tables.Remove (parentTable1);
604 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
605 //Write Xml along with the Schema
606 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema);
609 DataTable table = new DataTable ();
610 //Read the Xml and the Schema into a table which does not belongs to any DataSet
611 table.ReadXml (tempFile);
612 VerifyTableSchema (table, parentTable1.TableName, parentTable1.DataSet);
616 public void XmlTest3 ()
618 //Make a table without any Relations
620 dataSet.Tables.Remove (parentTable1);
622 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
623 //Write the Xml and the Schema
624 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema);
627 DataTable table = new DataTable ();
628 dataSet.Tables.Add (table);
630 //Read the Xml and the Schema into a table which already belongs to a DataSet
631 //and the table name does not match with the table ion the source XML
633 table.ReadXml (tempFile);
635 } catch (ArgumentException ex) {
636 // DataTable 'Table1' does not match to any
637 // DataTable in source
638 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
639 Assert.IsNull (ex.InnerException, "#3");
640 Assert.IsNotNull (ex.Message, "#4");
641 Assert.IsTrue (ex.Message.IndexOf ("'Table1'") != -1, "#5");
642 Assert.IsNull (ex.ParamName, "#6");
647 public void XmlTest4 ()
651 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
652 //Here the table belong to a dataset
653 //Write the Xml and the Schema
654 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema);
657 DataTable table = new DataTable ("ParentTable");
658 //Read the Xml and the Schema into a table which already belongs to a DataSet
659 //and the table name matches with the table in the source XML
660 table.ReadXml (tempFile);
661 VerifyTableSchema (table, parentTable1.TableName, null);
665 public void XmlTest5 ()
667 //Create a parent table and create child tables
670 MakeSecondChildTable ();
671 //Relate the parent and the children
674 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
675 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema, false);
678 DataTable table = new DataTable ();
679 table.ReadXml (tempFile);
680 VerifyTableSchema (table, parentTable1.TableName, null);
684 public void XmlTest6 ()
686 //Create a parent table and create child tables
689 MakeSecondChildTable ();
690 //Relate the parent and the children
693 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
694 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema, true);
697 DataTable table = new DataTable ();
698 table.ReadXml (tempFile);
700 VerifyTable_WithChildren (table, parentTable1.TableName, parentTable1.DataSet);
702 //Check Properties of First Child Table
703 DataTable firstChildTable = table.ChildRelations [1].ChildTable;
704 Assert.AreEqual (string.Empty, firstChildTable.Namespace, "#1");
705 Assert.AreEqual ("XmlDataSet", firstChildTable.DataSet.DataSetName, "#2");
706 Assert.AreEqual (3, firstChildTable.Columns.Count, "#3");
707 Assert.AreEqual (typeof (int), firstChildTable.Columns [0].DataType, "#4");
708 Assert.AreEqual (typeof (string), firstChildTable.Columns [1].DataType, "#5");
709 Assert.AreEqual (typeof (int), firstChildTable.Columns [2].DataType, "#6");
710 Assert.AreEqual (6, firstChildTable.Rows.Count, "#7");
711 Assert.AreEqual (false, firstChildTable.CaseSensitive, "#8");
712 Assert.AreEqual ("ChildTable", firstChildTable.TableName, "#9");
713 Assert.AreEqual (string.Empty, firstChildTable.Prefix, "#10");
714 Assert.AreEqual (2, firstChildTable.Constraints.Count, "#11");
715 Assert.AreEqual ("Constraint1", firstChildTable.Constraints [0].ToString (), "#12");
716 Assert.AreEqual ("ParentChild_Relation1", firstChildTable.Constraints [1].ToString (), "#13");
717 Assert.AreEqual (1, firstChildTable.ParentRelations.Count, "#14");
718 Assert.AreEqual ("ParentTable", firstChildTable.ParentRelations [0].ParentTable.TableName, "#15");
719 Assert.AreEqual (0, firstChildTable.ChildRelations.Count, "#16");
720 Assert.AreEqual (0, firstChildTable.PrimaryKey.Length, "#17");
722 //Check Properties of Second Child Table
723 DataTable secondChildTable = table.ChildRelations [0].ChildTable;
724 Assert.AreEqual (string.Empty, secondChildTable.Namespace, "#18");
725 Assert.AreEqual ("XmlDataSet", secondChildTable.DataSet.DataSetName, "#19");
726 Assert.AreEqual (4, secondChildTable.Columns.Count, "#20");
727 Assert.AreEqual (typeof (int), secondChildTable.Columns [0].DataType, "#21");
728 Assert.AreEqual (typeof (string), secondChildTable.Columns [1].DataType, "#22");
729 Assert.AreEqual (typeof (int), secondChildTable.Columns [2].DataType, "#23");
730 Assert.AreEqual (typeof (int), secondChildTable.Columns [3].DataType, "#24");
731 Assert.AreEqual (6, secondChildTable.Rows.Count, "#25");
732 Assert.AreEqual (false, secondChildTable.CaseSensitive, "#26");
733 Assert.AreEqual ("SecondChildTable", secondChildTable.TableName, "#27");
734 Assert.AreEqual (string.Empty, secondChildTable.Prefix, "#28");
735 Assert.AreEqual (2, secondChildTable.Constraints.Count, "#29");
736 Assert.AreEqual ("Constraint1", secondChildTable.Constraints [0].ToString (), "#30");
737 Assert.AreEqual ("ParentChild_Relation2", secondChildTable.Constraints [1].ToString (), "#31");
738 Assert.AreEqual (1, secondChildTable.ParentRelations.Count, "#32");;
739 Assert.AreEqual ("ParentTable", secondChildTable.ParentRelations [0].ParentTable.TableName, "#33");
740 Assert.AreEqual (0, secondChildTable.ChildRelations.Count, "#34");
741 Assert.AreEqual (0, secondChildTable.PrimaryKey.Length, "#35");
745 public void XmlTest7 ()
747 //Create a parent table and create child tables
750 MakeSecondChildTable ();
751 //Relate the parent and the children
754 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
755 //WriteXml on any of the children
756 childTable.WriteXml (stream, XmlWriteMode.WriteSchema, false);
759 DataTable table = new DataTable ();
760 table.ReadXml (tempFile);
763 //Check Properties of Table
764 Assert.AreEqual (string.Empty, table.Namespace, "#1");
765 Assert.AreEqual (null, table.DataSet, "#2");
766 Assert.AreEqual (3, table.Columns.Count, "#3");
767 Assert.AreEqual (false, table.CaseSensitive, "#5");
768 Assert.AreEqual ("ChildTable", table.TableName, "#6");
769 Assert.AreEqual (string.Empty, table.Prefix, "#7");
770 Assert.AreEqual (1, table.Constraints.Count, "#8");
771 Assert.AreEqual ("Constraint1", table.Constraints [0].ToString (), "#9");
772 Assert.AreEqual (typeof (UniqueConstraint), table.Constraints [0].GetType (), "#10");
773 Assert.AreEqual (0, table.PrimaryKey.Length, "#11");
774 Assert.AreEqual (0, table.ParentRelations.Count, "#12");
775 Assert.AreEqual (0, table.ChildRelations.Count, "#13");
778 //Check properties of each column
780 DataColumn col = table.Columns [0];
781 Assert.AreEqual (true, col.AllowDBNull, "#14");
782 Assert.AreEqual (0, col.AutoIncrementSeed, "#15");
783 Assert.AreEqual (1, col.AutoIncrementStep, "#16");
784 Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#17");
785 Assert.AreEqual ("ID", col.Caption, "#18");
786 Assert.AreEqual ("ChildID", col.ColumnName, "#19");
787 Assert.AreEqual (typeof (int), col.DataType, "#20");
788 Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#21");
789 Assert.AreEqual (false, col.DesignMode, "#22");
790 Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#23");
791 Assert.AreEqual (-1, col.MaxLength, "#24");
792 Assert.AreEqual (0, col.Ordinal, "#25");
793 Assert.AreEqual (string.Empty, col.Prefix, "#26");
794 Assert.AreEqual ("ChildTable", col.Table.ToString (), "#27");
795 Assert.AreEqual (true, col.Unique, "#28");
798 col = table.Columns [1];
799 Assert.AreEqual (true, col.AllowDBNull, "#29");
800 Assert.AreEqual (0, col.AutoIncrementSeed, "#30");
801 Assert.AreEqual (1, col.AutoIncrementStep, "#31");
802 Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#32");
803 Assert.AreEqual ("ChildItem", col.Caption, "#33");
804 Assert.AreEqual ("ChildItem", col.ColumnName, "#34");
805 Assert.AreEqual (typeof (string), col.DataType, "#35");
806 Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#36");
807 Assert.AreEqual (false, col.DesignMode, "#37");
808 Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#38");
809 Assert.AreEqual (-1, col.MaxLength, "#39");
810 Assert.AreEqual (1, col.Ordinal, "#40");
811 Assert.AreEqual (string.Empty, col.Prefix, "#41");
812 Assert.AreEqual ("ChildTable", col.Table.ToString (), "#42");
813 Assert.AreEqual (false, col.Unique, "#43");
816 col = table.Columns [2];
817 Assert.AreEqual (true, col.AllowDBNull, "#44");
818 Assert.AreEqual (false, col.AutoIncrement, "#45");
819 Assert.AreEqual (0, col.AutoIncrementSeed, "#46");
820 Assert.AreEqual (1, col.AutoIncrementStep, "#47");
821 Assert.AreEqual ("Element", col.ColumnMapping.ToString (), "#48");
822 Assert.AreEqual ("ParentID", col.Caption, "#49");
823 Assert.AreEqual ("ParentID", col.ColumnName, "#50");
824 Assert.AreEqual (typeof (int), col.DataType, "#51");
825 Assert.AreEqual (string.Empty, col.DefaultValue.ToString (), "#52");
826 Assert.AreEqual (false, col.DesignMode, "#53");
827 Assert.AreEqual ("System.Data.PropertyCollection", col.ExtendedProperties.ToString (), "#54");
828 Assert.AreEqual (-1, col.MaxLength, "#55");
829 Assert.AreEqual (2, col.Ordinal, "#56");
830 Assert.AreEqual (string.Empty, col.Prefix, "#57");
831 Assert.AreEqual ("ChildTable", col.Table.ToString (), "#58");
832 Assert.AreEqual (false, col.Unique, "#59");
835 Assert.AreEqual (6, table.Rows.Count, "#60");
837 //Test values of each row
838 DataRow row = table.Rows [0];
839 Assert.AreEqual (1, row ["ChildID"], "#61");
840 Assert.AreEqual ("ChildItem 1", row ["ChildItem"], "#62");
841 Assert.AreEqual (1, row ["ParentID"], "#63");
843 row = table.Rows [1];
844 Assert.AreEqual (2, row ["ChildID"], "#64");
845 Assert.AreEqual ("ChildItem 2", row ["ChildItem"], "#65");
846 Assert.AreEqual (1, row ["ParentID"], "#66");
848 row = table.Rows [2];
849 Assert.AreEqual (5, row ["ChildID"], "#67");
850 Assert.AreEqual ("ChildItem 1", row ["ChildItem"], "#68");
851 Assert.AreEqual (2, row ["ParentID"], "#69");
853 row = table.Rows [3];
854 Assert.AreEqual (6, row ["ChildID"], "#70");
855 Assert.AreEqual ("ChildItem 2", row ["ChildItem"], "#71");
856 Assert.AreEqual (2, row ["ParentID"], "#72");
858 row = table.Rows [4];
859 Assert.AreEqual (10, row ["ChildID"], "#73");
860 Assert.AreEqual ("ChildItem 1", row ["ChildItem"], "#74");
861 Assert.AreEqual (3, row ["ParentID"], "#75");
863 row = table.Rows [5];
864 Assert.AreEqual (11, row ["ChildID"], "#75");
865 Assert.AreEqual ("ChildItem 2", row ["ChildItem"], "#76");
866 Assert.AreEqual (3, row ["ParentID"], "#77");
870 public void XmlTest8 ()
874 MakeSecondChildTable ();
875 //Relate the parent and the children
878 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
880 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema, false);
883 DataSet ds = new DataSet ();
884 ds.ReadXml (tempFile);
886 Assert.AreEqual (1, ds.Tables.Count, "#1");
887 Assert.AreEqual ("ParentTable", ds.Tables [0].TableName, "#2");
888 DataTable table = ds.Tables [0];
890 Assert.AreEqual (3, table.Rows.Count, "#3");
891 //Test values of each row
892 DataRow row = table.Rows [0];
893 Assert.AreEqual ("1", row ["id"], "#4");
894 Assert.AreEqual ("ParentItem 1", row ["ParentItem"], "#5");
895 Assert.AreEqual ("1", row ["DepartmentID"], "#6");
897 row = table.Rows [1];
898 Assert.AreEqual ("2", row ["id"], "#7");
899 Assert.AreEqual ("ParentItem 2", row ["ParentItem"], "#8");
900 Assert.AreEqual ("2", row ["DepartmentID"], "#9");
902 row = table.Rows [2];
903 Assert.AreEqual ("3", row ["id"], "#10");
904 Assert.AreEqual ("ParentItem 3", row ["ParentItem"], "#11");
905 Assert.AreEqual ("3", row ["DepartmentID"], "#12");
909 public void XmlTest9 ()
913 MakeSecondChildTable ();
914 //Relate the parent and the children
917 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
919 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema, true);
922 DataSet ds = new DataSet ();
923 ds.ReadXml (tempFile);
925 Assert.AreEqual (3, ds.Tables.Count, "#1");
926 Assert.AreEqual ("ParentTable", ds.Tables [0].TableName, "#2");
927 Assert.AreEqual ("ChildTable", ds.Tables [1].TableName, "#3");
928 Assert.AreEqual ("SecondChildTable", ds.Tables [2].TableName, "#4");
930 //get the first table
931 DataTable table = ds.Tables [0];
932 Assert.AreEqual (3, table.Rows.Count, "#5");
934 DataRow row = table.Rows [0];
935 Assert.AreEqual ("1", row ["id"], "#6");
936 Assert.AreEqual ("ParentItem 1", row ["ParentItem"], "#7");
937 Assert.AreEqual ("1", row ["DepartmentID"], "#8");
939 row = table.Rows [1];
940 Assert.AreEqual ("2", row ["id"], "#9");
941 Assert.AreEqual ("ParentItem 2", row ["ParentItem"], "#10");
942 Assert.AreEqual ("2", row ["DepartmentID"], "#11");
944 row = table.Rows [2];
945 Assert.AreEqual ("3", row ["id"], "#12");
946 Assert.AreEqual ("ParentItem 3", row ["ParentItem"], "#13");
947 Assert.AreEqual ("3", row ["DepartmentID"], "#14");
949 //get the second table
950 table = ds.Tables [1];
951 Assert.AreEqual (6, table.Rows.Count);
953 row = table.Rows [0];
954 Assert.AreEqual ("1", row ["ChildID"], "#15");
955 Assert.AreEqual ("ChildItem 1", row ["ChildItem"], "#16");
956 Assert.AreEqual ("1", row ["ParentID"], "#17");
958 row = table.Rows [1];
959 Assert.AreEqual ("2", row ["ChildID"], "#18");
960 Assert.AreEqual ("ChildItem 2", row ["ChildItem"], "#19");
961 Assert.AreEqual ("1", row ["ParentID"], "#20");
963 row = table.Rows [2];
964 Assert.AreEqual ("5", row ["ChildID"], "#21");
965 Assert.AreEqual ("ChildItem 1", row ["ChildItem"], "#22");
966 Assert.AreEqual ("2", row ["ParentID"], "#23");
968 row = table.Rows [3];
969 Assert.AreEqual ("6", row ["ChildID"], "#24");
970 Assert.AreEqual ("ChildItem 2", row ["ChildItem"], "#25");
971 Assert.AreEqual ("2", row ["ParentID"], "#26");
973 row = table.Rows [4];
974 Assert.AreEqual ("10", row ["ChildID"], "#27");
975 Assert.AreEqual ("ChildItem 1", row ["ChildItem"], "#28");
976 Assert.AreEqual ("3", row ["ParentID"], "#29");
978 row = table.Rows [5];
979 Assert.AreEqual ("11", row ["ChildID"], "#30");
980 Assert.AreEqual ("ChildItem 2", row ["ChildItem"], "#31");
981 Assert.AreEqual ("3", row ["ParentID"], "#32");
983 //get the third table
984 table = ds.Tables [2];
985 Assert.AreEqual (6, table.Rows.Count);
987 row = table.Rows [0];
988 Assert.AreEqual ("1", row ["ChildID"], "#33");
989 Assert.AreEqual ("SecondChildItem 1", row ["ChildItem"], "#34");
990 Assert.AreEqual ("1", row ["ParentID"], "#35");
991 Assert.AreEqual ("1", row ["DepartmentID"], "#36");
993 row = table.Rows [1];
994 Assert.AreEqual ("2", row ["ChildID"], "#37");
995 Assert.AreEqual ("SecondChildItem 2", row ["ChildItem"], "#38");
996 Assert.AreEqual ("1", row ["ParentID"], "#39");
997 Assert.AreEqual ("1", row ["DepartmentID"], "#40");
999 row = table.Rows [2];
1000 Assert.AreEqual ("5", row ["ChildID"], "#41");
1001 Assert.AreEqual ("SecondChildItem 1", row ["ChildItem"], "#42");
1002 Assert.AreEqual ("2", row ["ParentID"], "#43");
1003 Assert.AreEqual ("2", row ["DepartmentID"], "#44");
1005 row = table.Rows [3];
1006 Assert.AreEqual ("6", row ["ChildID"], "#45");
1007 Assert.AreEqual ("SecondChildItem 2", row ["ChildItem"], "#46");
1008 Assert.AreEqual ("2", row ["ParentID"], "#47");
1009 Assert.AreEqual ("2", row ["DepartmentID"], "#48");
1011 row = table.Rows [4];
1012 Assert.AreEqual ("10", row ["ChildID"], "#49");
1013 Assert.AreEqual ("SecondChildItem 1", row ["ChildItem"], "#50");
1014 Assert.AreEqual ("3", row ["ParentID"], "#51");
1015 Assert.AreEqual ("3", row ["DepartmentID"], "#52");
1017 row = table.Rows [5];
1018 Assert.AreEqual ("11", row ["ChildID"], "#53");
1019 Assert.AreEqual ("SecondChildItem 2", row ["ChildItem"], "#54");
1020 Assert.AreEqual ("3", row ["ParentID"], "#55");
1021 Assert.AreEqual ("3", row ["DepartmentID"], "#56");
1025 public void XmlTest10 ()
1029 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1030 dummyTable.WriteXml (stream, XmlWriteMode.DiffGram);
1033 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1034 XmlReaderSettings settings = new XmlReaderSettings ();
1035 settings.IgnoreWhitespace = true;
1036 XmlReader reader = XmlReader.Create (stream, settings);
1039 Assert.AreEqual (true, reader.IsStartElement (), "#1");
1040 Assert.AreEqual (0, reader.Depth, "#2");
1041 Assert.AreEqual (true, reader.HasAttributes, "#3");
1042 Assert.AreEqual (false, reader.HasValue, "#4");
1043 Assert.AreEqual (false, reader.IsDefault, "#5");
1044 Assert.AreEqual (false, reader.IsEmptyElement, "#6");
1045 Assert.AreEqual ("diffgr:diffgram", reader.Name, "#7");
1046 Assert.AreEqual ("diffgram", reader.LocalName, "#8");
1047 Assert.AreEqual (2, reader.AttributeCount, "#9");
1048 Assert.AreEqual ("urn:schemas-microsoft-com:xml-msdata", reader [0], "#10");
1049 Assert.AreEqual ("urn:schemas-microsoft-com:xml-diffgram-v1", reader [1], "#11");
1050 Assert.AreEqual ("urn:schemas-microsoft-com:xml-diffgram-v1", reader.NamespaceURI, "#12");
1051 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#13");
1054 Assert.AreEqual (true, reader.IsStartElement (), "#14");
1055 Assert.AreEqual (1, reader.Depth, "#15");
1056 Assert.AreEqual (false, reader.HasAttributes, "#16");
1057 Assert.AreEqual (false, reader.HasValue, "#17");
1058 Assert.AreEqual (false, reader.IsDefault, "#18");
1059 Assert.AreEqual (false, reader.IsEmptyElement, "#19");
1060 Assert.AreEqual ("NewDataSet", reader.Name, "#20");
1061 Assert.AreEqual ("NewDataSet", reader.LocalName, "#21");
1062 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#22");
1065 Assert.AreEqual (true, reader.IsStartElement (), "#23");
1066 Assert.AreEqual (2, reader.Depth, "#24");
1067 Assert.AreEqual (true, reader.HasAttributes, "#25");
1068 Assert.AreEqual (false, reader.HasValue, "#26");
1069 Assert.AreEqual (false, reader.IsDefault, "#27");
1070 Assert.AreEqual (false, reader.IsEmptyElement, "#28");
1071 Assert.AreEqual ("DummyTable", reader.Name, "#29");
1072 Assert.AreEqual ("DummyTable", reader.LocalName, "#30");
1073 Assert.AreEqual (2, reader.AttributeCount, "#31");
1074 Assert.AreEqual ("DummyTable1", reader [0], "#32");
1075 Assert.AreEqual ("0", reader [1], "#33");
1076 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#34");
1079 VerifyDiffGramElement1 (reader);
1082 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#35");
1083 Assert.AreEqual (true, reader.HasValue, "#36");
1084 Assert.AreEqual ("1", reader.Value, "#37");
1087 VerifyDiffGramElement3 (reader);
1090 VerifyDiffGramElement2 (reader);
1093 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#38");
1094 Assert.AreEqual (true, reader.HasValue, "#39");
1095 Assert.AreEqual ("DummyItem 1", reader.Value, "#40");
1098 Assert.AreEqual (false, reader.IsStartElement (), "#41");
1099 Assert.AreEqual ("DummyItem", reader.Name, "#42");
1100 Assert.AreEqual ("DummyItem", reader.LocalName, "#43");
1101 Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#44");
1104 Assert.AreEqual (false, reader.IsStartElement (), "#45");
1105 Assert.AreEqual ("DummyTable", reader.Name, "#46");
1106 Assert.AreEqual ("DummyTable", reader.LocalName, "#47");
1107 Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#48");
1110 Assert.AreEqual (true, reader.IsStartElement (), "#49");
1111 Assert.AreEqual (2, reader.Depth, "#50");
1112 Assert.AreEqual (true, reader.HasAttributes, "#51");
1113 Assert.AreEqual (false, reader.HasValue, "#52");
1114 Assert.AreEqual (false, reader.IsDefault, "#53");
1115 Assert.AreEqual (false, reader.IsEmptyElement, "#54");
1116 Assert.AreEqual ("DummyTable", reader.Name, "#55");
1117 Assert.AreEqual ("DummyTable", reader.LocalName, "#56");
1118 Assert.AreEqual (3, reader.AttributeCount, "#57");
1119 Assert.AreEqual ("DummyTable2", reader [0], "#58");
1120 Assert.AreEqual ("1", reader [1], "#59");
1121 Assert.AreEqual ("modified", reader [2], "#60");
1122 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#61");
1125 VerifyDiffGramElement1 (reader);
1128 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#62");
1129 Assert.AreEqual (true, reader.HasValue, "#63");
1130 Assert.AreEqual ("2", reader.Value, "#64");
1133 VerifyDiffGramElement3 (reader);
1136 VerifyDiffGramElement2 (reader);
1139 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#65");
1140 Assert.AreEqual (true, reader.HasValue, "#66");
1141 Assert.AreEqual ("Changed_DummyItem 2", reader.Value, "#67");
1144 VerifyDiffGramElement4 (reader);
1147 VerifyDiffGramElement5 (reader);
1150 Assert.AreEqual (true, reader.IsStartElement (), "#68");
1151 Assert.AreEqual (2, reader.Depth, "#69");
1152 Assert.AreEqual (true, reader.HasAttributes, "#70");
1153 Assert.AreEqual (false, reader.HasValue, "#71");
1154 Assert.AreEqual (false, reader.IsDefault, "#72");
1155 Assert.AreEqual (false, reader.IsEmptyElement, "#73");
1156 Assert.AreEqual ("DummyTable", reader.Name, "#74");
1157 Assert.AreEqual ("DummyTable", reader.LocalName, "#75");
1158 Assert.AreEqual (2, reader.AttributeCount, "#76");
1159 Assert.AreEqual ("DummyTable3", reader [0], "#77");
1160 Assert.AreEqual ("2", reader [1], "#78");
1161 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#79");
1164 VerifyDiffGramElement1 (reader);
1167 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#80");
1168 Assert.AreEqual (true, reader.HasValue, "#81");
1169 Assert.AreEqual ("3", reader.Value, "#82");
1172 VerifyDiffGramElement3 (reader);
1175 VerifyDiffGramElement2 (reader);
1179 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#83");
1180 Assert.AreEqual (true, reader.HasValue, "#84");
1181 Assert.AreEqual ("DummyItem 3", reader.Value, "#85");
1184 VerifyDiffGramElement4 (reader);
1187 VerifyDiffGramElement5 (reader);
1190 Assert.AreEqual (false, reader.IsStartElement (), "#86");
1191 Assert.AreEqual ("NewDataSet", reader.Name, "#87");
1192 Assert.AreEqual ("NewDataSet", reader.LocalName, "#88");
1193 Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#89");
1196 Assert.AreEqual (true, reader.IsStartElement (), "#90");
1197 Assert.AreEqual (1, reader.Depth, "#91");
1198 Assert.AreEqual (false, reader.HasAttributes, "#92");
1199 Assert.AreEqual (false, reader.HasValue, "#93");
1200 Assert.AreEqual (false, reader.IsDefault, "#94");
1201 Assert.AreEqual (false, reader.IsEmptyElement, "#95");
1202 Assert.AreEqual ("diffgr:before", reader.Name, "#96");
1203 Assert.AreEqual ("before", reader.LocalName, "#97");
1204 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#98");
1207 Assert.AreEqual (true, reader.IsStartElement (), "#99");
1208 Assert.AreEqual (2, reader.Depth, "#100");
1209 Assert.AreEqual (true, reader.HasAttributes, "#101");
1210 Assert.AreEqual (false, reader.HasValue, "#102");
1211 Assert.AreEqual (false, reader.IsDefault, "#103");
1212 Assert.AreEqual (false, reader.IsEmptyElement, "#104");
1213 Assert.AreEqual ("DummyTable", reader.Name, "#105");
1214 Assert.AreEqual ("DummyTable", reader.LocalName, "#106");
1215 Assert.AreEqual (2, reader.AttributeCount, "#107");
1216 Assert.AreEqual ("DummyTable2", reader [0], "#108");
1217 Assert.AreEqual ("1", reader [1], "#109");
1218 Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#110");
1221 VerifyDiffGramElement1 (reader);
1224 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#111");
1225 Assert.AreEqual (true, reader.HasValue, "#112");
1226 Assert.AreEqual ("2", reader.Value, "#113");
1229 VerifyDiffGramElement3 (reader);
1232 VerifyDiffGramElement2 (reader);
1235 Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#114");
1236 Assert.AreEqual (true, reader.HasValue, "#115");
1237 Assert.AreEqual ("DummyItem 2", reader.Value, "#116");
1240 VerifyDiffGramElement4 (reader);
1243 VerifyDiffGramElement5 (reader);
1246 Assert.AreEqual (false, reader.IsStartElement (), "#117");
1247 Assert.AreEqual ("diffgr:before", reader.Name, "#118");
1248 Assert.AreEqual ("before", reader.LocalName, "#119");
1249 Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#120");
1252 Assert.AreEqual (false, reader.IsStartElement (), "#121");
1253 Assert.AreEqual ("diffgr:diffgram", reader.Name, "#122");
1254 Assert.AreEqual ("diffgram", reader.LocalName, "#123");
1255 Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#124");
1260 public void XmlTest11 ()
1262 MakeParentTable1 ();
1264 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1265 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema);
1268 XmlReadMode mode = XmlReadMode.Auto;
1269 DataTable table = new DataTable ();
1270 table.Columns.Add (new DataColumn ("id", typeof (int)));
1272 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1273 //This should not read anything as table name is not set
1274 mode = table.ReadXml (stream);
1277 Assert.AreEqual (XmlReadMode.IgnoreSchema, mode, "#1");
1278 Assert.AreEqual (String.Empty, table.TableName, "#2");
1279 Assert.AreEqual (0, table.Rows.Count, "#3");
1280 Assert.AreEqual (1, table.Columns.Count, "#4");
1281 Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#5");
1282 Assert.IsNull (table.DataSet, "#6");
1286 public void XmlTest12 ()
1288 MakeParentTable1 ();
1290 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1291 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema);
1294 DataTable table = new DataTable ("Table1");
1295 XmlReadMode mode = XmlReadMode.Auto;
1296 table.Columns.Add (new DataColumn ("id", typeof (int)));
1298 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1299 //Same as last test. ReadXml does not read anything as table names dont match
1300 mode = table.ReadXml (stream);
1303 Assert.AreEqual (XmlReadMode.IgnoreSchema, mode, "#1");
1304 Assert.AreEqual ("Table1", table.TableName, "#2");
1305 Assert.AreEqual (0, table.Rows.Count, "#3");
1306 Assert.AreEqual (1, table.Columns.Count, "#4");
1307 Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#5");
1308 Assert.IsNull (table.DataSet, "#6");
1312 public void XmlTest13 ()
1314 MakeParentTable1 ();
1316 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1317 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema);
1320 DataTable table = new DataTable ("ParentTable");
1321 XmlReadMode mode = XmlReadMode.Auto;
1322 table.Columns.Add (new DataColumn ("id", typeof (string)));
1324 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1325 mode = table.ReadXml (stream);
1328 Assert.AreEqual (XmlReadMode.IgnoreSchema, mode, "#1");
1329 Assert.AreEqual ("ParentTable", table.TableName, "#2");
1330 Assert.AreEqual (3, table.Rows.Count, "#3");
1331 Assert.AreEqual (1, table.Columns.Count, "#4");
1332 Assert.AreEqual (typeof (string), table.Columns [0].DataType, "#5");
1333 Assert.IsNull (table.DataSet, "#6");
1336 DataRow row = table.Rows [0];
1337 Assert.AreEqual ("1", row [0], "#7");
1339 row = table.Rows [1];
1340 Assert.AreEqual ("2", row [0], "#8");
1342 row = table.Rows [2];
1343 Assert.AreEqual ("3", row [0], "#9");
1347 public void XmlTest14 ()
1349 MakeParentTable1 ();
1351 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1352 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema);
1355 //Create a target table which has nomatching column(s) names
1356 DataTable table = new DataTable ("ParentTable");
1357 XmlReadMode mode = XmlReadMode.Auto;
1358 table.Columns.Add (new DataColumn ("sid", typeof (string)));
1360 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1361 //ReadXml does not read anything as the column names are not matching
1362 mode = table.ReadXml (stream);
1365 Assert.AreEqual (XmlReadMode.IgnoreSchema, mode, "#1");
1366 Assert.AreEqual ("ParentTable", table.TableName, "#2");
1367 Assert.AreEqual (3, table.Rows.Count, "#3");
1368 Assert.AreEqual (1, table.Columns.Count, "#4");
1369 Assert.AreEqual ("sid", table.Columns [0].ColumnName, "#5");
1370 Assert.AreEqual (typeof (string), table.Columns [0].DataType, "#6");
1371 Assert.IsNull (table.DataSet, "#7");
1374 foreach (DataRow row in table.Rows)
1375 Assert.AreEqual (DBNull.Value, row [0], "#8");
1379 public void XmlTest15 ()
1381 MakeParentTable1 ();
1383 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1384 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema);
1387 //Create a target table which has matching column(s) name and an extra column
1388 DataTable table = new DataTable ("ParentTable");
1389 XmlReadMode mode = XmlReadMode.Auto;
1390 table.Columns.Add (new DataColumn ("id", typeof (int)));
1391 table.Columns.Add (new DataColumn ("ParentItem", typeof (string)));
1392 table.Columns.Add (new DataColumn ("DepartmentID", typeof (int)));
1393 table.Columns.Add (new DataColumn ("DummyColumn", typeof (string)));
1395 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1396 mode = table.ReadXml (stream);
1399 Assert.AreEqual (XmlReadMode.IgnoreSchema, mode, "#1");
1400 Assert.AreEqual ("ParentTable", table.TableName, "#2");
1401 Assert.AreEqual (3, table.Rows.Count, "#3");
1402 Assert.AreEqual (4, table.Columns.Count, "#4");
1403 Assert.IsNull (table.DataSet, "#5");
1406 Assert.AreEqual ("id", table.Columns [0].ColumnName, "#6");
1407 Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#7");
1409 Assert.AreEqual ("ParentItem", table.Columns [1].ColumnName, "#8");
1410 Assert.AreEqual (typeof (string), table.Columns [1].DataType, "#9");
1412 Assert.AreEqual ("DepartmentID", table.Columns [2].ColumnName, "#10");
1413 Assert.AreEqual (typeof (int), table.Columns [2].DataType, "#11");
1415 Assert.AreEqual ("DummyColumn", table.Columns [3].ColumnName, "#12");
1416 Assert.AreEqual (typeof (string), table.Columns [3].DataType, "#13");
1419 DataRow row = table.Rows [0];
1420 Assert.AreEqual (1, row ["id"], "#14");
1421 Assert.AreEqual ("ParentItem 1", row ["ParentItem"], "#15");
1422 Assert.AreEqual (1, row ["DepartmentID"], "#16");
1423 Assert.AreEqual (DBNull.Value, row ["DummyColumn"], "#17");
1425 row = table.Rows [1];
1426 Assert.AreEqual (2, row ["id"], "#18");
1427 Assert.AreEqual ("ParentItem 2", row ["ParentItem"], "#19");
1428 Assert.AreEqual (2, row ["DepartmentID"], "#20");
1429 Assert.AreEqual (DBNull.Value, row ["DummyColumn"], "#21");
1431 row = table.Rows [2];
1432 Assert.AreEqual (3, row ["id"], "#22");
1433 Assert.AreEqual ("ParentItem 3", row ["ParentItem"], "#23");
1434 Assert.AreEqual (3, row ["DepartmentID"], "#24");
1435 Assert.AreEqual (DBNull.Value, row ["DummyColumn"], "#25");
1439 public void XmlTest16 ()
1441 MakeParentTable1 ();
1443 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1444 //Write the Xml with schema information
1445 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema);
1448 XmlReadMode mode = XmlReadMode.Auto ;
1449 DataTable table = new DataTable ();
1450 table.Columns.Add (new DataColumn ("id", typeof (int)));
1452 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1453 mode = table.ReadXml (stream);
1456 Assert.AreEqual (XmlReadMode.ReadSchema, mode, "#1");
1457 Assert.AreEqual (String.Empty, table.TableName, "#2");
1458 Assert.AreEqual (0, table.Rows.Count, "#3");
1459 Assert.AreEqual (1, table.Columns.Count, "#4");
1460 Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#5");
1461 Assert.IsNull (table.DataSet, "#6");
1465 public void XmlTest17 ()
1467 MakeParentTable1 ();
1469 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1470 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema);
1473 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1474 DataTable table = new DataTable ("Table1");
1475 table.Columns.Add (new DataColumn ("id", typeof (int)));
1478 table.ReadXml (stream);
1480 } catch (ArgumentException ex) {
1481 // DataTable 'Table1' does not match to
1482 // any DataTable in source
1483 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1484 Assert.IsNull (ex.InnerException, "#3");
1485 Assert.IsNotNull (ex.Message, "#4");
1486 Assert.IsTrue (ex.Message.IndexOf ("'Table1'") != -1, "#5");
1487 Assert.IsNull (ex.ParamName, "#6");
1493 public void XmlTest18 ()
1495 MakeParentTable1 ();
1497 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1498 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema);
1501 DataTable table = new DataTable ("ParentTable");
1502 XmlReadMode mode = XmlReadMode.Auto;
1503 table.Columns.Add (new DataColumn ("id", typeof (int)));
1504 table.Columns.Add (new DataColumn ("DepartmentID", typeof (int)));
1506 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1507 mode = table.ReadXml (stream);
1510 Assert.AreEqual (XmlReadMode.ReadSchema, mode, "#1");
1511 Assert.AreEqual ("ParentTable", table.TableName, "#2");
1512 Assert.AreEqual (3, table.Rows.Count, "#3");
1513 Assert.AreEqual (2, table.Columns.Count, "#4");
1514 Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#5");
1515 Assert.AreEqual (typeof (int), table.Columns [1].DataType, "#6");
1516 Assert.IsNull (table.DataSet, "#6");
1519 DataRow row = table.Rows [0];
1520 Assert.AreEqual (1, row [0], "#7");
1521 Assert.AreEqual (1, row [1], "#8");
1523 row = table.Rows [1];
1524 Assert.AreEqual (2, row [0], "#9");
1525 Assert.AreEqual (2, row [1], "#10");
1527 row = table.Rows [2];
1528 Assert.AreEqual (3, row [0], "#11");
1529 Assert.AreEqual (3, row [1], "#12");
1533 public void XmlTest19 ()
1535 MakeParentTable1 ();
1537 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1538 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema);
1541 DataSet ds = new DataSet ();
1542 DataTable table = new DataTable ();
1543 XmlReadMode mode = XmlReadMode.Auto;
1544 table.Columns.Add (new DataColumn ("id", typeof (int)));
1545 ds.Tables.Add (table);
1547 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1548 //ReadXml wont read anything as TableNames dont match
1549 mode = table.ReadXml (stream);
1552 Assert.AreEqual (XmlReadMode.IgnoreSchema, mode, "#1");
1553 Assert.AreEqual ("Table1", table.TableName, "#2");
1554 Assert.AreEqual (0, table.Rows.Count, "#3");
1555 Assert.AreEqual (1, table.Columns.Count, "#4");
1556 Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#5");
1557 Assert.AreEqual ("System.Data.DataSet", table.DataSet.ToString (), "#6");
1558 Assert.AreEqual ("NewDataSet", table.DataSet.DataSetName, "#7");
1562 public void XmlTest20 ()
1564 MakeParentTable1 ();
1566 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1567 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema);
1570 DataSet ds = new DataSet ();
1571 DataTable table = new DataTable ("HelloWorldTable");
1572 XmlReadMode mode = XmlReadMode.Auto;
1573 table.Columns.Add (new DataColumn ("id", typeof (int)));
1574 ds.Tables.Add (table);
1576 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1577 //ReadXml wont read anything as TableNames dont match
1578 mode = table.ReadXml (stream);
1581 Assert.AreEqual (XmlReadMode.IgnoreSchema, mode, "#1");
1582 Assert.AreEqual ("HelloWorldTable", table.TableName, "#2");
1583 Assert.AreEqual (0, table.Rows.Count, "#3");
1584 Assert.AreEqual (1, table.Columns.Count, "#4");
1585 Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#5");
1586 Assert.AreEqual ("System.Data.DataSet", table.DataSet.ToString (), "#6");
1587 Assert.AreEqual ("NewDataSet", table.DataSet.DataSetName, "#7");
1591 public void XmlTest21 ()
1593 MakeParentTable1 ();
1595 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1596 parentTable1.WriteXml (stream, XmlWriteMode.IgnoreSchema);
1599 DataSet ds = new DataSet ();
1600 DataTable table = new DataTable ("ParentTable");
1601 XmlReadMode mode = XmlReadMode.Auto;
1602 table.Columns.Add (new DataColumn ("id", Type.GetType ("System.Int32")));
1603 ds.Tables.Add (table);
1605 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1606 mode = table.ReadXml (stream);
1609 Assert.AreEqual (XmlReadMode.IgnoreSchema, mode, "#1");
1610 Assert.AreEqual ("ParentTable", table.TableName, "#2");
1611 Assert.AreEqual (3, table.Rows.Count, "#3");
1612 Assert.AreEqual (1, table.Columns.Count, "#4");
1613 Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#5");
1614 Assert.AreEqual ("System.Data.DataSet", table.DataSet.ToString (), "#6");
1615 Assert.AreEqual ("NewDataSet", table.DataSet.DataSetName, "#7");
1618 DataRow row = table.Rows [0];
1619 Assert.AreEqual (1, row [0], "#8");
1621 row = table.Rows [1];
1622 Assert.AreEqual (2, row [0], "#9");
1624 row = table.Rows [2];
1625 Assert.AreEqual (3, row [0], "#10");
1629 public void XmlTest22 ()
1631 MakeParentTable1 ();
1633 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1634 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema);
1637 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1638 DataSet ds = new DataSet ();
1639 DataTable table = new DataTable ("Table1");
1640 table.Columns.Add (new DataColumn ("id", Type.GetType ("System.Int32")));
1641 ds.Tables.Add (table);
1644 table.ReadXml (stream);
1646 } catch (ArgumentException ex) {
1647 // DataTable 'Table1' does not match to
1648 // any DataTable in source
1649 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1650 Assert.IsNull (ex.InnerException, "#3");
1651 Assert.IsNotNull (ex.Message, "#4");
1652 Assert.IsTrue (ex.Message.IndexOf ("'Table1'") != -1, "#5");
1653 Assert.IsNull (ex.ParamName, "#6");
1659 public void XmlTest23 ()
1661 MakeParentTable1 ();
1663 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1664 parentTable1.WriteXml (stream, XmlWriteMode.WriteSchema);
1667 DataSet ds = new DataSet ();
1668 DataTable table = new DataTable ("ParentTable");
1669 XmlReadMode mode = XmlReadMode.Auto;
1670 table.Columns.Add (new DataColumn ("id", typeof (int)));
1671 table.Columns.Add (new DataColumn ("DepartmentID", typeof (string)));
1672 ds.Tables.Add (table);
1674 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1675 mode = table.ReadXml (stream);
1678 Assert.AreEqual (XmlReadMode.ReadSchema, mode, "#1");
1679 Assert.AreEqual ("ParentTable", table.TableName, "#2");
1680 Assert.AreEqual ("NewDataSet", table.DataSet.DataSetName, "#3");
1681 Assert.AreEqual (3, table.Rows.Count, "#4");
1682 Assert.AreEqual (2, table.Columns.Count, "#5");
1683 Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#6");
1684 Assert.AreEqual (typeof (string), table.Columns [1].DataType, "#7");
1687 DataRow row = table.Rows [0];
1688 Assert.AreEqual (1, row [0], "#8");
1689 Assert.AreEqual ("1", row [1], "#9");
1691 row = table.Rows [1];
1692 Assert.AreEqual (2, row [0], "#10");
1693 Assert.AreEqual ("2", row [1], "#11");
1695 row = table.Rows [2];
1696 Assert.AreEqual (3, row [0], "#12");
1697 Assert.AreEqual ("3", row [1], "#13");
1701 public void XmlTest24 ()
1705 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1706 dummyTable.WriteXml (stream, XmlWriteMode.DiffGram);
1709 //This test is the same for case when the table name is set but no schema is defined
1711 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1712 DataTable table = new DataTable ();
1715 table.ReadXml (stream);
1717 } catch (InvalidOperationException ex) {
1718 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
1719 Assert.IsNull (ex.InnerException, "#3");
1720 Assert.IsNotNull (ex.Message, "#4");
1726 public void XmlTest25 ()
1730 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1731 dummyTable.WriteXml (stream, XmlWriteMode.DiffGram);
1734 XmlReadMode mode = XmlReadMode.Auto;
1735 //Create a table but dont set the table name
1736 DataTable table = new DataTable ();
1737 //define the table schame partially
1738 table.Columns.Add ("id", typeof (int));
1740 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1741 mode = table.ReadXml (stream);
1744 Assert.AreEqual (String.Empty, table.TableName, "#1");
1745 Assert.AreEqual (1, table.Columns.Count, "#2");
1746 Assert.AreEqual (0, table.Rows.Count, "#3");
1747 Assert.AreEqual (XmlReadMode.DiffGram, mode, "#4");
1751 public void XmlTest26 ()
1755 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1756 dummyTable.WriteXml (stream, XmlWriteMode.DiffGram);
1759 //Create a table and set the table name
1760 DataTable table = new DataTable ("DummyTable");
1761 //define the table schame partially
1762 table.Columns.Add (new DataColumn ("DummyItem", typeof (string)));
1764 XmlReadMode mode = XmlReadMode.Auto;
1766 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1767 mode = table.ReadXml (stream);
1770 Assert.AreEqual (XmlReadMode.DiffGram, mode, "#1");
1771 Assert.AreEqual (null, table.DataSet, "#2");
1772 Assert.AreEqual (1, table.Columns.Count, "#3");
1773 Assert.AreEqual (typeof (string), table.Columns [0].DataType, "#4");
1774 Assert.AreEqual (3, table.Rows.Count, "#5");
1777 DataRow row = table.Rows [0];
1778 Assert.AreEqual ("DummyItem 1", row [0], "#1");
1779 Assert.AreEqual (DataRowState.Unchanged, row.RowState, "#2");
1781 row = table.Rows [1];
1782 Assert.AreEqual ("Changed_DummyItem 2", row [0], "#3");
1783 Assert.AreEqual (DataRowState.Modified, row.RowState, "#4");
1785 row = table.Rows [2];
1786 Assert.AreEqual ("DummyItem 3", row [0], "#5");
1787 Assert.AreEqual (DataRowState.Unchanged, row.RowState, "#6");
1791 public void XmlTest27 ()
1795 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1796 dummyTable.WriteXml (stream, XmlWriteMode.DiffGram);
1799 //Create a table and set the table name
1800 DataTable table = new DataTable ("DummyTable");
1801 //define the table and add an extra column in the table
1802 table.Columns.Add (new DataColumn ("id", typeof (int)));
1803 table.Columns.Add (new DataColumn ("DummyItem", typeof (string)));
1804 //Add an extra column which does not match any column in the source diffram
1805 table.Columns.Add (new DataColumn ("ExtraColumn", typeof (double)));
1807 XmlReadMode mode = XmlReadMode.Auto;
1809 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1810 mode = table.ReadXml (stream);
1813 Assert.AreEqual (XmlReadMode.DiffGram, mode, "#1");
1814 Assert.IsNull (table.DataSet, "#2");
1815 Assert.AreEqual (3, table.Columns.Count, "#3");
1816 Assert.AreEqual (typeof (int), table.Columns [0].DataType, "#4");
1817 Assert.AreEqual (typeof (string), table.Columns [1].DataType, "#5");
1818 Assert.AreEqual (typeof (double), table.Columns [2].DataType, "#6");
1819 Assert.AreEqual (3, table.Rows.Count, "#7");
1822 DataRow row = table.Rows [0];
1823 Assert.AreEqual (1, row [0], "#8");
1824 Assert.AreEqual ("DummyItem 1", row [1], "#9");
1825 Assert.AreSame (DBNull.Value, row [2], "#10");
1826 Assert.AreEqual (DataRowState.Unchanged, row.RowState, "#11");
1828 row = table.Rows [1];
1829 Assert.AreEqual (2, row [0], "#12");
1830 Assert.AreEqual ("Changed_DummyItem 2", row [1], "#13");
1831 Assert.AreSame (DBNull.Value, row [2], "#14");
1832 Assert.AreEqual (DataRowState.Modified, row.RowState, "#15");
1834 row = table.Rows [2];
1835 Assert.AreEqual (3, row [0], "#16");
1836 Assert.AreEqual ("DummyItem 3", row [1], "#17");
1837 Assert.AreSame (DBNull.Value, row [2], "#18");
1838 Assert.AreEqual (DataRowState.Unchanged, row.RowState, "#19");
1842 public void XmlTest28 ()
1846 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1847 dummyTable.WriteXml (stream, XmlWriteMode.DiffGram);
1850 //Create a table and set the table name
1851 DataTable table = new DataTable ("DummyTable");
1852 //define the table schame partially with a column name which does not match with any
1853 //table columns in the diffgram
1854 table.Columns.Add (new DataColumn ("WrongColumnName", Type.GetType ("System.String")));
1856 XmlReadMode mode = XmlReadMode.Auto;
1858 using (FileStream stream = new FileStream (tempFile, FileMode.Open)) {
1859 mode = table.ReadXml (stream);
1862 Assert.AreEqual (XmlReadMode.DiffGram, mode, "#1");
1863 Assert.IsNull (table.DataSet, "#2");
1864 Assert.AreEqual ("DummyTable", table.TableName, "#3");
1865 Assert.AreEqual (1, table.Columns.Count, "#4");
1866 Assert.AreEqual (typeof (string), table.Columns [0].DataType, "#5");
1868 Assert.AreEqual (3, table.Rows.Count, "#6");
1869 foreach (DataRow row in table.Rows)
1870 Assert.AreSame (DBNull.Value, row [0], "#7");
1874 public void XmlTest29 ()
1876 MakeParentTable1 ();
1878 MakeSecondChildTable ();
1879 MakeDataRelation ();
1881 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1882 parentTable1.WriteXml (stream, XmlWriteMode.DiffGram, true);
1885 DataTable table1 = new DataTable ("ParentTable");
1886 table1.Columns.Add (new DataColumn (parentTable1.Columns [0].ColumnName, typeof (int)));
1887 table1.Columns.Add (new DataColumn (parentTable1.Columns [1].ColumnName, typeof (string)));
1888 table1.Columns.Add (new DataColumn (parentTable1.Columns [2].ColumnName, typeof (int)));
1890 //ReadXml on a DiffGram will never create any child relation
1891 XmlReadMode mode = table1.ReadXml (tempFile);
1893 Assert.AreEqual (XmlReadMode.DiffGram, mode, "#1");
1894 Assert.AreEqual (null, table1.DataSet, "#2");
1895 Assert.AreEqual ("ParentTable", table1.TableName, "#3");
1896 Assert.AreEqual (3, table1.Columns.Count, "#4");
1897 Assert.AreEqual (typeof (int), table1.Columns [0].DataType, "#5");
1898 Assert.AreEqual (typeof (string), table1.Columns [1].DataType, "#6");
1899 Assert.AreEqual (typeof (int), table1.Columns [2].DataType, "#7");
1900 Assert.AreEqual (0, table1.ChildRelations.Count, "#8");
1902 Assert.AreEqual (3, table1.Rows.Count, "#9");
1904 DataRow row = table1.Rows [0];
1905 Assert.AreEqual (1, row [0], "#10");
1906 Assert.AreEqual ("ParentItem 1", row [1], "#11");
1907 Assert.AreEqual (1, row [2], "#12");
1909 row = table1.Rows [1];
1910 Assert.AreEqual (2, row [0], "#13");
1911 Assert.AreEqual ("ParentItem 2", row [1], "#14");
1912 Assert.AreEqual (2, row [2], "#15");
1914 row = table1.Rows [2];
1915 Assert.AreEqual (3, row [0], "#16");
1916 Assert.AreEqual ("ParentItem 3", row [1], "#17");
1917 Assert.AreEqual (3, row [2], "#18");
1921 public void XmlTest30 ()
1925 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
1926 dummyTable.WriteXml (stream, XmlWriteMode.DiffGram);
1929 Assert.AreEqual (3, dummyTable.Rows.Count, "#4b");
1931 DataSet dataSet = new DataSet ("HelloWorldDataSet");
1932 DataTable table = new DataTable ("DummyTable");
1933 table.Columns.Add (new DataColumn ("DummyItem", typeof (string)));
1934 dataSet.Tables.Add (table);
1936 //Call ReadXml on a table which belong to a DataSet
1937 table.ReadXml (tempFile);
1939 Assert.AreEqual ("HelloWorldDataSet", table.DataSet.DataSetName, "#1");
1940 Assert.AreEqual (1, table.Columns.Count, "#2");
1941 Assert.AreEqual (typeof (string), table.Columns [0].DataType, "#3");
1942 Assert.AreEqual (3, table.Rows.Count, "#4");
1945 DataRow row = table.Rows [0];
1946 Assert.AreEqual ("DummyItem 1", row [0], "#5");
1947 Assert.AreEqual (DataRowState.Unchanged, row.RowState, "#6");
1949 row = table.Rows [1];
1950 Assert.AreEqual ("Changed_DummyItem 2", row [0], "#7");
1951 Assert.AreEqual (DataRowState.Modified, row.RowState, "#8");
1953 row = table.Rows [2];
1954 Assert.AreEqual ("DummyItem 3", row [0], "#9");
1955 Assert.AreEqual (DataRowState.Unchanged, row.RowState, "#10");
1959 public void XmlTest31 ()
1961 DataSet ds = new DataSet ();
1962 DataTable parent = new DataTable ("Parent");
1963 parent.Columns.Add (new DataColumn ("col1", typeof (int)));
1964 parent.Columns.Add (new DataColumn ("col2", typeof (string)));
1965 parent.Columns [0].Unique = true;
1967 DataTable child1 = new DataTable ("Child1");
1968 child1.Columns.Add (new DataColumn ("col3", typeof (int)));
1969 child1.Columns.Add (new DataColumn ("col4", typeof (string)));
1970 child1.Columns.Add (new DataColumn ("col5", typeof (int)));
1971 child1.Columns [2].Unique = true;
1973 DataTable child2 = new DataTable ("Child2");
1974 child2.Columns.Add (new DataColumn ("col6", typeof (int)));
1975 child2.Columns.Add (new DataColumn ("col7"));
1977 parent.Rows.Add (new object [] {1, "P_"});
1978 parent.Rows.Add (new object [] {2, "P_"});
1980 child1.Rows.Add (new object [] {1, "C1_", 3});
1981 child1.Rows.Add (new object [] {1, "C1_", 4});
1982 child1.Rows.Add (new object [] {2, "C1_", 5});
1983 child1.Rows.Add (new object [] {2, "C1_", 6});
1985 child2.Rows.Add (new object [] {3, "C2_"});
1986 child2.Rows.Add (new object [] {3, "C2_"});
1987 child2.Rows.Add (new object [] {4, "C2_"});
1988 child2.Rows.Add (new object [] {4, "C2_"});
1989 child2.Rows.Add (new object [] {5, "C2_"});
1990 child2.Rows.Add (new object [] {5, "C2_"});
1991 child2.Rows.Add (new object [] {6, "C2_"});
1992 child2.Rows.Add (new object [] {6, "C2_"});
1994 ds.Tables.Add (parent);
1995 ds.Tables.Add (child1);
1996 ds.Tables.Add (child2);
1998 DataRelation relation = new DataRelation ("Relation1", parent.Columns [0], child1.Columns [0]);
1999 parent.ChildRelations.Add (relation);
2001 relation = new DataRelation ("Relation2", child1.Columns [2], child2.Columns [0]);
2002 child1.ChildRelations.Add (relation);
2004 using (FileStream stream = new FileStream (tempFile, FileMode.Create)) {
2005 parent.WriteXml (stream, XmlWriteMode.WriteSchema, true);
2008 DataTable table = new DataTable ();
2009 table.ReadXml (tempFile);
2011 Assert.AreEqual ("Parent", table.TableName, "#1");
2012 Assert.AreEqual ("NewDataSet", table.DataSet.DataSetName, "#2");
2013 Assert.AreEqual (2, table.Columns.Count, "#3");
2014 Assert.AreEqual (2, table.Rows.Count, "#4");
2015 Assert.AreEqual (typeof (Int32), table.Columns [0].DataType, "#5");
2016 Assert.AreEqual (typeof (String), table.Columns [1].DataType, "#6");
2017 Assert.AreEqual (1, table.Constraints.Count, "#7");
2018 Assert.AreEqual (typeof (UniqueConstraint), table.Constraints [0].GetType (), "#8");
2019 Assert.AreEqual (1, table.ChildRelations.Count, "#9");
2020 Assert.AreEqual ("Relation1", table.ChildRelations [0].RelationName, "#10");
2021 Assert.AreEqual ("Parent", table.ChildRelations [0].ParentTable.TableName, "#11");
2022 Assert.AreEqual ("Child1", table.ChildRelations [0].ChildTable.TableName, "#12");
2024 DataTable table1 = table.ChildRelations [0].ChildTable;
2025 Assert.AreEqual ("Child1", table1.TableName, "#13");
2026 Assert.AreEqual ("NewDataSet", table1.DataSet.DataSetName, "#14");
2027 Assert.AreEqual (3, table1.Columns.Count, "#15");
2028 Assert.AreEqual (4, table1.Rows.Count, "#16");
2029 Assert.AreEqual (typeof (Int32), table1.Columns [0].DataType, "#17");
2030 Assert.AreEqual (typeof (String), table1.Columns [1].DataType, "#18");
2031 Assert.AreEqual (typeof (Int32), table1.Columns [2].DataType, "#19");
2032 Assert.AreEqual (2, table1.Constraints.Count, "#20");
2033 Assert.AreEqual (typeof (UniqueConstraint), table1.Constraints [0].GetType (), "#21");
2034 Assert.AreEqual (typeof (ForeignKeyConstraint), table1.Constraints [1].GetType (), "#22");
2035 Assert.AreEqual (1, table1.ParentRelations.Count, "#23");
2036 Assert.AreEqual (1, table1.ChildRelations.Count, "#24");
2037 Assert.AreEqual ("Relation1", table1.ParentRelations [0].RelationName, "#25");
2038 Assert.AreEqual ("Relation2", table1.ChildRelations [0].RelationName, "#26");
2039 Assert.AreEqual ("Parent", table1.ParentRelations [0].ParentTable.TableName, "#27");
2040 Assert.AreEqual ("Child2", table1.ChildRelations [0].ChildTable.TableName, "#28");
2042 table1 = table1.ChildRelations [0].ChildTable;
2043 Assert.AreEqual ("Child2", table1.TableName, "#28");
2044 Assert.AreEqual ("NewDataSet", table1.DataSet.DataSetName, "#29");
2045 Assert.AreEqual (2, table1.Columns.Count, "#30");
2046 Assert.AreEqual (8, table1.Rows.Count, "#31");
2047 Assert.AreEqual (typeof (Int32), table1.Columns [0].DataType, "#32");
2048 Assert.AreEqual (typeof (String), table1.Columns [1].DataType, "#33");
2049 Assert.AreEqual (1, table1.Constraints.Count, "#34");
2050 Assert.AreEqual (typeof (ForeignKeyConstraint), table1.Constraints [0].GetType (), "#35");
2051 Assert.AreEqual (1, table1.ParentRelations.Count, "#36");
2052 Assert.AreEqual (0, table1.ChildRelations.Count, "#37");
2053 Assert.AreEqual ("Relation2", table1.ParentRelations [0].RelationName, "#38");
2054 Assert.AreEqual ("Child1", table1.ParentRelations [0].ParentTable.TableName, "#39");