1 // DataTableTest.cs - NUnit Test Cases for testing the DataTable
4 // Franklin Wise (gracenote@earthlink.net)
5 // Martin Willemoes Hansen (mwh@sysrq.dk)
6 // Hagit Yidov (hagity@mainsoft.com)
9 // (C) 2003 Martin Willemoes Hansen
10 // (C) 2005 Mainsoft Corporation (http://www.mainsoft.com)
13 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
14 // Copyright (C) 2011 Xamarin Inc. (http://www.xamarin.com)
16 // Permission is hereby granted, free of charge, to any person obtaining
17 // a copy of this software and associated documentation files (the
18 // "Software"), to deal in the Software without restriction, including
19 // without limitation the rights to use, copy, modify, merge, publish,
20 // distribute, sublicense, and/or sell copies of the Software, and to
21 // permit persons to whom the Software is furnished to do so, subject to
22 // the following conditions:
24 // The above copyright notice and this permission notice shall be
25 // included in all copies or substantial portions of the Software.
27 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
28 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
29 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
30 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
31 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
32 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
33 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
37 using System.Collections;
38 using System.Collections.Generic;
40 using System.Data.SqlTypes;
41 using System.Globalization;
43 using System.Runtime.Serialization.Formatters.Binary;
44 using System.Threading;
47 using MonoTests.System.Data.Utils;
49 using NUnit.Framework;
51 namespace MonoTests.System.Data
54 public class DataTableTest : DataSetAssertion
61 DataTable dt = new DataTable();
63 Assert.IsFalse (dt.CaseSensitive, "CaseSensitive must be false.");
64 Assert.IsNotNull (dt.Columns, "Col");
65 //Assert.IsTrue (dt.ChildRelations != null);
66 Assert.IsNotNull (dt.Constraints, "Const");
67 Assert.IsNull (dt.DataSet, "ds");
68 Assert.IsNotNull (dt.DefaultView, "dv");
69 Assert.AreEqual (string.Empty, dt.DisplayExpression, "de");
70 Assert.IsNotNull (dt.ExtendedProperties, "ep");
71 Assert.IsFalse (dt.HasErrors, "he");
72 Assert.IsNotNull (dt.Locale, "lc");
73 Assert.AreEqual (50, dt.MinimumCapacity, "mc"); //LAMESPEC:
74 Assert.AreEqual (string.Empty, dt.Namespace, "ns");
75 //Assert.IsTrue (dt.ParentRelations != null);
76 Assert.AreEqual (string.Empty, dt.Prefix, "pf");
77 Assert.IsNotNull (dt.PrimaryKey, "pk");
78 Assert.IsNotNull (dt.Rows, "rows");
79 Assert.IsNull (dt.Site, "Site");
80 Assert.AreEqual (string.Empty, dt.TableName, "tname");
86 DataSet Set = new DataSet ();
87 DataTable Mom = new DataTable ("Mom");
88 DataTable Child = new DataTable ("Child");
90 Set.Tables.Add (Child);
92 DataColumn Col = new DataColumn ("Name");
93 DataColumn Col2 = new DataColumn ("ChildName");
94 Mom.Columns.Add (Col);
95 Mom.Columns.Add (Col2);
97 DataColumn Col3 = new DataColumn ("Name");
98 DataColumn Col4 = new DataColumn ("Age");
99 Col4.DataType = typeof (short);
100 Child.Columns.Add (Col3);
101 Child.Columns.Add (Col4);
103 DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);
104 Set.Relations.Add (Relation);
106 DataRow Row = Mom.NewRow ();
132 Row [0] = "'Jhon O'' Collenal'";
136 Row = Child.NewRow ();
139 Child.Rows.Add (Row);
141 Row = Child.NewRow ();
144 Child.Rows.Add (Row);
146 Row = Child.NewRow ();
149 Child.Rows.Add (Row);
151 Row = Child.NewRow ();
154 Child.Rows.Add (Row);
156 Row = Child.NewRow ();
159 Child.Rows.Add (Row);
161 Row = Child.NewRow ();
164 Child.Rows.Add (Row);
166 Row = Child.NewRow ();
169 Child.Rows.Add (Row);
171 DataRow [] Rows = Mom.Select ("Name = 'Teresa'");
172 Assert.AreEqual (2, Rows.Length, "test#01");
174 // test with apos escaped
175 Rows = Mom.Select ("Name = '''Jhon O'''' Collenal'''");
176 Assert.AreEqual (1, Rows.Length, "test#01.1");
178 Rows = Mom.Select ("Name = 'Teresa' and ChildName = 'Nick'");
179 Assert.AreEqual (0, Rows.Length, "test#02");
181 Rows = Mom.Select ("Name = 'Teresa' and ChildName = 'Jack'");
182 Assert.AreEqual (1, Rows.Length, "test#03");
184 Rows = Mom.Select ("Name = 'Teresa' and ChildName <> 'Jack'");
185 Assert.AreEqual ("Mack", Rows [0] [1], "test#04");
187 Rows = Mom.Select ("Name = 'Teresa' or ChildName <> 'Jack'");
188 Assert.AreEqual (6, Rows.Length, "test#05");
190 Rows = Child.Select ("age = 20 - 1");
191 Assert.AreEqual (1, Rows.Length, "test#06");
193 Rows = Child.Select ("age <= 20");
194 Assert.AreEqual (3, Rows.Length, "test#07");
196 Rows = Child.Select ("age >= 20");
197 Assert.AreEqual (4, Rows.Length, "test#08");
199 Rows = Child.Select ("age >= 20 and name = 'Mack' or name = 'Nick'");
200 Assert.AreEqual (2, Rows.Length, "test#09");
202 Rows = Child.Select ("age >= 20 and (name = 'Mack' or name = 'Nick')");
203 Assert.AreEqual (1, Rows.Length, "test#10");
204 Assert.AreEqual ("Mack", Rows [0] [0], "test#11");
206 Rows = Child.Select ("not (Name = 'Jack')");
207 Assert.AreEqual (6, Rows.Length, "test#12");
211 public void Select2 ()
213 DataSet Set = new DataSet ();
214 DataTable Child = new DataTable ("Child");
216 Set.Tables.Add (Child);
218 DataColumn Col3 = new DataColumn ("Name");
219 DataColumn Col4 = new DataColumn ("Age");
220 Col4.DataType = typeof (short);
221 Child.Columns.Add (Col3);
222 Child.Columns.Add (Col4);
224 DataRow Row = Child.NewRow ();
227 Child.Rows.Add (Row);
229 Row = Child.NewRow ();
232 Child.Rows.Add (Row);
234 Row = Child.NewRow ();
237 Child.Rows.Add (Row);
239 Row = Child.NewRow ();
242 Child.Rows.Add (Row);
244 Row = Child.NewRow ();
247 Child.Rows.Add (Row);
249 Row = Child.NewRow ();
252 Child.Rows.Add (Row);
254 DataRow [] Rows = Child.Select ("age >= 20", "age DESC");
255 Assert.AreEqual (3, Rows.Length, "test#01");
256 Assert.AreEqual ("Mack", Rows [0] [0], "test#02");
257 Assert.AreEqual ("Mick", Rows [1] [0], "test#03");
258 Assert.AreEqual ("Dick", Rows [2] [0], "test#04");
260 Rows = Child.Select ("age >= 20", "age asc");
261 Assert.AreEqual (3, Rows.Length, "test#05");
262 Assert.AreEqual ("Dick", Rows [0] [0], "test#06");
263 Assert.AreEqual ("Mick", Rows [1] [0], "test#07");
264 Assert.AreEqual ("Mack", Rows [2] [0], "test#08");
266 Rows = Child.Select ("age >= 20", "name asc");
267 Assert.AreEqual (3, Rows.Length, "test#09");
268 Assert.AreEqual ("Dick", Rows [0] [0], "test#10");
269 Assert.AreEqual ("Mack", Rows [1] [0], "test#11");
270 Assert.AreEqual ("Mick", Rows [2] [0], "test#12");
272 Rows = Child.Select ("age >= 20", "name desc");
273 Assert.AreEqual (3, Rows.Length, "test#09");
274 Assert.AreEqual ("Mick", Rows [0] [0], "test#10");
275 Assert.AreEqual ("Mack", Rows [1] [0], "test#11");
276 Assert.AreEqual ("Dick", Rows [2] [0], "test#12");
280 public void SelectParsing ()
282 DataTable T = new DataTable ("test");
283 DataColumn C = new DataColumn ("name");
285 C = new DataColumn ("age");
286 C.DataType = typeof (int);
288 C = new DataColumn ("id");
291 DataSet Set = new DataSet ("TestSet");
295 for (int i = 0; i < 100; i++) {
297 Row [0] = "human" + i;
309 Assert.AreEqual (12, T.Select ("age<=10").Length, "test#01");
311 Assert.AreEqual (12, T.Select ("age\n\t<\n\t=\t\n10").Length, "test#02");
314 T.Select ("name = 1human ");
315 Assert.Fail ("test#03");
316 } catch (SyntaxErrorException e) {
317 // missing operand after 'human' operand
318 Assert.AreEqual (typeof (SyntaxErrorException), e.GetType (), "test#04");
322 T.Select ("name = 1");
323 Assert.Fail ("test#05");
324 } catch (EvaluateException e) {
325 // Cannot perform '=' operation between string and Int32
326 Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#06");
329 Assert.AreEqual (1, T.Select ("age = '13'").Length, "test#07");
333 public void SelectEscaping ()
335 DataTable dt = new DataTable ();
336 dt.Columns.Add ("SomeCol");
337 dt.Rows.Add (new object [] {"\t"});
338 dt.Rows.Add (new object [] {"\\"});
340 Assert.AreEqual (1, dt.Select (@"SomeCol='\t'").Length, "test#01");
341 Assert.AreEqual (1, dt.Select (@"SomeCol='\\'").Length, "test#02");
344 dt.Select (@"SomeCol='\x'");
345 Assert.Fail ("test#03");
346 } catch (SyntaxErrorException) {
351 public void SelectOperators ()
353 DataTable T = new DataTable ("test");
354 DataColumn C = new DataColumn ("name");
356 C = new DataColumn ("age");
357 C.DataType = typeof (int);
359 C = new DataColumn ("id");
362 DataSet Set = new DataSet ("TestSet");
366 for (int i = 0; i < 100; i++) {
368 Row [0] = "human" + i;
380 Assert.AreEqual (11, T.Select ("age < 10").Length, "test#01");
381 Assert.AreEqual (12, T.Select ("age <= 10").Length, "test#02");
382 Assert.AreEqual (12, T.Select ("age< =10").Length, "test#03");
383 Assert.AreEqual (89, T.Select ("age > 10").Length, "test#04");
384 Assert.AreEqual (90, T.Select ("age >= 10").Length, "test#05");
385 Assert.AreEqual (100, T.Select ("age <> 10").Length, "test#06");
386 Assert.AreEqual (3, T.Select ("name < 'human10'").Length, "test#07");
387 Assert.AreEqual (3, T.Select ("id < '10'").Length, "test#08");
388 // FIXME: Somebody explain how this can be possible.
389 // it seems that it is no matter between 10 - 30. The
390 // result is allways 25 :-P
391 //Assert.AreEqual (25, T.Select ("id < 10").Length, "test#09");
396 public void SelectExceptions ()
398 DataTable T = new DataTable ("test");
399 DataColumn C = new DataColumn ("name");
401 C = new DataColumn ("age");
402 C.DataType = typeof (int);
404 C = new DataColumn ("id");
407 for (int i = 0; i < 100; i++) {
408 DataRow Row = T.NewRow ();
409 Row [0] = "human" + i;
416 T.Select ("name = human1");
417 Assert.Fail ("test#01");
418 } catch (EvaluateException e) {
419 // column name human not found
420 Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#02");
423 Assert.AreEqual (1, T.Select ("id = '12'").Length, "test#04");
424 Assert.AreEqual (1, T.Select ("id = 12").Length, "test#05");
427 T.Select ("id = 1k3");
428 Assert.Fail ("test#06");
429 } catch (SyntaxErrorException e) {
430 // no operands after k3 operator
431 Assert.AreEqual (typeof (SyntaxErrorException), e.GetType (), "test#07");
436 public void SelectStringOperators ()
438 DataTable T = new DataTable ("test");
439 DataColumn C = new DataColumn ("name");
441 C = new DataColumn ("age");
442 C.DataType = typeof (int);
444 C = new DataColumn ("id");
447 DataSet Set = new DataSet ("TestSet");
451 for (int i = 0; i < 100; i++) {
453 Row [0] = "human" + i;
464 Assert.AreEqual (1, T.Select ("name = 'human' + 1").Length, "test#01");
466 Assert.AreEqual ("human1", T.Select ("name = 'human' + 1") [0] ["name"], "test#02");
467 Assert.AreEqual (1, T.Select ("name = 'human' + '1'").Length, "test#03");
468 Assert.AreEqual ("human1", T.Select ("name = 'human' + '1'") [0] ["name"], "test#04");
469 Assert.AreEqual (1, T.Select ("name = 'human' + 1 + 2").Length, "test#05");
470 Assert.AreEqual ("human12", T.Select ("name = 'human' + '1' + '2'") [0] ["name"], "test#06");
472 Assert.AreEqual (1, T.Select ("name = 'huMAn' + 1").Length, "test#07");
474 Set.CaseSensitive = true;
475 Assert.AreEqual (0, T.Select ("name = 'huMAn' + 1").Length, "test#08");
477 T.CaseSensitive = false;
478 Assert.AreEqual (1, T.Select ("name = 'huMAn' + 1").Length, "test#09");
480 T.CaseSensitive = true;
481 Assert.AreEqual (0, T.Select ("name = 'huMAn' + 1").Length, "test#10");
483 Set.CaseSensitive = false;
484 Assert.AreEqual (0, T.Select ("name = 'huMAn' + 1").Length, "test#11");
486 T.CaseSensitive = false;
487 Assert.AreEqual (1, T.Select ("name = 'huMAn' + 1").Length, "test#12");
489 Assert.AreEqual (0, T.Select ("name = 'human1*'").Length, "test#13");
490 Assert.AreEqual (11, T.Select ("name like 'human1*'").Length, "test#14");
491 Assert.AreEqual (11, T.Select ("name like 'human1%'").Length, "test#15");
494 Assert.AreEqual (11, T.Select ("name like 'h*an1'").Length, "test#16");
495 Assert.Fail ("test#16");
496 } catch (EvaluateException e) {
497 // 'h*an1' is invalid
498 Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#17");
502 Assert.AreEqual (11, T.Select ("name like 'h%an1'").Length, "test#18");
503 Assert.Fail ("test#19");
504 } catch (EvaluateException e) {
505 // 'h%an1' is invalid
506 Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#20");
509 Assert.AreEqual (0, T.Select ("name like 'h[%]an'").Length, "test#21");
510 Assert.AreEqual (1, T.Select ("name like 'h[*]an'").Length, "test#22");
514 public void SelectAggregates ()
516 DataTable T = new DataTable ("test");
517 DataColumn C = new DataColumn ("name");
519 C = new DataColumn ("age");
520 C.DataType = typeof (int);
522 C = new DataColumn ("id");
526 for (int i = 0; i < 1000; i++) {
528 Row [0] = "human" + i;
534 Assert.AreEqual (1000, T.Select ("Sum(age) > 10").Length, "test#01");
535 Assert.AreEqual (1000, T.Select ("avg(age) = 499").Length, "test#02");
536 Assert.AreEqual (1000, T.Select ("min(age) = 0").Length, "test#03");
537 Assert.AreEqual (1000, T.Select ("max(age) = 999").Length, "test#04");
538 Assert.AreEqual (1000, T.Select ("count(age) = 1000").Length, "test#05");
539 Assert.AreEqual (1000, T.Select ("stdev(age) > 287 and stdev(age) < 289").Length, "test#06");
540 Assert.AreEqual (1000, T.Select ("var(age) < 83417 and var(age) > 83416").Length, "test#07");
544 public void SelectFunctions ()
546 DataTable T = new DataTable ("test");
547 DataColumn C = new DataColumn ("name");
549 C = new DataColumn ("age");
550 C.DataType = typeof (int);
552 C = new DataColumn ("id");
556 for (int i = 0; i < 1000; i++) {
558 Row [0] = "human" + i;
565 Row [0] = "human" + "test";
566 Row [1] = DBNull.Value;
567 Row [2] = DBNull.Value;
570 //TODO: How to test Convert-function
571 Assert.AreEqual (25, T.Select ("age = 5*5") [0]["age"], "test#01");
572 Assert.AreEqual (901, T.Select ("len(name) > 7").Length, "test#02");
573 Assert.AreEqual (125, T.Select ("age = 5*5*5 AND len(name)>7") [0]["age"], "test#03");
574 Assert.AreEqual (1, T.Select ("isnull(id, 'test') = 'test'").Length, "test#04");
575 Assert.AreEqual (1000, T.Select ("iif(id = '56', 'test', 'false') = 'false'").Length, "test#05");
576 Assert.AreEqual (1, T.Select ("iif(id = '56', 'test', 'false') = 'test'").Length, "test#06");
577 Assert.AreEqual (9, T.Select ("substring(id, 2, 3) = '23'").Length, "test#07");
578 Assert.AreEqual ("123", T.Select ("substring(id, 2, 3) = '23'") [0] ["id"], "test#08");
579 Assert.AreEqual ("423", T.Select ("substring(id, 2, 3) = '23'") [3] ["id"], "test#09");
580 Assert.AreEqual ("923", T.Select ("substring(id, 2, 3) = '23'") [8] ["id"], "test#10");
584 public void SelectRelations ()
586 DataSet Set = new DataSet ();
587 DataTable Mom = new DataTable ("Mom");
588 DataTable Child = new DataTable ("Child");
590 Set.Tables.Add (Mom);
591 Set.Tables.Add (Child);
593 DataColumn Col = new DataColumn ("Name");
594 DataColumn Col2 = new DataColumn ("ChildName");
595 Mom.Columns.Add (Col);
596 Mom.Columns.Add (Col2);
598 DataColumn Col3 = new DataColumn ("Name");
599 DataColumn Col4 = new DataColumn ("Age");
600 Col4.DataType = typeof (short);
601 Child.Columns.Add (Col3);
602 Child.Columns.Add (Col4);
604 DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);
605 Set.Relations.Add (Relation);
607 DataRow Row = Mom.NewRow ();
632 Row = Child.NewRow ();
635 Child.Rows.Add (Row);
637 Row = Child.NewRow ();
640 Child.Rows.Add (Row);
642 Row = Child.NewRow ();
645 Child.Rows.Add (Row);
647 Row = Child.NewRow ();
650 Child.Rows.Add (Row);
652 Row = Child.NewRow ();
655 Child.Rows.Add (Row);
657 Row = Child.NewRow ();
660 Child.Rows.Add (Row);
662 DataRow [] Rows = Child.Select ("name = Parent.Childname");
663 Assert.AreEqual (6, Rows.Length, "test#01");
664 Rows = Child.Select ("Parent.childname = 'Jack'");
665 Assert.AreEqual (1, Rows.Length, "test#02");
669 // FIXME: LAMESPEC: Why the exception is thrown why... why...
670 Mom.Select ("Child.Name = 'Jack'");
671 Assert.Fail ("test#03");
672 } catch (Exception e) {
673 Assert.AreEqual (typeof (SyntaxErrorException), e.GetType (), "test#04");
674 Assert.AreEqual ("Cannot interpret token 'Child' at position 1.", e.Message, "test#05");
678 Rows = Child.Select ("Parent.name = 'Laura'");
679 Assert.AreEqual (3, Rows.Length, "test#06");
681 DataTable Parent2 = new DataTable ("Parent2");
682 Col = new DataColumn ("Name");
683 Col2 = new DataColumn ("ChildName");
685 Parent2.Columns.Add (Col);
686 Parent2.Columns.Add (Col2);
687 Set.Tables.Add (Parent2);
689 Row = Parent2.NewRow ();
692 Parent2.Rows.Add (Row);
694 Row = Parent2.NewRow ();
697 Parent2.Rows.Add (Row);
699 Row = Parent2.NewRow ();
702 Parent2.Rows.Add (Row);
704 Row = Parent2.NewRow ();
707 Parent2.Rows.Add (Row);
709 Row = Parent2.NewRow ();
712 Parent2.Rows.Add (Row);
714 Relation = new DataRelation ("Rel2", Parent2.Columns [1], Child.Columns [0]);
715 Set.Relations.Add (Relation);
718 Rows = Child.Select ("Parent.ChildName = 'Jack'");
719 Assert.Fail ("test#07");
720 } catch (EvaluateException e) {
721 Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#08");
722 // Do not compare exception messages!
723 //Assert.AreEqual ("The table [Child] involved in more than one relation. You must explicitly mention a relation name in the expression 'parent.[ChildName]'.", e.Message, "test#09");
726 Rows = Child.Select ("Parent(rel).ChildName = 'Jack'");
727 Assert.AreEqual (1, Rows.Length, "test#10");
729 Rows = Child.Select ("Parent(Rel2).ChildName = 'Jack'");
730 Assert.AreEqual (1, Rows.Length, "test#10");
733 Mom.Select ("Parent.name = 'John'");
734 } catch (IndexOutOfRangeException e) {
735 Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (), "test#11");
736 // Do not compare exception messages!
737 //Assert.AreEqual ("Cannot find relation 0.", e.Message, "test#12");
742 public void SelectRowState()
744 DataTable d = new DataTable();
745 d.Columns.Add (new DataColumn ("aaa"));
746 DataRow [] rows = d.Select (null, null, DataViewRowState.Deleted);
747 Assert.AreEqual (0, rows.Length);
748 d.Rows.Add (new object [] {"bbb"});
749 d.Rows.Add (new object [] {"bbb"});
750 rows = d.Select (null, null, DataViewRowState.Deleted);
751 Assert.AreEqual (0, rows.Length);
755 public void ToStringTest()
757 DataTable dt = new DataTable();
758 dt.Columns.Add("Col1", typeof(int));
760 dt.TableName = "Mytable";
761 dt.DisplayExpression = "Col1";
763 string cmpr = dt.TableName + " + " + dt.DisplayExpression;
764 Assert.AreEqual (cmpr, dt.ToString());
768 public void PrimaryKey ()
770 DataTable dt = new DataTable ();
771 DataColumn Col = new DataColumn ();
772 Col.AllowDBNull = false;
773 Col.DataType = typeof (int);
774 dt.Columns.Add (Col);
779 Assert.AreEqual (0, dt.PrimaryKey.Length, "test#01");
781 dt.PrimaryKey = new DataColumn [] {dt.Columns [0]};
782 Assert.AreEqual (1, dt.PrimaryKey.Length, "test#02");
783 Assert.AreEqual ("Column1", dt.PrimaryKey [0].ColumnName, "test#03");
785 dt.PrimaryKey = null;
786 Assert.AreEqual (0, dt.PrimaryKey.Length, "test#04");
788 Col = new DataColumn ("failed");
791 dt.PrimaryKey = new DataColumn [] {Col};
792 Assert.Fail ("test#05");
793 } catch (ArgumentException e) {
794 Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#06");
795 // Never expect English message
796 // Assert.AreEqual ("Column must belong to a table.", e.Message, "test#07");
799 DataTable dt2 = new DataTable ();
803 dt.PrimaryKey = new DataColumn [] {dt2.Columns [0]};
804 Assert.Fail ("test#08");
805 } catch (ArgumentException e) {
806 Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#09");
807 // Never expect English message
808 // Assert.AreEqual ("PrimaryKey columns do not belong to this table.", e.Message, "test#10");
811 Assert.AreEqual (0, dt.Constraints.Count, "test#11");
813 dt.PrimaryKey = new DataColumn [] {dt.Columns [0], dt.Columns [1]};
814 Assert.AreEqual (2, dt.PrimaryKey.Length, "test#12");
815 Assert.AreEqual (1, dt.Constraints.Count, "test#13");
816 Assert.IsTrue (dt.Constraints [0] is UniqueConstraint, "test#14");
817 Assert.AreEqual ("Column1", dt.PrimaryKey [0].ColumnName, "test#15");
818 Assert.AreEqual ("Column2", dt.PrimaryKey [1].ColumnName, "test#16");
822 public void PropertyExceptions ()
824 DataSet set = new DataSet ();
825 DataTable table = new DataTable ();
826 DataTable table1 = new DataTable ();
827 set.Tables.Add (table);
828 set.Tables.Add (table1);
830 DataColumn col = new DataColumn ();
831 col.ColumnName = "Id";
832 col.DataType = typeof (int);
833 table.Columns.Add (col);
834 UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
835 table.Constraints.Add (uc);
836 table.CaseSensitive = false;
838 col = new DataColumn ();
839 col.ColumnName = "Name";
840 col.DataType = typeof (string);
841 table.Columns.Add (col);
843 col = new DataColumn ();
844 col.ColumnName = "Id";
845 col.DataType = typeof (int);
846 table1.Columns.Add (col);
847 col = new DataColumn ();
848 col.ColumnName = "Name";
849 col.DataType = typeof (string);
850 table1.Columns.Add (col);
852 DataRelation dr = new DataRelation ("DR", table.Columns[0], table1.Columns[0]);
853 set.Relations.Add (dr);
856 table.CaseSensitive = true;
857 table1.CaseSensitive = true;
858 Assert.Fail ("#A01");
859 } catch (ArgumentException) {
863 CultureInfo cultureInfo = new CultureInfo ("en-gb");
864 table.Locale = cultureInfo;
865 table1.Locale = cultureInfo;
866 Assert.Fail ("#A03");
867 } catch (ArgumentException) {
871 table.Prefix = "Prefix#1";
872 Assert.Fail ("#A05");
873 } catch (DataException) {
878 public void GetErrors ()
880 DataTable table = new DataTable ();
882 DataColumn col = new DataColumn ();
883 col.ColumnName = "Id";
884 col.DataType = typeof (int);
885 table.Columns.Add (col);
887 col = new DataColumn ();
888 col.ColumnName = "Name";
889 col.DataType = typeof (string);
890 table.Columns.Add (col);
892 DataRow row = table.NewRow ();
894 row ["name"] = "Abc";
895 row.RowError = "Error#1";
896 table.Rows.Add (row);
898 Assert.AreEqual (1, table.GetErrors ().Length, "#A01");
899 Assert.AreEqual ("Error#1", (table.GetErrors ())[0].RowError, "#A02");
903 public void NewRowAddedTest ()
905 DataTable table = new DataTable ();
907 DataColumn col = new DataColumn ();
908 col.ColumnName = "Id";
909 col.DataType = typeof (int);
910 table.Columns.Add (col);
912 col = new DataColumn ();
913 col.ColumnName = "Name";
914 col.DataType = typeof (string);
915 table.Columns.Add (col);
917 _tableNewRowAddedEventFired = false;
918 table.TableNewRow += new DataTableNewRowEventHandler (OnTableNewRowAdded);
919 DataRow row = table.NewRow ();
921 row ["name"] = "Abc";
922 table.Rows.Add (row);
924 Assert.IsTrue (_tableNewRowAddedEventFired, "#NewRowAdded Event #01");
928 public void CloneCopyTest ()
930 DataTable table = new DataTable ();
931 table.TableName = "Table#1";
932 DataTable table1 = new DataTable ();
933 table1.TableName = "Table#2";
935 table.AcceptChanges ();
937 DataSet set = new DataSet ("Data Set#1");
938 set.DataSetName = "Dataset#1";
939 set.Tables.Add (table);
940 set.Tables.Add (table1);
942 DataColumn col = new DataColumn ();
943 col.ColumnName = "Id";
944 col.DataType = typeof (int);
945 table.Columns.Add (col);
946 UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
947 table.Constraints.Add (uc);
949 col = new DataColumn ();
950 col.ColumnName = "Id";
951 col.DataType = typeof (int);
952 table1.Columns.Add (col);
954 col = new DataColumn ();
955 col.ColumnName = "Name";
956 col.DataType = typeof (string);
957 table.Columns.Add (col);
959 col = new DataColumn ();
960 col.ColumnName = "Name";
961 col.DataType = typeof (string);
962 table1.Columns.Add (col);
963 DataRow row = table.NewRow ();
965 row ["name"] = "Abc";
966 row.RowError = "Error#1";
967 table.Rows.Add (row);
969 row = table.NewRow ();
971 row ["name"] = "Efg";
972 table.Rows.Add (row);
973 table.AcceptChanges ();
975 table.CaseSensitive = true;
976 table1.CaseSensitive = true;
977 table.MinimumCapacity = 100;
978 table.Prefix = "PrefixNo:1";
979 table.Namespace = "Namespace#1";
980 table.DisplayExpression = "Id / Name + (Id * Id)";
981 DataColumn[] colArray = {table.Columns[0]};
982 table.PrimaryKey = colArray;
983 table.ExtendedProperties.Add ("TimeStamp", DateTime.Now);
985 row = table1.NewRow ();
986 row ["Name"] = "Abc";
988 table1.Rows.Add (row);
990 row = table1.NewRow ();
992 row ["Name"] = "Efg";
993 table1.Rows.Add (row);
995 DataRelation dr = new DataRelation ("DR", table.Columns[0], table1.Columns[0]);
996 set.Relations.Add (dr);
998 //Testing properties of clone
999 DataTable cloneTable = table.Clone ();
1000 Assert.IsTrue (cloneTable.CaseSensitive, "#A01");
1001 Assert.AreEqual (0 , cloneTable.ChildRelations.Count, "#A02");
1002 Assert.AreEqual (0 , cloneTable.ParentRelations.Count, "#A03");
1003 Assert.AreEqual (2, cloneTable.Columns.Count, "#A04");
1004 Assert.AreEqual (1, cloneTable.Constraints.Count, "#A05");
1005 Assert.AreEqual ("Id / Name + (Id * Id)", cloneTable.DisplayExpression, "#A06");
1006 Assert.AreEqual (1, cloneTable.ExtendedProperties.Count, "#A07");
1007 Assert.IsFalse (cloneTable.HasErrors, "#A08");
1008 Assert.AreEqual (100, cloneTable.MinimumCapacity, "#A10");
1009 Assert.AreEqual ("Namespace#1", cloneTable.Namespace, "#A11");
1010 Assert.AreEqual ("PrefixNo:1", cloneTable.Prefix, "#A12");
1011 Assert.AreEqual ("Id", cloneTable.PrimaryKey[0].ColumnName, "#A13");
1012 Assert.AreEqual (0, cloneTable.Rows.Count , "#A14");
1013 Assert.AreEqual ("Table#1", cloneTable.TableName, "#A15");
1015 //Testing properties of copy
1016 DataTable copyTable = table.Copy ();
1017 Assert.IsTrue (copyTable.CaseSensitive, "#A16");
1018 Assert.AreEqual (0 , copyTable.ChildRelations.Count, "#A17");
1019 Assert.AreEqual (0 , copyTable.ParentRelations.Count, "#A18");
1020 Assert.AreEqual (2, copyTable.Columns.Count, "#A19");
1021 Assert.AreEqual (1, copyTable.Constraints.Count, "#A20");
1022 Assert.AreEqual ("Id / Name + (Id * Id)", copyTable.DisplayExpression, "#A21");
1023 Assert.AreEqual (1, copyTable.ExtendedProperties.Count, "#A22");
1024 Assert.IsTrue (copyTable.HasErrors, "#A23");
1025 Assert.AreEqual (100, copyTable.MinimumCapacity, "#A25");
1026 Assert.AreEqual ("Namespace#1", copyTable.Namespace, "#A26");
1027 Assert.AreEqual ("PrefixNo:1", copyTable.Prefix, "#A27");
1028 Assert.AreEqual ("Id", copyTable.PrimaryKey[0].ColumnName, "#A28");
1029 Assert.AreEqual (2, copyTable.Rows.Count, "#A29");
1030 Assert.AreEqual ("Table#1", copyTable.TableName, "#A30");
1034 public void CloneExtendedProperties ()
1037 DataTable t1 = new DataTable ("t1");
1038 DataColumn c1 = t1.Columns.Add ("c1");
1039 c1.ExtendedProperties.Add ("Company", "Xamarin");
1041 DataTable t2 = t1.Clone ();
1042 Assert.AreEqual ("Xamarin", t1.Columns["c1"].ExtendedProperties["Company"], "CEP1");
1043 Assert.AreEqual ("Xamarin", t2.Columns["c1"].ExtendedProperties["Company"], "CEP2");
1047 [ExpectedException (typeof (EvaluateException))]
1048 public void CloneExtendedProperties1 ()
1051 DataTable table1 = new DataTable("Table1") ;
1053 DataColumn c1 = table1.Columns.Add("c1", typeof(string), "'hello ' + c2") ; /* Should cause an exception */
1057 public void CloneExtendedProperties2 ()
1060 DataTable table1 = new DataTable("Table1") ;
1062 DataColumn c1 = table1.Columns.Add("c1") ;
1063 DataColumn c2 = table1.Columns.Add("c2") ;
1065 c1.Expression = "'hello ' + c2";
1067 DataTable t2 = table1.Clone(); // this should not cause an exception
1071 public void LoadDataException ()
1073 DataTable table = new DataTable ();
1074 DataColumn col = new DataColumn ();
1075 col.ColumnName = "Id";
1076 col.DataType = typeof (int);
1077 col.DefaultValue = 47;
1078 table.Columns.Add (col);
1079 UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
1080 table.Constraints.Add (uc);
1082 col = new DataColumn ();
1083 col.ColumnName = "Name";
1084 col.DataType = typeof (string);
1085 col.DefaultValue = "Hello";
1086 table.Columns.Add (col);
1088 table.BeginLoadData();
1089 object[] row = {147, "Abc"};
1090 DataRow newRow = table.LoadDataRow (row, true);
1092 object[] row1 = {147, "Efg"};
1093 DataRow newRow1 = table.LoadDataRow (row1, true);
1095 object[] row2 = {143, "Hij"};
1096 DataRow newRow2 = table.LoadDataRow (row2, true);
1099 table.EndLoadData ();
1100 Assert.Fail ("#A01");
1101 } catch (ConstraintException) {
1106 public void Changes () //To test GetChanges and RejectChanges
1108 DataTable table = new DataTable ();
1110 DataColumn col = new DataColumn ();
1111 col.ColumnName = "Id";
1112 col.DataType = typeof (int);
1113 table.Columns.Add (col);
1114 UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
1115 table.Constraints.Add (uc);
1117 col = new DataColumn ();
1118 col.ColumnName = "Name";
1119 col.DataType = typeof (string);
1120 table.Columns.Add (col);
1122 DataRow row = table.NewRow ();
1124 row ["name"] = "Abc";
1125 table.Rows.Add (row);
1126 table.AcceptChanges ();
1128 row = table.NewRow ();
1130 row ["name"] = "Efg";
1131 table.Rows.Add (row);
1133 //Testing GetChanges
1134 DataTable changesTable = table.GetChanges ();
1135 Assert.AreEqual (1, changesTable.Rows.Count, "#A01");
1136 Assert.AreEqual ("Efg", changesTable.Rows[0]["Name"], "#A02");
1137 table.AcceptChanges ();
1138 changesTable = table.GetChanges ();
1141 int cnt = changesTable.Rows.Count;
1143 } catch (NullReferenceException) {
1146 //Testing RejectChanges
1147 row = table.NewRow ();
1149 row ["name"] = "Hij";
1150 table.Rows.Add (row);
1152 (table.Rows [0])["Name"] = "AaBbCc";
1153 table.RejectChanges ();
1154 Assert.AreEqual ("Abc" , (table.Rows [0]) ["Name"], "#A03");
1155 Assert.AreEqual (2, table.Rows.Count, "#A04");
1159 public void ImportRowTest ()
1161 // build source table
1162 DataTable src = new DataTable ();
1163 src.Columns.Add ("id", typeof (int));
1164 src.Columns.Add ("name", typeof (string));
1166 src.PrimaryKey = new DataColumn [] {src.Columns [0]} ;
1168 src.Rows.Add (new object [] { 1, "mono 1" });
1169 src.Rows.Add (new object [] { 2, "mono 2" });
1170 src.Rows.Add (new object [] { 3, "mono 3" });
1171 src.AcceptChanges ();
1173 src.Rows [0] [1] = "mono changed 1"; // modify 1st row
1174 src.Rows [1].Delete (); // delete 2nd row
1175 // 3rd row is unchanged
1176 src.Rows.Add (new object [] { 4, "mono 4" }); // add 4th row
1178 // build target table
1179 DataTable target = new DataTable ();
1180 target.Columns.Add ("id", typeof (int));
1181 target.Columns.Add ("name", typeof (string));
1183 target.PrimaryKey = new DataColumn [] {target.Columns [0]} ;
1186 target.ImportRow (src.Rows [0]); // import 1st row
1187 target.ImportRow (src.Rows [1]); // import 2nd row
1188 target.ImportRow (src.Rows [2]); // import 3rd row
1189 target.ImportRow (src.Rows [3]); // import 4th row
1192 target.ImportRow (src.Rows [2]); // import 3rd row again
1193 Assert.Fail ("#C1");
1194 } catch (ConstraintException ex) {
1195 // Column 'id' is constrained to be unique.
1196 // Value '3' is already present
1197 Assert.AreEqual (typeof (ConstraintException), ex.GetType (), "#C2");
1198 Assert.IsNull (ex.InnerException, "#C3");
1199 Assert.IsNotNull (ex.Message, "#C4");
1200 Assert.IsTrue (ex.Message.IndexOf ("'id'") != -1, "#C5");
1201 Assert.IsTrue (ex.Message.IndexOf ("'3'") != -1, "#C6");
1205 Assert.AreEqual (src.Rows [0].RowState, target.Rows [0].RowState, "#A1");
1206 Assert.AreEqual (src.Rows [1].RowState, target.Rows [1].RowState, "#A2");
1207 Assert.AreEqual (src.Rows [2].RowState, target.Rows [2].RowState, "#A3");
1208 Assert.AreEqual (src.Rows [3].RowState, target.Rows [3].RowState, "#A4");
1210 // check for modified row (1st row)
1211 Assert.AreEqual ((string) src.Rows [0] [1], (string) target.Rows [0] [1], "#B1");
1212 Assert.AreEqual ((string) src.Rows [0] [1, DataRowVersion.Default], (string) target.Rows [0] [1, DataRowVersion.Default], "#B2");
1213 Assert.AreEqual ((string) src.Rows [0] [1, DataRowVersion.Original], (string) target.Rows [0] [1, DataRowVersion.Original], "#B3");
1214 Assert.AreEqual ((string) src.Rows [0] [1, DataRowVersion.Current], (string) target.Rows [0] [1, DataRowVersion.Current], "#B4");
1215 Assert.IsFalse (target.Rows [0].HasVersion(DataRowVersion.Proposed), "#B5");
1217 // check for deleted row (2nd row)
1218 Assert.AreEqual ((string) src.Rows [1] [1, DataRowVersion.Original], (string) target.Rows [1] [1, DataRowVersion.Original], "#C1");
1220 // check for unchanged row (3rd row)
1221 Assert.AreEqual ((string) src.Rows [2] [1], (string) target.Rows [2] [1], "#D1");
1222 Assert.AreEqual ((string) src.Rows [2] [1, DataRowVersion.Default], (string) target.Rows [2] [1, DataRowVersion.Default], "#D2");
1223 Assert.AreEqual ((string) src.Rows [2] [1, DataRowVersion.Original], (string) target.Rows [2] [1, DataRowVersion.Original], "#D3");
1224 Assert.AreEqual ((string) src.Rows [2] [1, DataRowVersion.Current], (string) target.Rows [2] [1, DataRowVersion.Current], "#D4");
1226 // check for newly added row (4th row)
1227 Assert.AreEqual ((string) src.Rows [3] [1], (string) target.Rows [3] [1], "#E1");
1228 Assert.AreEqual ((string) src.Rows [3] [1, DataRowVersion.Default], (string) target.Rows [3] [1, DataRowVersion.Default], "#E2");
1229 Assert.AreEqual ((string) src.Rows [3] [1, DataRowVersion.Current], (string) target.Rows [3] [1, DataRowVersion.Current], "#E3");
1233 public void ImportRowDetachedTest ()
1235 DataTable table = new DataTable ();
1236 DataColumn col = new DataColumn ();
1237 col.ColumnName = "Id";
1238 col.DataType = typeof (int);
1239 table.Columns.Add (col);
1241 table.PrimaryKey = new DataColumn [] {col};
1243 col = new DataColumn ();
1244 col.ColumnName = "Name";
1245 col.DataType = typeof (string);
1246 table.Columns.Add (col);
1248 DataRow row = table.NewRow ();
1250 row ["name"] = "Abc";
1252 // keep silent as ms.net ;-), though this is not useful.
1253 table.ImportRow (row);
1255 //if RowState is detached, then dont import the row.
1256 Assert.AreEqual (0, table.Rows.Count, "#1");
1260 public void ImportRowDeletedTest ()
1262 DataTable table = new DataTable ();
1263 table.Columns.Add ("col", typeof (int));
1264 table.Columns.Add ("col1", typeof (int));
1266 DataRow row = table.Rows.Add (new object[] {1,2});
1267 table.PrimaryKey = new DataColumn[] {table.Columns[0]};
1268 table.AcceptChanges ();
1270 // If row is in Deleted state, then ImportRow loads the
1273 table.ImportRow (row);
1274 Assert.AreEqual (2, table.Rows.Count, "#A1");
1276 // Both the deleted rows shud be now gone
1277 table.AcceptChanges ();
1278 Assert.AreEqual (0, table.Rows.Count, "#A2");
1280 //just add another row
1281 row = table.Rows.Add (new object[] {1,2});
1282 // no exception shud be thrown
1283 table.AcceptChanges ();
1285 // If row is in Deleted state, then ImportRow loads the
1286 // row and validate only on RejectChanges
1288 table.ImportRow (row);
1289 Assert.AreEqual (2, table.Rows.Count, "#A3");
1290 Assert.AreEqual (DataRowState.Deleted, table.Rows[1].RowState, "#A4");
1293 table.RejectChanges ();
1294 Assert.Fail ("#B1");
1295 } catch (ConstraintException ex) {
1296 // Column 'col' is constrained to be unique.
1297 // Value '1' is already present
1298 Assert.AreEqual (typeof (ConstraintException), ex.GetType (), "#B2");
1299 Assert.IsNull (ex.InnerException, "#B3");
1300 Assert.IsNotNull (ex.Message, "#B4");
1301 Assert.IsTrue (ex.Message.IndexOf ("'col'") != -1, "#B5");
1302 Assert.IsTrue (ex.Message.IndexOf ("'1'") != -1, "#B6");
1308 public void ImportRowTypeChangeTest ()
1310 // this is from http://bugzilla.xamarin.com/show_bug.cgi?id=2926
1312 Type [] types = new Type [] { typeof (string), typeof (sbyte), typeof (byte), typeof (short), typeof (ushort), typeof (int), typeof (uint), typeof (long), typeof (ulong), typeof (float), typeof (double), typeof (char), typeof (decimal), typeof (DateTime) };
1313 object [] values = new object [] { "1", (sbyte) 1, (byte) 2, (short) 3, (ushort) 4, (int) 5, (uint) 6, (long) 7, (ulong) 8, (float) 9, (double) 10, 'z', (decimal) 13, new DateTime (24) };
1314 int length = types.Length;
1316 HashSet<Tuple<Type, Type>> invalid = new HashSet<Tuple<Type, Type>> () {
1317 Tuple.Create (typeof (string), typeof (DateTime)),
1318 Tuple.Create (typeof (sbyte), typeof (DateTime)),
1319 Tuple.Create (typeof (byte), typeof (DateTime)),
1320 Tuple.Create (typeof (short), typeof (DateTime)),
1321 Tuple.Create (typeof (ushort), typeof (DateTime)),
1322 Tuple.Create (typeof (int), typeof (DateTime)),
1323 Tuple.Create (typeof (uint), typeof (DateTime)),
1324 Tuple.Create (typeof (long), typeof (DateTime)),
1325 Tuple.Create (typeof (ulong), typeof (DateTime)),
1326 Tuple.Create (typeof (float), typeof (char)),
1327 Tuple.Create (typeof (float), typeof (DateTime)),
1328 Tuple.Create (typeof (double), typeof (char)),
1329 Tuple.Create (typeof (double), typeof (DateTime)),
1330 Tuple.Create (typeof (char), typeof (float)),
1331 Tuple.Create (typeof (char), typeof (double)),
1332 Tuple.Create (typeof (char), typeof (decimal)),
1333 Tuple.Create (typeof (char), typeof (DateTime)),
1334 Tuple.Create (typeof (Decimal), typeof (char)),
1335 Tuple.Create (typeof (Decimal), typeof (DateTime)),
1336 Tuple.Create (typeof (DateTime), typeof (sbyte)),
1337 Tuple.Create (typeof (DateTime), typeof (byte)),
1338 Tuple.Create (typeof (DateTime), typeof (short)),
1339 Tuple.Create (typeof (DateTime), typeof (ushort)),
1340 Tuple.Create (typeof (DateTime), typeof (int)),
1341 Tuple.Create (typeof (DateTime), typeof (uint)),
1342 Tuple.Create (typeof (DateTime), typeof (long)),
1343 Tuple.Create (typeof (DateTime), typeof (ulong)),
1344 Tuple.Create (typeof (DateTime), typeof (float)),
1345 Tuple.Create (typeof (DateTime), typeof (double)),
1346 Tuple.Create (typeof (DateTime), typeof (char)),
1347 Tuple.Create (typeof (DateTime), typeof (decimal)),
1350 for (int a = 0; a < length; a++) {
1351 for (int b = 0; b < length; b++) {
1352 DataSet ds = new DataSet ();
1353 DataTable dt1 = ds.Tables.Add ("T1");
1354 DataTable dt2 = ds.Tables.Add ("T2");
1356 string name = "C-" + types [a].Name + "-to-" + types [b].Name;
1357 dt1.Columns.Add (name, types [a]);
1358 dt2.Columns.Add (name, types [b]);
1360 DataRow r1 = dt1.NewRow ();
1363 r1 [0] = values [a];
1365 if (invalid.Contains (Tuple.Create (types [a], types [b]))) {
1368 Assert.Fail ("#B: " + name + " expected ArgumentException");
1369 } catch /*(ArgumentException)*/ {
1374 DataRow r2 = dt2.Rows [0];
1375 Assert.AreEqual (types [b], r2 [0].GetType (), "#A: " + name);
1383 public void ClearReset () //To test Clear and Reset methods
1385 DataTable table = new DataTable ("table");
1386 DataTable table1 = new DataTable ("table1");
1388 DataSet set = new DataSet ();
1389 set.Tables.Add (table);
1390 set.Tables.Add (table1);
1392 table.Columns.Add ("Id", typeof (int));
1393 table.Columns.Add ("Name", typeof (string));
1394 table.Constraints.Add (new UniqueConstraint ("UK1", table.Columns [0]));
1395 table.CaseSensitive = false;
1397 table1.Columns.Add ("Id", typeof (int));
1398 table1.Columns.Add ("Name", typeof (string));
1400 DataRelation dr = new DataRelation ("DR", table.Columns[0], table1.Columns[0]);
1401 set.Relations.Add (dr);
1403 DataRow row = table.NewRow ();
1405 row ["name"] = "Roopa";
1406 table.Rows.Add (row);
1408 row = table.NewRow ();
1410 row ["Name"] = "roopa";
1411 table.Rows.Add (row);
1413 Assert.AreEqual (2, table.Rows.Count);
1414 Assert.AreEqual (1, table.ChildRelations.Count);
1417 Assert.Fail ("#A01, should have thrown ArgumentException");
1418 } catch (ArgumentException) {
1421 Assert.AreEqual (0, table.Rows.Count, "#CT01");
1422 Assert.AreEqual (0, table.ChildRelations.Count, "#CT02");
1423 Assert.AreEqual (0, table.ParentRelations.Count, "#CT03");
1424 Assert.AreEqual (0, table.Constraints.Count, "#CT04");
1427 Assert.AreEqual (0, table1.Rows.Count, "#A05");
1428 Assert.AreEqual (0, table1.Constraints.Count, "#A06");
1429 Assert.AreEqual (0, table1.ParentRelations.Count, "#A07");
1433 Assert.AreEqual (0, table.Rows.Count, "#A08");
1434 Assert.AreEqual (0, table.Constraints.Count, "#A09");
1435 Assert.AreEqual (0, table.ChildRelations.Count, "#A10");
1439 public void ClearTest ()
1441 DataTable table = new DataTable ("test");
1442 table.Columns.Add ("id", typeof (int));
1443 table.Columns.Add ("name", typeof (string));
1445 table.PrimaryKey = new DataColumn [] { table.Columns [0] } ;
1447 table.Rows.Add (new object [] { 1, "mono 1" });
1448 table.Rows.Add (new object [] { 2, "mono 2" });
1449 table.Rows.Add (new object [] { 3, "mono 3" });
1450 table.Rows.Add (new object [] { 4, "mono 4" });
1452 table.AcceptChanges ();
1453 _tableClearedEventFired = false;
1454 table.TableCleared += new DataTableClearEventHandler (OnTableCleared);
1455 _tableClearingEventFired = false;
1456 table.TableClearing += new DataTableClearEventHandler (OnTableClearing);
1459 Assert.IsTrue (_tableClearingEventFired, "#3 should have fired cleared event");
1460 Assert.IsTrue (_tableClearedEventFired, "#0 should have fired cleared event");
1462 DataRow r = table.Rows.Find (1);
1463 Assert.IsTrue (r == null, "#1 should have cleared");
1465 // try adding new row. indexes should have cleared
1466 table.Rows.Add (new object [] { 2, "mono 2" });
1467 Assert.AreEqual (1, table.Rows.Count, "#2 should add row");
1470 private bool _tableClearedEventFired;
1471 private void OnTableCleared (object src, DataTableClearEventArgs args)
1473 _tableClearedEventFired = true;
1476 private bool _tableClearingEventFired;
1477 private void OnTableClearing (object src, DataTableClearEventArgs args)
1479 _tableClearingEventFired = true;
1482 private bool _tableNewRowAddedEventFired;
1483 private void OnTableNewRowAdded (object src, DataTableNewRowEventArgs args)
1485 _tableNewRowAddedEventFired = true;
1489 public void TestWriteXmlSchema1 ()
1491 DataTable dt = new DataTable("TestWriteXmlSchema");
1492 dt.Columns.Add("Col1", typeof(int));
1493 dt.Columns.Add("Col2", typeof(int));
1494 DataRow dr = dt.NewRow();
1498 DataTable dt1 = new DataTable("HelloWorld");
1499 dt1.Columns.Add("T1", typeof(int));
1500 dt1.Columns.Add("T2", typeof(int));
1501 DataRow dr1 = dt1.NewRow();
1505 TextWriter writer = new StringWriter ();
1506 dt.WriteXmlSchema (writer);
1507 string TextString = writer.ToString ();
1508 string substring = TextString.Substring (0, TextString.IndexOf(EOL));
1509 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1510 Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
1512 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1513 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1514 Assert.AreEqual ("<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring, "test#02");
1515 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1516 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1517 Assert.AreEqual (" <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring, "test#03");
1518 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1519 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1520 Assert.AreEqual (" <xs:complexType>", substring, "test#04");
1522 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1523 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1524 Assert.AreEqual (" <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring, "test#05");
1526 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1527 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1528 Assert.AreEqual (" <xs:element name=\"TestWriteXmlSchema\">", substring, "test#06");
1530 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1531 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1532 Assert.AreEqual (" <xs:complexType>", substring, "test#07");
1534 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1535 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1536 Assert.AreEqual (" <xs:sequence>", substring, "test#08");
1538 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1539 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1540 Assert.AreEqual (" <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#09");
1542 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1543 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1544 Assert.AreEqual (" <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#10");
1546 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1547 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1548 Assert.AreEqual (" </xs:sequence>", substring, "test#11");
1550 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1551 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1552 Assert.AreEqual (" </xs:complexType>", substring, "test#12");
1554 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1555 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1556 Assert.AreEqual (" </xs:element>", substring, "test#13");
1558 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1559 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1560 Assert.AreEqual (" </xs:choice>", substring, "test#14");
1562 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1563 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1564 Assert.AreEqual (" </xs:complexType>", substring, "test#15");
1566 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1567 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1568 Assert.AreEqual (" </xs:element>", substring, "test#16");
1569 Assert.AreEqual ("</xs:schema>", TextString, "test#17");
1573 public void TestWriteXmlSchema2()
1575 DataTable dt = new DataTable("TestWriteXmlSchema");
1576 dt.Columns.Add("Col1", typeof(int));
1577 dt.Columns.Add("Col2", typeof(int));
1578 DataRow dr = dt.NewRow();
1582 DataTable dt1 = new DataTable("HelloWorld");
1583 dt1.Columns.Add("T1", typeof(int));
1584 dt1.Columns.Add("T2", typeof(int));
1585 DataRow dr1 = dt1.NewRow();
1589 DataSet ds = new DataSet();
1592 DataRelation rel = new DataRelation("Relation1", dt.Columns["Col1"], dt1.Columns["T1"]);
1593 ds.Relations.Add(rel);
1594 TextWriter writer = new StringWriter ();
1595 dt.WriteXmlSchema (writer);
1596 string TextString = writer.ToString ();
1597 string substring = TextString.Substring (0, TextString.IndexOf(EOL));
1598 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1599 Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
1601 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1602 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1603 Assert.AreEqual ("<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring, "test#02");
1604 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1605 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1606 Assert.AreEqual (" <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring, "test#03");
1607 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1608 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1609 Assert.AreEqual (" <xs:complexType>", substring, "test#04");
1611 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1612 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1613 Assert.AreEqual (" <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring, "test#05");
1615 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1616 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1617 Assert.AreEqual (" <xs:element name=\"TestWriteXmlSchema\">", substring, "test#06");
1619 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1620 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1621 Assert.AreEqual (" <xs:complexType>", substring, "test#07");
1623 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1624 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1625 Assert.AreEqual (" <xs:sequence>", substring, "test#08");
1627 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1628 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1629 Assert.AreEqual (" <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#09");
1631 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1632 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1633 Assert.AreEqual (" <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#10");
1635 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1636 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1637 Assert.AreEqual (" </xs:sequence>", substring, "test#11");
1639 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1640 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1641 Assert.AreEqual (" </xs:complexType>", substring, "test#12");
1643 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1644 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1645 Assert.AreEqual (" </xs:element>", substring, "test#13");
1647 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1648 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1649 Assert.AreEqual (" </xs:choice>", substring, "test#14");
1651 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1652 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1653 Assert.AreEqual (" </xs:complexType>", substring, "test#15");
1655 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1656 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1657 Assert.AreEqual (" <xs:unique name=\"Constraint1\">", substring, "test#16");
1659 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1660 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1661 Assert.AreEqual (" <xs:selector xpath=\".//TestWriteXmlSchema\" />", substring, "test#17");
1663 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1664 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1665 Assert.AreEqual (" <xs:field xpath=\"Col1\" />", substring, "test#18");
1667 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1668 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1669 Assert.AreEqual (" </xs:unique>", substring, "test#19");
1671 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1672 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1673 Assert.AreEqual (" </xs:element>", substring, "test#20");
1674 Assert.AreEqual ("</xs:schema>", TextString, "test#21");
1678 public void TestWriteXmlSchema3()
1680 DataTable dt = new DataTable("TestWriteXmlSchema");
1681 dt.Columns.Add("Col1", typeof(int));
1682 dt.Columns.Add("Col2", typeof(int));
1683 DataRow dr = dt.NewRow();
1687 DataTable dt1 = new DataTable("HelloWorld");
1688 dt1.Columns.Add("T1", typeof(int));
1689 dt1.Columns.Add("T2", typeof(int));
1690 DataRow dr1 = dt1.NewRow();
1694 DataSet ds = new DataSet();
1697 DataRelation rel = new DataRelation("Relation1", dt.Columns["Col1"], dt1.Columns["T1"]);
1698 ds.Relations.Add(rel);
1699 TextWriter writer = new StringWriter ();
1700 dt.WriteXmlSchema (writer, true);
1701 string TextString = writer.ToString ();
1702 string substring = TextString.Substring (0, TextString.IndexOf(EOL));
1703 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1704 Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
1706 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1707 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1708 Assert.AreEqual ("<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring, "test#02");
1709 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1710 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1711 Assert.AreEqual (" <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring, "test#03");
1712 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1713 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1714 Assert.AreEqual (" <xs:complexType>", substring, "test#04");
1716 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1717 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1718 Assert.AreEqual (" <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring, "test#05");
1720 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1721 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1722 Assert.AreEqual (" <xs:element name=\"TestWriteXmlSchema\">", substring, "test#06");
1724 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1725 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1726 Assert.AreEqual (" <xs:complexType>", substring, "test#07");
1728 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1729 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1730 Assert.AreEqual (" <xs:sequence>", substring, "test#08");
1732 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1733 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1734 Assert.AreEqual (" <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#09");
1736 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1737 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1738 Assert.AreEqual (" <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#10");
1740 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1741 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1742 Assert.AreEqual (" </xs:sequence>", substring, "test#11");
1744 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1745 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1746 Assert.AreEqual (" </xs:complexType>", substring, "test#12");
1748 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1749 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1750 Assert.AreEqual (" </xs:element>", substring, "test#13");
1752 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1753 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1754 Assert.AreEqual (" <xs:element name=\"HelloWorld\">", substring, "test#14");
1756 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1757 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1758 Assert.AreEqual (" <xs:complexType>", substring, "test#15");
1760 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1761 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1762 Assert.AreEqual (" <xs:sequence>", substring, "test#16");
1764 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1765 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1766 Assert.AreEqual (" <xs:element name=\"T1\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#17");
1768 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1769 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1770 Assert.AreEqual (" <xs:element name=\"T2\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#18");
1772 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1773 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1774 Assert.AreEqual (" </xs:sequence>", substring, "test#19");
1776 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1777 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1778 Assert.AreEqual (" </xs:complexType>", substring, "test#20");
1780 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1781 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1782 Assert.AreEqual (" </xs:element>", substring, "test#21");
1784 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1785 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1786 Assert.AreEqual (" </xs:choice>", substring, "test#22");
1788 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1789 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1790 Assert.AreEqual (" </xs:complexType>", substring, "test#23");
1792 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1793 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1794 Assert.AreEqual (" <xs:unique name=\"Constraint1\">", substring, "test#24");
1796 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1797 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1798 Assert.AreEqual (" <xs:selector xpath=\".//TestWriteXmlSchema\" />", substring, "test#25");
1800 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1801 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1802 Assert.AreEqual (" <xs:field xpath=\"Col1\" />", substring, "test#26");
1804 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1805 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1806 Assert.AreEqual (" </xs:unique>", substring, "test#27");
1808 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1809 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1810 Assert.AreEqual (" <xs:keyref name=\"Relation1\" refer=\"Constraint1\">", substring, "test#28");
1812 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1813 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1814 Assert.AreEqual (" <xs:selector xpath=\".//HelloWorld\" />", substring, "test#29");
1816 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1817 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1818 Assert.AreEqual (" <xs:field xpath=\"T1\" />", substring, "test#30");
1820 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1821 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1822 Assert.AreEqual (" </xs:keyref>", substring, "test#31");
1824 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1825 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1826 Assert.AreEqual (" </xs:element>", substring, "test#32");
1827 Assert.AreEqual ("</xs:schema>", TextString, "test#33");
1831 public void Serialize ()
1833 MemoryStream fs = new MemoryStream ();
1835 // Construct a BinaryFormatter and use it
1836 // to serialize the data to the stream.
1837 BinaryFormatter formatter = new BinaryFormatter();
1839 // Create an array with multiple elements refering to
1840 // the one Singleton object.
1841 DataTable dt = new DataTable();
1843 dt.Columns.Add(new DataColumn("Id", typeof(string)));
1844 dt.Columns.Add(new DataColumn("ContactName", typeof(string)));
1845 dt.Columns.Add(new DataColumn("ContactTitle", typeof(string)));
1846 dt.Columns.Add(new DataColumn("ContactAreaCode", typeof(string)));
1847 dt.Columns.Add(new DataColumn("ContactPhone", typeof(string)));
1850 loRowToAdd = dt.NewRow();
1851 loRowToAdd[0] = "a";
1852 loRowToAdd[1] = "b";
1853 loRowToAdd[2] = "c";
1854 loRowToAdd[3] = "d";
1855 loRowToAdd[4] = "e";
1856 dt.Rows.Add(loRowToAdd);
1858 DataTable[] dtarr = new DataTable[] {dt};
1860 // Serialize the array elements.
1861 formatter.Serialize(fs, dtarr);
1863 // Deserialize the array elements.
1865 DataTable[] a2 = (DataTable[]) formatter.Deserialize(fs);
1867 DataSet ds = new DataSet();
1868 ds.Tables.Add(a2[0]);
1870 StringWriter sw = new StringWriter ();
1872 XmlDocument doc = new XmlDocument ();
1873 doc.LoadXml (sw.ToString ());
1874 Assert.AreEqual (5, doc.DocumentElement.FirstChild.ChildNodes.Count);
1878 public void SetPrimaryKeyAssertsNonNull ()
1880 DataTable dt = new DataTable ("table");
1881 dt.Columns.Add ("col1");
1882 dt.Columns.Add ("col2");
1883 dt.Constraints.Add (new UniqueConstraint (dt.Columns [0]));
1884 dt.Rows.Add (new object [] {1, 3});
1885 dt.Rows.Add (new object [] {DBNull.Value, 3});
1888 dt.PrimaryKey = new DataColumn [] { dt.Columns [0] };
1890 } catch (DataException) {
1895 public void PrimaryKeyColumnChecksNonNull ()
1897 DataTable dt = new DataTable ("table");
1898 dt.Columns.Add ("col1");
1899 dt.Columns.Add ("col2");
1900 dt.Constraints.Add (new UniqueConstraint (dt.Columns [0]));
1901 dt.PrimaryKey = new DataColumn [] {dt.Columns [0]};
1902 dt.Rows.Add (new object [] {1, 3});
1905 dt.Rows.Add (new object [] { DBNull.Value, 3 });
1907 } catch (NoNullAllowedException) {
1912 public void PrimaryKey_CheckSetsAllowDBNull ()
1914 DataTable table = new DataTable ();
1915 DataColumn col1 = table.Columns.Add ("col1", typeof (int));
1916 DataColumn col2 = table.Columns.Add ("col2", typeof (int));
1918 Assert.IsTrue (col1.AllowDBNull, "#1" );
1919 Assert.IsTrue (col2.AllowDBNull, "#2" );
1920 Assert.IsFalse (col2.Unique, "#3" );
1921 Assert.IsFalse (col2.Unique, "#4" );
1923 table.PrimaryKey = new DataColumn[] {col1,col2};
1924 Assert.IsFalse (col1.AllowDBNull, "#5" );
1925 Assert.IsFalse (col2.AllowDBNull, "#6" );
1926 // LAMESPEC or bug ??
1927 Assert.IsFalse (col1.Unique, "#7" );
1928 Assert.IsFalse (col2.Unique, "#8" );
1931 void RowChanging (object o, DataRowChangeEventArgs e)
1933 Assert.AreEqual (rowChangingExpectedAction, e.Action, "changing.Action");
1934 rowChangingRowChanging = true;
1937 void RowChanged (object o, DataRowChangeEventArgs e)
1939 Assert.AreEqual (rowChangingExpectedAction, e.Action, "changed.Action");
1940 rowChangingRowChanged = true;
1943 bool rowChangingRowChanging, rowChangingRowChanged;
1944 DataRowAction rowChangingExpectedAction;
1947 public void RowChanging ()
1949 DataTable dt = new DataTable ("table");
1950 dt.Columns.Add ("col1");
1951 dt.Columns.Add ("col2");
1952 dt.RowChanging += new DataRowChangeEventHandler (RowChanging);
1953 dt.RowChanged += new DataRowChangeEventHandler (RowChanged);
1954 rowChangingExpectedAction = DataRowAction.Add;
1955 dt.Rows.Add (new object [] {1, 2});
1956 Assert.IsTrue (rowChangingRowChanging, "changing,Added");
1957 Assert.IsTrue (rowChangingRowChanged, "changed,Added");
1958 rowChangingExpectedAction = DataRowAction.Change;
1959 dt.Rows [0] [0] = 2;
1960 Assert.IsTrue (rowChangingRowChanging, "changing,Changed");
1961 Assert.IsTrue (rowChangingRowChanged, "changed,Changed");
1965 public void CloneSubClassTest()
1967 MyDataTable dt1 = new MyDataTable();
1968 MyDataTable dt = (MyDataTable)(dt1.Clone());
1969 Assert.AreEqual (2, MyDataTable.count, "A#01");
1972 DataRowAction rowActionChanging = DataRowAction.Nothing;
1973 DataRowAction rowActionChanged = DataRowAction.Nothing;
1975 public void AcceptChangesTest ()
1977 DataTable dt = new DataTable ("test");
1978 dt.Columns.Add ("id", typeof (int));
1979 dt.Columns.Add ("name", typeof (string));
1981 dt.Rows.Add (new object [] { 1, "mono 1" });
1983 dt.RowChanged += new DataRowChangeEventHandler (OnRowChanged);
1984 dt.RowChanging += new DataRowChangeEventHandler (OnRowChanging);
1987 rowActionChanged = rowActionChanging = DataRowAction.Nothing;
1988 dt.AcceptChanges ();
1990 Assert.AreEqual (DataRowAction.Commit, rowActionChanging,
1991 "#1 should have fired event and set action to commit");
1992 Assert.AreEqual (DataRowAction.Commit, rowActionChanged,
1993 "#2 should have fired event and set action to commit");
1995 dt.RowChanged -= new DataRowChangeEventHandler (OnRowChanged);
1996 dt.RowChanging -= new DataRowChangeEventHandler (OnRowChanging);
2001 public void ColumnObjectTypeTest() {
2002 DataTable dt = new DataTable();
2003 dt.Columns.Add("Series Label", typeof(SqlInt32));
2004 dt.Rows.Add(new object[] {"sss"});
2005 Assert.AreEqual (1, dt.Rows.Count);
2008 private bool tableInitialized;
2010 public void TableInitializedEventTest1 ()
2012 DataTable dt = new DataTable();
2013 tableInitialized = false;
2014 dt.Initialized += new EventHandler (OnTableInitialized);
2015 dt.Columns.Add("Series Label", typeof(SqlInt32));
2016 dt.Rows.Add(new object[] {"sss"});
2017 Assert.IsFalse (tableInitialized, "TableInitialized #01");
2018 dt.Initialized -= new EventHandler (OnTableInitialized);
2022 public void TableInitializedEventTest2 ()
2024 DataTable dt = new DataTable();
2026 tableInitialized = false;
2027 dt.Initialized += new EventHandler (OnTableInitialized);
2028 dt.Columns.Add("Series Label", typeof(SqlInt32));
2029 dt.Rows.Add(new object[] {"sss"});
2031 dt.Initialized -= new EventHandler (OnTableInitialized);
2032 Assert.IsTrue (tableInitialized, "TableInitialized #02");
2036 public void TableInitializedEventTest3 ()
2038 DataTable dt = new DataTable();
2039 tableInitialized = true;
2040 dt.Initialized += new EventHandler (OnTableInitialized);
2041 dt.Columns.Add("Series Label", typeof(SqlInt32));
2042 dt.Rows.Add(new object[] {"sss"});
2043 Assert.AreEqual (tableInitialized, dt.IsInitialized, "TableInitialized #03");
2044 dt.Initialized -= new EventHandler (OnTableInitialized);
2048 public void TableInitializedEventTest4 ()
2050 DataTable dt = new DataTable();
2051 Assert.IsTrue (dt.IsInitialized, "TableInitialized #04");
2053 tableInitialized = false;
2054 dt.Initialized += new EventHandler (OnTableInitialized);
2055 dt.Columns.Add("Series Label", typeof(SqlInt32));
2056 dt.Rows.Add(new object[] {"sss"});
2057 Assert.IsFalse (dt.IsInitialized, "TableInitialized #05");
2059 Assert.IsTrue (dt.IsInitialized, "TableInitialized #06");
2060 Assert.IsTrue (tableInitialized, "TableInitialized #07");
2061 dt.Initialized -= new EventHandler (OnTableInitialized);
2064 private void OnTableInitialized (object src, EventArgs args)
2066 tableInitialized = true;
2069 public void OnRowChanging (object src, DataRowChangeEventArgs args)
2071 rowActionChanging = args.Action;
2074 public void OnRowChanged (object src, DataRowChangeEventArgs args)
2076 rowActionChanged = args.Action;
2079 private DataTable dt;
2080 private void localSetup () {
2081 dt = new DataTable ("test");
2082 dt.Columns.Add ("id", typeof (int));
2083 dt.Columns.Add ("name", typeof (string));
2084 dt.PrimaryKey = new DataColumn[] { dt.Columns["id"] };
2086 dt.Rows.Add (new object[] { 1, "mono 1" });
2087 dt.Rows.Add (new object[] { 2, "mono 2" });
2088 dt.Rows.Add (new object[] { 3, "mono 3" });
2090 dt.AcceptChanges ();
2093 #region DataTable.CreateDataReader Tests
2096 public void CreateDataReader1 ()
2099 DataTableReader dtr = dt.CreateDataReader ();
2100 Assert.IsTrue (dtr.HasRows, "HasRows");
2101 Assert.AreEqual (dt.Columns.Count, dtr.FieldCount, "CountCols");
2103 while (dtr.Read ()) {
2104 for (int i = 0; i < dtr.FieldCount; i++) {
2105 Assert.AreEqual (dt.Rows[ri][i], dtr[i], "RowData-" + ri + "-" + i);
2112 public void CreateDataReader2 ()
2115 DataTableReader dtr = dt.CreateDataReader ();
2116 Assert.IsTrue (dtr.HasRows, "HasRows");
2117 Assert.AreEqual (dt.Columns.Count, dtr.FieldCount, "CountCols");
2119 Assert.AreEqual (1, dtr[0], "RowData0-0");
2120 Assert.AreEqual ("mono 1", dtr[1], "RowData0-1");
2122 Assert.AreEqual (2, dtr[0], "RowData1-0");
2123 Assert.AreEqual ("mono 2", dtr[1], "RowData1-1");
2125 Assert.AreEqual (3, dtr[0], "RowData2-0");
2126 Assert.AreEqual ("mono 3", dtr[1], "RowData2-1");
2129 #endregion // DataTable.CreateDataReader Tests
2131 #region DataTable.Load Tests
2134 public void Load_Basic ()
2137 DataTable dtLoad = new DataTable ("LoadBasic");
2138 dtLoad.Columns.Add ("id", typeof (int));
2139 dtLoad.Columns.Add ("name", typeof (string));
2140 dtLoad.Columns["id"].ReadOnly = true;
2141 dtLoad.Columns["name"].ReadOnly = true;
2142 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2143 dtLoad.Rows.Add (new object[] { 1, "load 1" });
2144 dtLoad.Rows.Add (new object[] { 2, "load 2" });
2145 dtLoad.Rows.Add (new object[] { 3, "load 3" });
2146 dtLoad.AcceptChanges ();
2147 DataTableReader dtr = dt.CreateDataReader ();
2149 Assert.AreEqual (2, dtLoad.Columns.Count, "NColumns");
2150 Assert.AreEqual (3, dtLoad.Rows.Count, "NRows");
2151 Assert.AreEqual (1, dtLoad.Rows[0][0], "RowData0-0");
2152 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1], "RowData0-1");
2153 Assert.AreEqual (2, dtLoad.Rows[1][0], "RowData1-0");
2154 Assert.AreEqual ("mono 2", dtLoad.Rows[1][1], "RowData1-1");
2155 Assert.AreEqual (3, dtLoad.Rows[2][0], "RowData2-0");
2156 Assert.AreEqual ("mono 3", dtLoad.Rows[2][1], "RowData2-1");
2160 public void Load_NoSchema ()
2163 DataTable dtLoad = new DataTable ("LoadNoSchema");
2164 DataTableReader dtr = dt.CreateDataReader ();
2166 Assert.AreEqual (2, dtLoad.Columns.Count, "NColumns");
2167 Assert.AreEqual (3, dtLoad.Rows.Count, "NRows");
2168 Assert.AreEqual (1, dtLoad.Rows[0][0], "RowData0-0");
2169 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1], "RowData0-1");
2170 Assert.AreEqual (2, dtLoad.Rows[1][0], "RowData1-0");
2171 Assert.AreEqual ("mono 2", dtLoad.Rows[1][1], "RowData1-1");
2172 Assert.AreEqual (3, dtLoad.Rows[2][0], "RowData2-0");
2173 Assert.AreEqual ("mono 3", dtLoad.Rows[2][1], "RowData2-1");
2176 internal struct fillErrorStruct
2178 internal string error;
2179 internal string tableName;
2180 internal int rowKey;
2181 internal bool contFlag;
2183 internal void init (string tbl, int row, bool cont, string err)
2191 private fillErrorStruct[] fillErr = new fillErrorStruct[3];
2192 private int fillErrCounter;
2193 private void fillErrorHandler (object sender, FillErrorEventArgs e)
2195 e.Continue = fillErr[fillErrCounter].contFlag;
2196 Assert.AreEqual (fillErr[fillErrCounter].tableName, e.DataTable.TableName, "fillErr-T");
2197 //Assert.AreEqual (fillErr[fillErrCounter].rowKey, e.Values[0], "fillErr-R");
2198 Assert.AreEqual (fillErr[fillErrCounter].contFlag, e.Continue, "fillErr-C");
2199 //Assert.AreEqual (fillErr[fillErrCounter].error, e.Errors.Message, "fillErr-E");
2204 public void Load_Incompatible ()
2207 DataTable dtLoad = new DataTable ("LoadIncompatible");
2208 dtLoad.Columns.Add ("name", typeof (double));
2209 DataTableReader dtr = dt.CreateDataReader ();
2213 } catch (ArgumentException) {
2217 // Load doesn't have a third overload in System.Data
2218 // and is commented-out below
2219 public void Load_IncompatibleEHandlerT ()
2222 fillErr[0].init ("LoadIncompatible", 1, true,
2223 "Input string was not in a correct format.Couldn't store <mono 1> in name Column. Expected type is Double.");
2224 fillErr[1].init ("LoadIncompatible", 2, true,
2225 "Input string was not in a correct format.Couldn't store <mono 2> in name Column. Expected type is Double.");
2226 fillErr[2].init ("LoadIncompatible", 3, true,
2227 "Input string was not in a correct format.Couldn't store <mono 3> in name Column. Expected type is Double.");
2229 DataTable dtLoad = new DataTable ("LoadIncompatible");
2230 dtLoad.Columns.Add ("name", typeof (double));
2231 DataTableReader dtr = dt.CreateDataReader ();
2232 dtLoad.Load (dtr,LoadOption.PreserveChanges,fillErrorHandler);
2236 // Load doesn't have a third overload in System.Data
2237 // and is commented-out below
2238 public void Load_IncompatibleEHandlerF ()
2241 fillErr[0].init ("LoadIncompatible", 1, false,
2242 "Input string was not in a correct format.Couldn't store <mono 1> in name Column. Expected type is Double.");
2244 DataTable dtLoad = new DataTable ("LoadIncompatible");
2245 dtLoad.Columns.Add ("name", typeof (double));
2246 DataTableReader dtr = dt.CreateDataReader ();
2248 dtLoad.Load (dtr, LoadOption.PreserveChanges, fillErrorHandler);
2250 } catch (ArgumentException) {
2255 public void Load_ExtraColsEqualVal ()
2258 DataTable dtLoad = new DataTable ("LoadExtraCols");
2259 dtLoad.Columns.Add ("id", typeof (int));
2260 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2261 dtLoad.Rows.Add (new object[] { 1 });
2262 dtLoad.Rows.Add (new object[] { 2 });
2263 dtLoad.Rows.Add (new object[] { 3 });
2264 dtLoad.AcceptChanges ();
2265 DataTableReader dtr = dt.CreateDataReader ();
2267 Assert.AreEqual (2, dtLoad.Columns.Count, "NColumns");
2268 Assert.AreEqual (3, dtLoad.Rows.Count, "NRows");
2269 Assert.AreEqual (1, dtLoad.Rows[0][0], "RowData0-0");
2270 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1], "RowData0-1");
2271 Assert.AreEqual (2, dtLoad.Rows[1][0], "RowData1-0");
2272 Assert.AreEqual ("mono 2", dtLoad.Rows[1][1], "RowData1-1");
2273 Assert.AreEqual (3, dtLoad.Rows[2][0], "RowData2-0");
2274 Assert.AreEqual ("mono 3", dtLoad.Rows[2][1], "RowData2-1");
2278 public void Load_ExtraColsNonEqualVal ()
2281 DataTable dtLoad = new DataTable ("LoadExtraCols");
2282 dtLoad.Columns.Add ("id", typeof (int));
2283 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2284 dtLoad.Rows.Add (new object[] { 4 });
2285 dtLoad.Rows.Add (new object[] { 5 });
2286 dtLoad.Rows.Add (new object[] { 6 });
2287 dtLoad.AcceptChanges ();
2288 DataTableReader dtr = dt.CreateDataReader ();
2290 Assert.AreEqual (2, dtLoad.Columns.Count, "NColumns");
2291 Assert.AreEqual (6, dtLoad.Rows.Count, "NRows");
2292 Assert.AreEqual (4, dtLoad.Rows[0][0], "RowData0-0");
2293 Assert.AreEqual (5, dtLoad.Rows[1][0], "RowData1-0");
2294 Assert.AreEqual (6, dtLoad.Rows[2][0], "RowData2-0");
2295 Assert.AreEqual (1, dtLoad.Rows[3][0], "RowData3-0");
2296 Assert.AreEqual ("mono 1", dtLoad.Rows[3][1], "RowData3-1");
2297 Assert.AreEqual (2, dtLoad.Rows[4][0], "RowData4-0");
2298 Assert.AreEqual ("mono 2", dtLoad.Rows[4][1], "RowData4-1");
2299 Assert.AreEqual (3, dtLoad.Rows[5][0], "RowData5-0");
2300 Assert.AreEqual ("mono 3", dtLoad.Rows[5][1], "RowData5-1");
2304 public void Load_MissingColsNonNullable ()
2307 DataTable dtLoad = new DataTable ("LoadMissingCols");
2308 dtLoad.Columns.Add ("id", typeof (int));
2309 dtLoad.Columns.Add ("name", typeof (string));
2310 dtLoad.Columns.Add ("missing", typeof (string));
2311 dtLoad.Columns["missing"].AllowDBNull = false;
2312 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2313 dtLoad.Rows.Add (new object[] { 4, "mono 4", "miss4" });
2314 dtLoad.Rows.Add (new object[] { 5, "mono 5", "miss5" });
2315 dtLoad.Rows.Add (new object[] { 6, "mono 6", "miss6" });
2316 dtLoad.AcceptChanges ();
2317 DataTableReader dtr = dt.CreateDataReader ();
2321 } catch (ConstraintException) {
2326 public void Load_MissingColsDefault ()
2329 DataTable dtLoad = new DataTable ("LoadMissingCols");
2330 dtLoad.Columns.Add ("id", typeof (int));
2331 dtLoad.Columns.Add ("name", typeof (string));
2332 dtLoad.Columns.Add ("missing", typeof (string));
2333 dtLoad.Columns["missing"].AllowDBNull = false;
2334 dtLoad.Columns["missing"].DefaultValue = "DefaultValue";
2335 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2336 dtLoad.Rows.Add (new object[] { 4, "mono 4", "miss4" });
2337 dtLoad.Rows.Add (new object[] { 5, "mono 5", "miss5" });
2338 dtLoad.Rows.Add (new object[] { 6, "mono 6", "miss6" });
2339 dtLoad.AcceptChanges ();
2340 DataTableReader dtr = dt.CreateDataReader ();
2342 Assert.AreEqual (3, dtLoad.Columns.Count, "NColumns");
2343 Assert.AreEqual (6, dtLoad.Rows.Count, "NRows");
2344 Assert.AreEqual (4, dtLoad.Rows[0][0], "RowData0-0");
2345 Assert.AreEqual ("mono 4", dtLoad.Rows[0][1], "RowData0-1");
2346 Assert.AreEqual ("miss4", dtLoad.Rows[0][2], "RowData0-2");
2347 Assert.AreEqual (5, dtLoad.Rows[1][0], "RowData1-0");
2348 Assert.AreEqual ("mono 5", dtLoad.Rows[1][1], "RowData1-1");
2349 Assert.AreEqual ("miss5", dtLoad.Rows[1][2], "RowData1-2");
2350 Assert.AreEqual (6, dtLoad.Rows[2][0], "RowData2-0");
2351 Assert.AreEqual ("mono 6", dtLoad.Rows[2][1], "RowData2-1");
2352 Assert.AreEqual ("miss6", dtLoad.Rows[2][2], "RowData2-2");
2353 Assert.AreEqual (1, dtLoad.Rows[3][0], "RowData3-0");
2354 Assert.AreEqual ("mono 1", dtLoad.Rows[3][1], "RowData3-1");
2355 Assert.AreEqual ("DefaultValue", dtLoad.Rows[3][2], "RowData3-2");
2356 Assert.AreEqual (2, dtLoad.Rows[4][0], "RowData4-0");
2357 Assert.AreEqual ("mono 2", dtLoad.Rows[4][1], "RowData4-1");
2358 Assert.AreEqual ("DefaultValue", dtLoad.Rows[4][2], "RowData4-2");
2359 Assert.AreEqual (3, dtLoad.Rows[5][0], "RowData5-0");
2360 Assert.AreEqual ("mono 3", dtLoad.Rows[5][1], "RowData5-1");
2361 Assert.AreEqual ("DefaultValue", dtLoad.Rows[5][2], "RowData5-2");
2365 public void Load_MissingColsNullable ()
2368 DataTable dtLoad = new DataTable ("LoadMissingCols");
2369 dtLoad.Columns.Add ("id", typeof (int));
2370 dtLoad.Columns.Add ("name", typeof (string));
2371 dtLoad.Columns.Add ("missing", typeof (string));
2372 dtLoad.Columns["missing"].AllowDBNull = true;
2373 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2374 dtLoad.Rows.Add (new object[] { 4, "mono 4", "miss4" });
2375 dtLoad.Rows.Add (new object[] { 5, "mono 5", "miss5" });
2376 dtLoad.Rows.Add (new object[] { 6, "mono 6", "miss6" });
2377 dtLoad.AcceptChanges ();
2378 DataTableReader dtr = dt.CreateDataReader ();
2380 Assert.AreEqual (3, dtLoad.Columns.Count, "NColumns");
2381 Assert.AreEqual (6, dtLoad.Rows.Count, "NRows");
2382 Assert.AreEqual (4, dtLoad.Rows[0][0], "RowData0-0");
2383 Assert.AreEqual ("mono 4", dtLoad.Rows[0][1], "RowData0-1");
2384 Assert.AreEqual ("miss4", dtLoad.Rows[0][2], "RowData0-2");
2385 Assert.AreEqual (5, dtLoad.Rows[1][0], "RowData1-0");
2386 Assert.AreEqual ("mono 5", dtLoad.Rows[1][1], "RowData1-1");
2387 Assert.AreEqual ("miss5", dtLoad.Rows[1][2], "RowData1-2");
2388 Assert.AreEqual (6, dtLoad.Rows[2][0], "RowData2-0");
2389 Assert.AreEqual ("mono 6", dtLoad.Rows[2][1], "RowData2-1");
2390 Assert.AreEqual ("miss6", dtLoad.Rows[2][2], "RowData2-2");
2391 Assert.AreEqual (1, dtLoad.Rows[3][0], "RowData3-0");
2392 Assert.AreEqual ("mono 1", dtLoad.Rows[3][1], "RowData3-1");
2393 //Assert.IsNull (dtLoad.Rows[3][2], "RowData3-2");
2394 Assert.AreEqual (2, dtLoad.Rows[4][0], "RowData4-0");
2395 Assert.AreEqual ("mono 2", dtLoad.Rows[4][1], "RowData4-1");
2396 //Assert.IsNull (dtLoad.Rows[4][2], "RowData4-2");
2397 Assert.AreEqual (3, dtLoad.Rows[5][0], "RowData5-0");
2398 Assert.AreEqual ("mono 3", dtLoad.Rows[5][1], "RowData5-1");
2399 //Assert.IsNull (dtLoad.Rows[5][2], "RowData5-2");
2402 private DataTable setupRowState ()
2404 DataTable tbl = new DataTable ("LoadRowStateChanges");
2405 tbl.RowChanged += new DataRowChangeEventHandler (dtLoad_RowChanged);
2406 tbl.RowChanging += new DataRowChangeEventHandler (dtLoad_RowChanging);
2407 tbl.Columns.Add ("id", typeof (int));
2408 tbl.Columns.Add ("name", typeof (string));
2409 tbl.PrimaryKey = new DataColumn[] { tbl.Columns["id"] };
2410 tbl.Rows.Add (new object[] { 1, "RowState 1" });
2411 tbl.Rows.Add (new object[] { 2, "RowState 2" });
2412 tbl.Rows.Add (new object[] { 3, "RowState 3" });
2413 tbl.AcceptChanges ();
2414 // Update Table with following changes: Row0 unmodified,
2415 // Row1 modified, Row2 deleted, Row3 added, Row4 not-present.
2416 tbl.Rows[1]["name"] = "Modify 2";
2417 tbl.Rows[2].Delete ();
2418 DataRow row = tbl.NewRow ();
2420 row["name"] = "Add 4";
2425 private DataRowAction[] rowChangeAction = new DataRowAction[5];
2426 private bool checkAction;
2427 private int rowChagedCounter, rowChangingCounter;
2428 private void rowActionInit (DataRowAction[] act)
2431 rowChagedCounter = 0;
2432 rowChangingCounter = 0;
2433 for (int i = 0; i < 5; i++)
2434 rowChangeAction[i] = act[i];
2437 private void rowActionEnd ()
2439 checkAction = false;
2442 private void dtLoad_RowChanged (object sender, DataRowChangeEventArgs e)
2445 Assert.AreEqual (rowChangeAction[rowChagedCounter], e.Action, "RowChanged" + rowChagedCounter);
2450 private void dtLoad_RowChanging (object sender, DataRowChangeEventArgs e)
2453 Assert.AreEqual (rowChangeAction[rowChangingCounter], e.Action, "RowChanging" + rowChangingCounter);
2454 rowChangingCounter++;
2459 public void Load_RowStateChangesDefault ()
2462 dt.Rows.Add (new object[] { 4, "mono 4" });
2463 dt.Rows.Add (new object[] { 5, "mono 5" });
2464 dt.AcceptChanges ();
2465 DataTableReader dtr = dt.CreateDataReader ();
2466 DataTable dtLoad = setupRowState ();
2467 DataRowAction[] dra = new DataRowAction[] {
2468 DataRowAction.ChangeCurrentAndOriginal,
2469 DataRowAction.ChangeOriginal,
2470 DataRowAction.ChangeOriginal,
2471 DataRowAction.ChangeOriginal,
2472 DataRowAction.ChangeCurrentAndOriginal};
2473 rowActionInit (dra);
2476 // asserting Unchanged Row0
2477 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1,DataRowVersion.Current], "RowData0-C");
2478 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1,DataRowVersion.Original], "RowData0-O");
2479 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[0].RowState, "RowState0");
2480 // asserting Modified Row1
2481 Assert.AreEqual ("Modify 2", dtLoad.Rows[1][1, DataRowVersion.Current], "RowData1-C");
2482 Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Original], "RowData1-O");
2483 Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[1].RowState, "RowState1");
2484 // asserting Deleted Row2
2485 Assert.AreEqual ("mono 3", dtLoad.Rows[2][1, DataRowVersion.Original], "RowData1-O");
2486 Assert.AreEqual (DataRowState.Deleted, dtLoad.Rows[2].RowState, "RowState2");
2487 // asserting Added Row3
2488 Assert.AreEqual ("Add 4", dtLoad.Rows[3][1, DataRowVersion.Current], "RowData3-C");
2489 Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2490 Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[3].RowState, "RowState3");
2491 // asserting Unpresent Row4
2492 Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Current], "RowData4-C");
2493 Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Original], "RowData4-O");
2494 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[4].RowState, "RowState4");
2498 public void Load_RowStateChangesDefaultDelete ()
2501 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2502 dtLoad.Columns.Add ("id", typeof (int));
2503 dtLoad.Columns.Add ("name", typeof (string));
2504 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2505 dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2506 dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2507 dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2508 dtLoad.AcceptChanges ();
2509 dtLoad.Rows[2].Delete ();
2510 DataTableReader dtr = dt.CreateDataReader ();
2514 Assert.AreEqual (" ", dtLoad.Rows[2][1, DataRowVersion.Current], "RowData2-C");
2516 } catch (VersionNotFoundException) {
2521 public void Load_RowStatePreserveChanges ()
2524 dt.Rows.Add (new object[] { 4, "mono 4" });
2525 dt.Rows.Add (new object[] { 5, "mono 5" });
2526 dt.AcceptChanges ();
2527 DataTableReader dtr = dt.CreateDataReader ();
2528 DataTable dtLoad = setupRowState ();
2529 DataRowAction[] dra = new DataRowAction[] {
2530 DataRowAction.ChangeCurrentAndOriginal,
2531 DataRowAction.ChangeOriginal,
2532 DataRowAction.ChangeOriginal,
2533 DataRowAction.ChangeOriginal,
2534 DataRowAction.ChangeCurrentAndOriginal};
2535 rowActionInit (dra);
2536 dtLoad.Load (dtr, LoadOption.PreserveChanges);
2538 // asserting Unchanged Row0
2539 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Current], "RowData0-C");
2540 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Original], "RowData0-O");
2541 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[0].RowState, "RowState0");
2542 // asserting Modified Row1
2543 Assert.AreEqual ("Modify 2", dtLoad.Rows[1][1, DataRowVersion.Current], "RowData1-C");
2544 Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Original], "RowData1-O");
2545 Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[1].RowState, "RowState1");
2546 // asserting Deleted Row2
2547 Assert.AreEqual ("mono 3", dtLoad.Rows[2][1, DataRowVersion.Original], "RowData1-O");
2548 Assert.AreEqual (DataRowState.Deleted, dtLoad.Rows[2].RowState, "RowState2");
2549 // asserting Added Row3
2550 Assert.AreEqual ("Add 4", dtLoad.Rows[3][1, DataRowVersion.Current], "RowData3-C");
2551 Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2552 Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[3].RowState, "RowState3");
2553 // asserting Unpresent Row4
2554 Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Current], "RowData4-C");
2555 Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Original], "RowData4-O");
2556 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[4].RowState, "RowState4");
2560 public void Load_RowStatePreserveChangesDelete () {
2562 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2563 dtLoad.Columns.Add ("id", typeof (int));
2564 dtLoad.Columns.Add ("name", typeof (string));
2565 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2566 dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2567 dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2568 dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2569 dtLoad.AcceptChanges ();
2570 dtLoad.Rows[2].Delete ();
2571 DataTableReader dtr = dt.CreateDataReader ();
2572 dtLoad.Load (dtr,LoadOption.PreserveChanges);
2575 Assert.AreEqual (" ", dtLoad.Rows[2][1, DataRowVersion.Current], "RowData2-C");
2577 } catch (VersionNotFoundException) {
2582 public void Load_RowStateOverwriteChanges ()
2585 dt.Rows.Add (new object[] { 4, "mono 4" });
2586 dt.Rows.Add (new object[] { 5, "mono 5" });
2587 dt.AcceptChanges ();
2588 DataTableReader dtr = dt.CreateDataReader ();
2589 DataTable dtLoad = setupRowState ();
2590 DataRowAction[] dra = new DataRowAction[] {
2591 DataRowAction.ChangeCurrentAndOriginal,
2592 DataRowAction.ChangeCurrentAndOriginal,
2593 DataRowAction.ChangeCurrentAndOriginal,
2594 DataRowAction.ChangeCurrentAndOriginal,
2595 DataRowAction.ChangeCurrentAndOriginal};
2596 rowActionInit (dra);
2597 dtLoad.Load (dtr, LoadOption.OverwriteChanges);
2599 // asserting Unchanged Row0
2600 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Current], "RowData0-C");
2601 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Original], "RowData0-O");
2602 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[0].RowState, "RowState0");
2603 // asserting Modified Row1
2604 Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Current], "RowData1-C");
2605 Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Original], "RowData1-O");
2606 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[1].RowState, "RowState1");
2607 // asserting Deleted Row2
2608 Assert.AreEqual ("mono 3", dtLoad.Rows[2][1, DataRowVersion.Current], "RowData1-C");
2609 Assert.AreEqual ("mono 3", dtLoad.Rows[2][1, DataRowVersion.Original], "RowData1-O");
2610 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[2].RowState, "RowState2");
2611 // asserting Added Row3
2612 Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Current], "RowData3-C");
2613 Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2614 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[3].RowState, "RowState3");
2615 // asserting Unpresent Row4
2616 Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Current], "RowData4-C");
2617 Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Original], "RowData4-O");
2618 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[4].RowState, "RowState4");
2622 public void Load_RowStateUpsert ()
2625 dt.Rows.Add (new object[] { 4, "mono 4" });
2626 dt.Rows.Add (new object[] { 5, "mono 5" });
2627 dt.AcceptChanges ();
2628 DataTableReader dtr = dt.CreateDataReader ();
2629 DataTable dtLoad = setupRowState ();
2630 // Notice rowChange-Actions only occur 5 times, as number
2631 // of actual rows, ignoring row duplication of the deleted row.
2632 DataRowAction[] dra = new DataRowAction[] {
2633 DataRowAction.Change,
2634 DataRowAction.Change,
2636 DataRowAction.Change,
2638 rowActionInit (dra);
2639 dtLoad.Load (dtr, LoadOption.Upsert);
2641 // asserting Unchanged Row0
2642 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Current], "RowData0-C");
2643 Assert.AreEqual ("RowState 1", dtLoad.Rows[0][1, DataRowVersion.Original], "RowData0-O");
2644 Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[0].RowState, "RowState0");
2645 // asserting Modified Row1
2646 Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Current], "RowData1-C");
2647 Assert.AreEqual ("RowState 2", dtLoad.Rows[1][1, DataRowVersion.Original], "RowData1-O");
2648 Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[1].RowState, "RowState1");
2649 // asserting Deleted Row2 and "Deleted-Added" Row4
2650 Assert.AreEqual ("RowState 3", dtLoad.Rows[2][1, DataRowVersion.Original], "RowData2-O");
2651 Assert.AreEqual (DataRowState.Deleted, dtLoad.Rows[2].RowState, "RowState2");
2652 Assert.AreEqual ("mono 3", dtLoad.Rows[4][1, DataRowVersion.Current], "RowData4-C");
2653 Assert.AreEqual (DataRowState.Added, dtLoad.Rows[4].RowState, "RowState4");
2654 // asserting Added Row3
2655 Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Current], "RowData3-C");
2656 Assert.AreEqual (DataRowState.Added, dtLoad.Rows[3].RowState, "RowState3");
2657 // asserting Unpresent Row5
2658 // Notice row4 is used for added row of deleted row2 and so
2659 // unpresent row4 moves to row5
2660 Assert.AreEqual ("mono 5", dtLoad.Rows[5][1, DataRowVersion.Current], "RowData5-C");
2661 Assert.AreEqual (DataRowState.Added, dtLoad.Rows[5].RowState, "RowState5");
2665 public void Load_RowStateUpsertDuplicateKey1 ()
2668 dt.Rows.Add (new object[] { 4, "mono 4" });
2669 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2670 dtLoad.Columns.Add ("id", typeof (int));
2671 dtLoad.Columns.Add ("name", typeof (string));
2672 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2673 dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2674 dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2675 dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2676 dtLoad.AcceptChanges ();
2677 dtLoad.Rows[2].Delete ();
2678 DataTableReader dtr = dt.CreateDataReader ();
2679 dtLoad.Load (dtr, LoadOption.Upsert);
2680 dtLoad.Rows[3][1] = "NEWVAL";
2681 Assert.AreEqual (DataRowState.Deleted, dtLoad.Rows[2].RowState, "A-RowState2");
2682 Assert.AreEqual (3, dtLoad.Rows[2][0, DataRowVersion.Original], "A-RowData2-id");
2683 Assert.AreEqual ("RowState 3", dtLoad.Rows[2][1, DataRowVersion.Original], "A-RowData2-name");
2684 Assert.AreEqual (DataRowState.Added, dtLoad.Rows[3].RowState, "A-RowState3");
2685 Assert.AreEqual (3, dtLoad.Rows[3][0, DataRowVersion.Current], "A-RowData3-id");
2686 Assert.AreEqual ("NEWVAL", dtLoad.Rows[3][1, DataRowVersion.Current], "A-RowData3-name");
2687 Assert.AreEqual (DataRowState.Added, dtLoad.Rows[4].RowState, "A-RowState4");
2688 Assert.AreEqual (4, dtLoad.Rows[4][0, DataRowVersion.Current], "A-RowData4-id");
2689 Assert.AreEqual ("mono 4", dtLoad.Rows[4][1, DataRowVersion.Current], "A-RowData4-name");
2691 dtLoad.AcceptChanges ();
2693 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[2].RowState, "B-RowState2");
2694 Assert.AreEqual (3, dtLoad.Rows[2][0, DataRowVersion.Current], "B-RowData2-id");
2695 Assert.AreEqual ("NEWVAL", dtLoad.Rows[2][1, DataRowVersion.Current], "B-RowData2-name");
2696 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[3].RowState, "B-RowState3");
2697 Assert.AreEqual (4, dtLoad.Rows[3][0, DataRowVersion.Current], "B-RowData3-id");
2698 Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Current], "B-RowData3-name");
2702 public void Load_RowStateUpsertDuplicateKey2 ()
2705 dt.Rows.Add (new object[] { 4, "mono 4" });
2706 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2707 dtLoad.Columns.Add ("id", typeof (int));
2708 dtLoad.Columns.Add ("name", typeof (string));
2709 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2710 dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2711 dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2712 dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2713 dtLoad.AcceptChanges ();
2714 dtLoad.Rows[2].Delete ();
2715 DataTableReader dtr = dt.CreateDataReader ();
2716 dtLoad.Load (dtr, LoadOption.Upsert);
2717 dtLoad.AcceptChanges ();
2720 Assert.AreEqual (" ", dtLoad.Rows[4][1], "RowData4");
2722 } catch (IndexOutOfRangeException) {
2727 public void Load_RowStateUpsertDelete1 ()
2730 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2731 dtLoad.Columns.Add ("id", typeof (int));
2732 dtLoad.Columns.Add ("name", typeof (string));
2733 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2734 dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2735 dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2736 dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2737 dtLoad.AcceptChanges ();
2738 dtLoad.Rows[2].Delete ();
2739 DataTableReader dtr = dt.CreateDataReader ();
2740 dtLoad.Load (dtr, LoadOption.Upsert);
2743 Assert.AreEqual (" ", dtLoad.Rows[2][1, DataRowVersion.Current], "RowData2-C");
2745 } catch (VersionNotFoundException) {
2750 public void Load_RowStateUpsertDelete2 ()
2753 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2754 dtLoad.Columns.Add ("id", typeof (int));
2755 dtLoad.Columns.Add ("name", typeof (string));
2756 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2757 dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2758 dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2759 dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2760 dtLoad.AcceptChanges ();
2761 dtLoad.Rows[2].Delete ();
2762 DataTableReader dtr = dt.CreateDataReader ();
2763 dtLoad.Load (dtr, LoadOption.Upsert);
2766 Assert.AreEqual (" ", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2768 } catch (VersionNotFoundException) {
2773 public void Load_RowStateUpsertAdd ()
2776 dt.Rows.Add (new object[] { 4, "mono 4" });
2777 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2778 dtLoad.Columns.Add ("id", typeof (int));
2779 dtLoad.Columns.Add ("name", typeof (string));
2780 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2781 dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2782 dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2783 dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2784 dtLoad.AcceptChanges ();
2785 DataRow row = dtLoad.NewRow ();
2787 row["name"] = "Add 4";
2788 dtLoad.Rows.Add (row);
2789 DataTableReader dtr = dt.CreateDataReader ();
2790 dtLoad.Load (dtr, LoadOption.Upsert);
2793 Assert.AreEqual (" ", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2795 } catch (VersionNotFoundException) {
2800 public void Load_RowStateUpsertUnpresent () {
2802 dt.Rows.Add (new object[] { 4, "mono 4" });
2803 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2804 dtLoad.Columns.Add ("id", typeof (int));
2805 dtLoad.Columns.Add ("name", typeof (string));
2806 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2807 dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2808 dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2809 dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2810 dtLoad.AcceptChanges ();
2811 DataTableReader dtr = dt.CreateDataReader ();
2812 dtLoad.Load (dtr, LoadOption.Upsert);
2815 Assert.AreEqual (" ", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2817 } catch (VersionNotFoundException) {
2822 public void Load_RowStateUpsertUnchangedEqualVal ()
2825 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2826 dtLoad.Columns.Add ("id", typeof (int));
2827 dtLoad.Columns.Add ("name", typeof (string));
2828 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2829 dtLoad.Rows.Add (new object[] { 1, "mono 1" });
2830 dtLoad.AcceptChanges ();
2831 DataTableReader dtr = dt.CreateDataReader ();
2832 DataRowAction[] dra = new DataRowAction[] {
2833 DataRowAction.Nothing,// REAL action
2834 DataRowAction.Nothing,// dummy
2835 DataRowAction.Nothing,// dummy
2836 DataRowAction.Nothing,// dummy
2837 DataRowAction.Nothing};// dummy
2838 rowActionInit (dra);
2839 dtLoad.Load (dtr, LoadOption.Upsert);
2841 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Current], "RowData0-C");
2842 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Original], "RowData0-O");
2843 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[0].RowState, "RowState0");
2847 public void LoadDataRow_LoadOptions ()
2849 // LoadDataRow is covered in detail (without LoadOptions) in DataTableTest2
2850 // LoadOption tests are covered in detail in DataTable.Load().
2851 // Therefore only minimal tests of LoadDataRow with LoadOptions are covered here.
2854 dt = CreateDataTableExample ();
2855 dt.PrimaryKey = new DataColumn[] { dt.Columns[0] }; //add ParentId as Primary Key
2856 dt.Columns["String1"].DefaultValue = "Default";
2858 dr = dt.Select ("ParentId=1")[0];
2860 //Update existing row with LoadOptions = OverwriteChanges
2861 dt.BeginLoadData ();
2862 dt.LoadDataRow (new object[] { 1, null, "Changed" },
2863 LoadOption.OverwriteChanges);
2866 // LoadDataRow(update1) - check column String2
2867 Assert.AreEqual ("Changed", dr["String2", DataRowVersion.Current], "DT72-C");
2868 Assert.AreEqual ("Changed", dr["String2", DataRowVersion.Original], "DT72-O");
2870 // LoadDataRow(update1) - check row state
2871 Assert.AreEqual (DataRowState.Unchanged, dr.RowState, "DT73-LO");
2873 //Add New row with LoadOptions = Upsert
2874 dt.BeginLoadData ();
2875 dt.LoadDataRow (new object[] { 99, null, "Changed" },
2879 // LoadDataRow(insert1) - check column String2
2880 dr = dt.Select ("ParentId=99")[0];
2881 Assert.AreEqual ("Changed", dr["String2", DataRowVersion.Current], "DT75-C");
2883 // LoadDataRow(insert1) - check row state
2884 Assert.AreEqual (DataRowState.Added, dr.RowState, "DT76-LO");
2887 public static DataTable CreateDataTableExample ()
2889 DataTable dtParent = new DataTable ("Parent");
2891 dtParent.Columns.Add ("ParentId", typeof (int));
2892 dtParent.Columns.Add ("String1", typeof (string));
2893 dtParent.Columns.Add ("String2", typeof (string));
2895 dtParent.Columns.Add ("ParentDateTime", typeof (DateTime));
2896 dtParent.Columns.Add ("ParentDouble", typeof (double));
2897 dtParent.Columns.Add ("ParentBool", typeof (bool));
2899 dtParent.Rows.Add (new object[] { 1, "1-String1", "1-String2", new DateTime (2005, 1, 1, 0, 0, 0, 0), 1.534, true });
2900 dtParent.Rows.Add (new object[] { 2, "2-String1", "2-String2", new DateTime (2004, 1, 1, 0, 0, 0, 1), -1.534, true });
2901 dtParent.Rows.Add (new object[] { 3, "3-String1", "3-String2", new DateTime (2003, 1, 1, 0, 0, 1, 0), double.MinValue * 10000, false });
2902 dtParent.Rows.Add (new object[] { 4, "4-String1", "4-String2", new DateTime (2002, 1, 1, 0, 1, 0, 0), double.MaxValue / 10000, true });
2903 dtParent.Rows.Add (new object[] { 5, "5-String1", "5-String2", new DateTime (2001, 1, 1, 1, 0, 0, 0), 0.755, true });
2904 dtParent.Rows.Add (new object[] { 6, "6-String1", "6-String2", new DateTime (2000, 1, 1, 0, 0, 0, 0), 0.001, false });
2905 dtParent.AcceptChanges ();
2909 #endregion // DataTable.Load Tests
2911 #region Read/Write XML Tests
2915 [Category ("NotWorking")]
2917 public void ReadXmlSchema ()
2919 DataTable Table = new DataTable ();
2920 Table.ReadXmlSchema ("Test/System.Data/own_schema1.xsd");
2922 Assert.AreEqual ("test_table", Table.TableName, "test#02");
2923 Assert.AreEqual ("", Table.Namespace, "test#03");
2924 Assert.AreEqual (2, Table.Columns.Count, "test#04");
2925 Assert.AreEqual (0, Table.Rows.Count, "test#05");
2926 Assert.IsFalse (Table.CaseSensitive, "test#06");
2927 Assert.AreEqual (1, Table.Constraints.Count, "test#07");
2928 Assert.AreEqual ("", Table.Prefix, "test#08");
2930 Constraint cons = Table.Constraints[0];
2931 Assert.AreEqual ("Constraint1", cons.ConstraintName.ToString (), "test#09");
2932 Assert.AreEqual ("Constraint1", cons.ToString (), "test#10");
2934 DataColumn column = Table.Columns[0];
2935 Assert.IsTrue (column.AllowDBNull, "test#11");
2936 Assert.IsFalse (column.AutoIncrement, "test#12");
2937 Assert.AreEqual (0L, column.AutoIncrementSeed, "test#13");
2938 Assert.AreEqual (1L, column.AutoIncrementStep, "test#14");
2939 Assert.AreEqual ("test", column.Caption, "test#15");
2940 Assert.AreEqual ("Element", column.ColumnMapping.ToString (), "test#16");
2941 Assert.AreEqual ("first", column.ColumnName, "test#17");
2942 Assert.AreEqual (typeof (string), column.DataType, "test#18");
2943 Assert.AreEqual ("test_default_value", column.DefaultValue.ToString (), "test#19");
2944 Assert.IsFalse (column.DesignMode, "test#20");
2945 Assert.AreEqual ("", column.Expression, "test#21");
2946 Assert.AreEqual (100, column.MaxLength, "test#22");
2947 Assert.AreEqual ("", column.Namespace, "test#23");
2948 Assert.AreEqual (0, column.Ordinal, "test#24");
2949 Assert.AreEqual ("", column.Prefix, "test#25");
2950 Assert.IsFalse (column.ReadOnly, "test#26");
2951 Assert.IsTrue (column.Unique, "test#27");
2953 DataColumn column2 = Table.Columns[1];
2954 Assert.IsTrue (column2.AllowDBNull, "test#28");
2955 Assert.IsFalse (column2.AutoIncrement, "test#29");
2956 Assert.AreEqual (0L, column2.AutoIncrementSeed, "test#30");
2957 Assert.AreEqual (1L, column2.AutoIncrementStep, "test#31");
2958 Assert.AreEqual ("second", column2.Caption, "test#32");
2959 Assert.AreEqual ("Element", column2.ColumnMapping.ToString (), "test#33");
2960 Assert.AreEqual ("second", column2.ColumnName, "test#34");
2961 Assert.AreEqual (typeof (SqlGuid), column2.DataType, "test#35");
2962 Assert.AreEqual (SqlGuid.Null, column2.DefaultValue, "test#36");
2963 Assert.AreEqual (typeof (SqlGuid), column2.DefaultValue.GetType (), "test#36-2");
2964 Assert.IsFalse (column2.DesignMode, "test#37");
2965 Assert.AreEqual ("", column2.Expression, "test#38");
2966 Assert.AreEqual (-1, column2.MaxLength, "test#39");
2967 Assert.AreEqual ("", column2.Namespace, "test#40");
2968 Assert.AreEqual (1, column2.Ordinal, "test#41");
2969 Assert.AreEqual ("", column2.Prefix, "test#42");
2970 Assert.IsFalse (column2.ReadOnly, "test#43");
2971 Assert.IsFalse (column2.Unique, "test#44");
2973 DataTable Table2 = new DataTable ();
2974 Table2.ReadXmlSchema ("Test/System.Data/own_schema2.xsd");
2976 Assert.AreEqual ("second_test_table", Table2.TableName, "test#45");
2977 Assert.AreEqual ("", Table2.Namespace, "test#46");
2978 Assert.AreEqual (1, Table2.Columns.Count, "test#47");
2979 Assert.AreEqual (0, Table2.Rows.Count, "test#48");
2980 Assert.IsFalse (Table2.CaseSensitive, "test#49");
2981 Assert.AreEqual (1, Table2.Constraints.Count, "test#50");
2982 Assert.AreEqual ("", Table2.Prefix, "test#51");
2984 DataColumn column3 = Table2.Columns[0];
2985 Assert.IsTrue (column3.AllowDBNull, "test#52");
2986 Assert.IsFalse (column3.AutoIncrement, "test#53");
2987 Assert.AreEqual (0L, column3.AutoIncrementSeed, "test#54");
2988 Assert.AreEqual (1L, column3.AutoIncrementStep, "test#55");
2989 Assert.AreEqual ("second_first", column3.Caption, "test#56");
2990 Assert.AreEqual ("Element", column3.ColumnMapping.ToString (), "test#57");
2991 Assert.AreEqual ("second_first", column3.ColumnName, "test#58");
2992 Assert.AreEqual (typeof (string), column3.DataType, "test#59");
2993 Assert.AreEqual ("default_value", column3.DefaultValue.ToString (), "test#60");
2994 Assert.IsFalse (column3.DesignMode, "test#61");
2995 Assert.AreEqual ("", column3.Expression, "test#62");
2996 Assert.AreEqual (100, column3.MaxLength, "test#63");
2997 Assert.AreEqual ("", column3.Namespace, "test#64");
2998 Assert.AreEqual (0, column3.Ordinal, "test#65");
2999 Assert.AreEqual ("", column3.Prefix, "test#66");
3000 Assert.IsFalse (column3.ReadOnly, "test#67");
3001 Assert.IsTrue (column3.Unique, "test#68");
3005 public void ReadXmlSchema_2 ()
3007 DataTable dt = new DataTable ();
3008 string xmlData = string.Empty;
3009 xmlData += "<?xml version=\"1.0\"?>";
3010 xmlData += "<xs:schema id=\"SiteConfiguration\" targetNamespace=\"http://tempuri.org/PortalCfg.xsd\" xmlns:mstns=\"http://tempuri.org/PortalCfg.xsd\" xmlns=\"http://tempuri.org/PortalCfg.xsd\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" attributeFormDefault=\"qualified\" elementFormDefault=\"qualified\">";
3011 xmlData += "<xs:element name=\"SiteConfiguration\" msdata:IsDataSet=\"true\" msdata:EnforceConstraints=\"False\">";
3012 xmlData += "<xs:complexType>";
3013 xmlData += "<xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">";
3014 xmlData += "<xs:element name=\"Tab\">";
3015 xmlData += "<xs:complexType>";
3016 xmlData += "<xs:sequence>";
3017 xmlData += "<xs:element name=\"Module\" minOccurs=\"0\" maxOccurs=\"unbounded\">";
3018 xmlData += "<xs:complexType>";
3019 xmlData += "<xs:attribute name=\"ModuleId\" form=\"unqualified\" type=\"xs:int\" />";
3020 xmlData += "</xs:complexType>";
3021 xmlData += "</xs:element>";
3022 xmlData += "</xs:sequence>";
3023 xmlData += "<xs:attribute name=\"TabId\" form=\"unqualified\" type=\"xs:int\" />";
3024 xmlData += "</xs:complexType>";
3025 xmlData += "</xs:element>";
3026 xmlData += "</xs:choice>";
3027 xmlData += "</xs:complexType>";
3028 xmlData += "<xs:key name=\"TabKey\" msdata:PrimaryKey=\"true\">";
3029 xmlData += "<xs:selector xpath=\".//mstns:Tab\" />";
3030 xmlData += "<xs:field xpath=\"@TabId\" />";
3031 xmlData += "</xs:key>";
3032 xmlData += "<xs:key name=\"ModuleKey\" msdata:PrimaryKey=\"true\">";
3033 xmlData += "<xs:selector xpath=\".//mstns:Module\" />";
3034 xmlData += "<xs:field xpath=\"@ModuleID\" />";
3035 xmlData += "</xs:key>";
3036 xmlData += "</xs:element>";
3037 xmlData += "</xs:schema>";
3038 dt.ReadXmlSchema (new StringReader (xmlData));
3042 public void ReadXmlSchema_ByStream ()
3044 DataSet ds1 = new DataSet ();
3045 ds1.Tables.Add (DataProvider.CreateParentDataTable ());
3046 ds1.Tables.Add (DataProvider.CreateChildDataTable ());
3048 MemoryStream ms1 = new MemoryStream ();
3049 MemoryStream ms2 = new MemoryStream ();
3050 //write xml schema only
3051 //ds1.WriteXmlSchema (ms);
3052 ds1.Tables[0].WriteXmlSchema (ms1);
3053 ds1.Tables[1].WriteXmlSchema (ms2);
3055 MemoryStream ms11 = new MemoryStream (ms1.GetBuffer ());
3056 MemoryStream ms22 = new MemoryStream (ms2.GetBuffer ());
3058 //DataSet ds2 = new DataSet ();
3059 DataTable dt1 = new DataTable ();
3060 DataTable dt2 = new DataTable ();
3062 //ds2.ReadXmlSchema (ms1);
3063 dt1.ReadXmlSchema (ms11);
3064 dt2.ReadXmlSchema (ms22);
3067 // ReadXmlSchema - Tables count
3068 //Assert.AreEqual (ds2.Tables.Count, ds1.Tables.Count, "DS269");
3070 // ReadXmlSchema - Tables 0 Col count
3071 Assert.AreEqual (ds1.Tables[0].Columns.Count, dt1.Columns.Count, "DS270");
3073 // ReadXmlSchema - Tables 1 Col count
3074 Assert.AreEqual (ds1.Tables[1].Columns.Count, dt2.Columns.Count, "DS271");
3076 //check some colummns types
3077 // ReadXmlSchema - Tables 0 Col type
3078 Assert.AreEqual (ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType (), "DS272");
3080 // ReadXmlSchema - Tables 1 Col type
3081 Assert.AreEqual (ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType (), "DS273");
3083 //check that no data exists
3084 // ReadXmlSchema - Table 1 row count
3085 Assert.AreEqual (0, dt1.Rows.Count, "DS274");
3087 // ReadXmlSchema - Table 2 row count
3088 Assert.AreEqual (0, dt2.Rows.Count, "DS275");
3092 public void ReadWriteXmlSchema_ByFileName ()
3094 string sTempFileName1 = "tmpDataSet_ReadWriteXml_43899-1.xml";
3095 string sTempFileName2 = "tmpDataSet_ReadWriteXml_43899-2.xml";
3097 DataSet ds1 = new DataSet ();
3098 ds1.Tables.Add (DataProvider.CreateParentDataTable ());
3099 ds1.Tables.Add (DataProvider.CreateChildDataTable ());
3101 ds1.Tables[0].WriteXmlSchema (sTempFileName1);
3102 ds1.Tables[1].WriteXmlSchema (sTempFileName2);
3104 DataTable dt1 = new DataTable ();
3105 DataTable dt2 = new DataTable ();
3107 dt1.ReadXmlSchema (sTempFileName1);
3108 dt2.ReadXmlSchema (sTempFileName2);
3110 Assert.AreEqual (ds1.Tables[0].Columns.Count, dt1.Columns.Count, "DS277");
3111 Assert.AreEqual (ds1.Tables[1].Columns.Count, dt2.Columns.Count, "DS278");
3112 Assert.AreEqual (ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType (), "DS279");
3113 Assert.AreEqual (ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType (), "DS280");
3114 Assert.AreEqual (0, dt1.Rows.Count, "DS281");
3115 Assert.AreEqual (0, dt2.Rows.Count, "DS282");
3117 File.Delete (sTempFileName1);
3118 File.Delete (sTempFileName2);
3122 public void ReadXmlSchema_ByTextReader ()
3124 DataSet ds1 = new DataSet ();
3125 ds1.Tables.Add (DataProvider.CreateParentDataTable ());
3126 ds1.Tables.Add (DataProvider.CreateChildDataTable ());
3128 StringWriter sw1 = new StringWriter ();
3129 StringWriter sw2 = new StringWriter ();
3130 //write xml file, schema only
3131 //ds1.WriteXmlSchema (sw);
3132 ds1.Tables[0].WriteXmlSchema (sw1);
3133 ds1.Tables[1].WriteXmlSchema (sw2);
3135 StringReader sr1 = new StringReader (sw1.GetStringBuilder ().ToString ());
3136 StringReader sr2 = new StringReader (sw2.GetStringBuilder ().ToString ());
3137 //copy both data and schema
3138 //DataSet ds2 = new DataSet ();
3139 DataTable dt1 = new DataTable ();
3140 DataTable dt2 = new DataTable ();
3142 //ds2.ReadXmlSchema (sr);
3143 dt1.ReadXmlSchema (sr1);
3144 dt2.ReadXmlSchema (sr2);
3147 // ReadXmlSchema - Tables count
3148 //Assert.AreEqual (ds2.Tables.Count, ds1.Tables.Count, "DS283");
3150 // ReadXmlSchema - Tables 0 Col count
3151 Assert.AreEqual (ds1.Tables[0].Columns.Count, dt1.Columns.Count, "DS284");
3153 // ReadXmlSchema - Tables 1 Col count
3154 Assert.AreEqual (ds1.Tables[1].Columns.Count, dt2.Columns.Count, "DS285");
3156 //check some colummns types
3157 // ReadXmlSchema - Tables 0 Col type
3158 Assert.AreEqual (ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType (), "DS286");
3160 // ReadXmlSchema - Tables 1 Col type
3161 Assert.AreEqual (ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType (), "DS287");
3163 //check that no data exists
3164 // ReadXmlSchema - Table 1 row count
3165 Assert.AreEqual (0, dt1.Rows.Count, "DS288");
3167 // ReadXmlSchema - Table 2 row count
3168 Assert.AreEqual (0, dt2.Rows.Count, "DS289");
3172 public void ReadXmlSchema_ByXmlReader ()
3174 DataSet ds1 = new DataSet ();
3175 ds1.Tables.Add (DataProvider.CreateParentDataTable ());
3176 ds1.Tables.Add (DataProvider.CreateChildDataTable ());
3178 StringWriter sw1 = new StringWriter ();
3179 XmlTextWriter xmlTW1 = new XmlTextWriter (sw1);
3180 StringWriter sw2 = new StringWriter ();
3181 XmlTextWriter xmlTW2 = new XmlTextWriter (sw2);
3183 //write xml file, schema only
3184 ds1.Tables[0].WriteXmlSchema (xmlTW1);
3186 ds1.Tables[1].WriteXmlSchema (xmlTW2);
3189 StringReader sr1 = new StringReader (sw1.ToString ());
3190 XmlTextReader xmlTR1 = new XmlTextReader (sr1);
3191 StringReader sr2 = new StringReader (sw2.ToString ());
3192 XmlTextReader xmlTR2 = new XmlTextReader (sr2);
3194 //copy both data and schema
3195 //DataSet ds2 = new DataSet ();
3196 DataTable dt1 = new DataTable ();
3197 DataTable dt2 = new DataTable ();
3199 //ds2.ReadXmlSchema (xmlTR);
3200 dt1.ReadXmlSchema (xmlTR1);
3201 dt2.ReadXmlSchema (xmlTR2);
3204 // ReadXmlSchema - Tables count
3205 //Assert.AreEqual (ds2.Tables.Count, ds1.Tables.Count, "DS290");
3207 // ReadXmlSchema - Tables 0 Col count
3208 Assert.AreEqual (ds1.Tables[0].Columns.Count, dt1.Columns.Count, "DS291");
3210 // ReadXmlSchema - Tables 1 Col count
3211 Assert.AreEqual (ds1.Tables[1].Columns.Count, dt2.Columns.Count, "DS292");
3213 //check some colummns types
3214 // ReadXmlSchema - Tables 0 Col type
3215 Assert.AreEqual (ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType (), "DS293");
3217 // ReadXmlSchema - Tables 1 Col type
3218 Assert.AreEqual (ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType (), "DS294");
3220 //check that no data exists
3221 // ReadXmlSchema - Table 1 row count
3222 Assert.AreEqual (0, dt1.Rows.Count, "DS295");
3224 // ReadXmlSchema - Table 2 row count
3225 Assert.AreEqual (0, dt2.Rows.Count, "DS296");
3229 public void WriteXmlSchema ()
3231 DataSet ds = new DataSet ();
3232 ds.ReadXml ("Test/System.Data/region.xml");
3233 TextWriter writer = new StringWriter ();
3234 ds.Tables[0].WriteXmlSchema (writer);
3236 string TextString = GetNormalizedSchema (writer.ToString ());
3237 //string TextString = writer.ToString ();
3240 string substring = TextString.Substring (0, TextString.IndexOf (EOL));
3241 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3242 Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
3244 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3245 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3246 Assert.AreEqual ("<xs:schema id=\"Root\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring, "test#02");
3248 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3249 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3250 Assert.AreEqual (" <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"en-US\" msdata:MainDataTable=\"Region\" name=\"Root\">", substring, "test#03");
3252 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3253 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3254 Assert.AreEqual (" <xs:complexType>", substring, "test#04");
3256 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3257 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3258 Assert.AreEqual (" <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring, "test#05");
3260 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3261 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3262 Assert.AreEqual (" <xs:element name=\"Region\">", substring, "test#06");
3264 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3265 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3266 Assert.AreEqual (" <xs:complexType>", substring, "test#07");
3268 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3269 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3270 Assert.AreEqual (" <xs:sequence>", substring, "test#08");
3272 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3273 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3274 Assert.AreEqual (" <xs:element minOccurs=\"0\" name=\"RegionID\" type=\"xs:string\" />", substring, "test#09");
3276 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3277 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3278 Assert.AreEqual (" <xs:element minOccurs=\"0\" name=\"RegionDescription\" type=\"xs:string\" />", substring, "test#10");
3280 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3281 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3282 Assert.AreEqual (" </xs:sequence>", substring, "test#11");
3284 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3285 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3286 Assert.AreEqual (" </xs:complexType>", substring, "test#12");
3288 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3289 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3290 Assert.AreEqual (" </xs:element>", substring, "test#13");
3292 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3293 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3294 Assert.AreEqual (" </xs:choice>", substring, "test#14");
3296 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3297 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3298 Assert.AreEqual (" </xs:complexType>", substring, "test#15");
3300 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3301 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3302 Assert.AreEqual (" </xs:element>", substring, "test#16");
3304 Assert.AreEqual ("</xs:schema>", TextString, "test#17");
3308 public void WriteXmlSchema2 ()
3310 string xml = @"<myDataSet xmlns='NetFrameWork'><myTable><id>0</id><item>item 0</item></myTable><myTable><id>1</id><item>item 1</item></myTable><myTable><id>2</id><item>item 2</item></myTable><myTable><id>3</id><item>item 3</item></myTable><myTable><id>4</id><item>item 4</item></myTable><myTable><id>5</id><item>item 5</item></myTable><myTable><id>6</id><item>item 6</item></myTable><myTable><id>7</id><item>item 7</item></myTable><myTable><id>8</id><item>item 8</item></myTable><myTable><id>9</id><item>item 9</item></myTable></myDataSet>";
3311 string schema = @"<?xml version='1.0' encoding='utf-16'?>
3312 <xs:schema id='myDataSet' targetNamespace='NetFrameWork' xmlns:mstns='NetFrameWork' xmlns='NetFrameWork' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' attributeFormDefault='qualified' elementFormDefault='qualified'>
3313 <xs:element name='myDataSet' msdata:IsDataSet='true' msdata:MainDataTable='NetFrameWork_x003A_myTable' msdata:UseCurrentLocale='true'>
3315 <xs:choice minOccurs='0' maxOccurs='unbounded'>
3316 <xs:element name='myTable'>
3319 <xs:element name='id' msdata:AutoIncrement='true' type='xs:int' minOccurs='0' />
3320 <xs:element name='item' type='xs:string' minOccurs='0' />
3328 DataSet OriginalDataSet = new DataSet ("myDataSet");
3329 OriginalDataSet.Namespace = "NetFrameWork";
3330 DataTable myTable = new DataTable ("myTable");
3331 DataColumn c1 = new DataColumn ("id", typeof (int));
3332 c1.AutoIncrement = true;
3333 DataColumn c2 = new DataColumn ("item");
3334 myTable.Columns.Add (c1);
3335 myTable.Columns.Add (c2);
3336 OriginalDataSet.Tables.Add (myTable);
3339 for (int i = 0; i < 10; i++) {
3340 newRow = myTable.NewRow ();
3341 newRow["item"] = "item " + i;
3342 myTable.Rows.Add (newRow);
3344 OriginalDataSet.AcceptChanges ();
3346 StringWriter sw = new StringWriter ();
3347 XmlTextWriter xtw = new XmlTextWriter (sw);
3348 xtw.QuoteChar = '\'';
3349 OriginalDataSet.WriteXml (xtw);
3350 string result = sw.ToString ();
3352 Assert.AreEqual (xml, result);
3354 sw = new StringWriter ();
3355 xtw = new XmlTextWriter (sw);
3356 xtw.Formatting = Formatting.Indented;
3357 OriginalDataSet.Tables[0].WriteXmlSchema (xtw);
3358 result = sw.ToString ();
3360 result = result.Replace ("\r\n", "\n").Replace ('"', '\'');
3361 Assert.AreEqual (schema.Replace ("\r\n", "\n"), result);
3365 public void WriteXmlSchema3 ()
3367 string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
3368 <xs:schema id=""ExampleDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3369 <xs:element name=""ExampleDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""ExampleDataTable"" msdata:UseCurrentLocale=""true"">
3371 <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3372 <xs:element name=""ExampleDataTable"">
3374 <xs:attribute name=""PrimaryKeyColumn"" type=""xs:int"" use=""required"" />
3379 <xs:unique name=""PK_ExampleDataTable"" msdata:PrimaryKey=""true"">
3380 <xs:selector xpath="".//ExampleDataTable"" />
3381 <xs:field xpath=""@PrimaryKeyColumn"" />
3385 DataSet ds = new DataSet ("ExampleDataSet");
3387 ds.Tables.Add (new DataTable ("ExampleDataTable"));
3388 ds.Tables["ExampleDataTable"].Columns.Add (
3389 new DataColumn ("PrimaryKeyColumn", typeof (int), "", MappingType.Attribute));
3390 ds.Tables["ExampleDataTable"].Columns["PrimaryKeyColumn"].AllowDBNull = false;
3392 ds.Tables["ExampleDataTable"].Constraints.Add (
3393 "PK_ExampleDataTable",
3394 ds.Tables["ExampleDataTable"].Columns["PrimaryKeyColumn"],
3397 ds.AcceptChanges ();
3398 StringWriter sw = new StringWriter ();
3399 ds.Tables[0].WriteXmlSchema (sw);
3401 string result = sw.ToString ();
3403 Assert.AreEqual (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
3404 //Assert.AreEqual (xmlschema, result.Replace ("\r\n", "\n"));
3408 public void WriteXmlSchema4 ()
3410 string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
3411 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3412 <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""MyType"" msdata:UseCurrentLocale=""true"">
3414 <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3415 <xs:element name=""MyType"">
3417 <xs:attribute name=""ID"" type=""xs:int"" use=""required"" />
3418 <xs:attribute name=""Desc"" type=""xs:string"" />
3425 DataSet ds = new DataSet ("Example");
3427 // Add MyType DataTable
3428 DataTable dt = new DataTable ("MyType");
3431 dt.Columns.Add (new DataColumn ("ID", typeof (int), "",
3432 MappingType.Attribute));
3433 dt.Columns["ID"].AllowDBNull = false;
3435 dt.Columns.Add (new DataColumn ("Desc", typeof
3436 (string), "", MappingType.Attribute));
3438 ds.AcceptChanges ();
3440 StringWriter sw = new StringWriter ();
3441 ds.Tables[0].WriteXmlSchema (sw);
3443 string result = sw.ToString ();
3445 Assert.AreEqual (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
3449 public void WriteXmlSchema5 ()
3451 string xmlschema1 = @"<?xml version=""1.0"" encoding=""utf-16""?>
3452 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3453 <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""StandAlone"" msdata:UseCurrentLocale=""true"">
3455 <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3456 <xs:element name=""StandAlone"">
3458 <xs:attribute name=""ID"" type=""xs:int"" use=""required"" />
3459 <xs:attribute name=""Desc"" type=""xs:string"" use=""required"" />
3466 string xmlschema2 = @"<?xml version=""1.0"" encoding=""utf-16""?>
3467 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3468 <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""Dimension"" msdata:UseCurrentLocale=""true"">
3470 <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3471 <xs:element name=""Dimension"">
3473 <xs:attribute name=""Number"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
3474 <xs:attribute name=""Title"" type=""xs:string"" use=""required"" />
3479 <xs:unique name=""PK_Dimension"" msdata:PrimaryKey=""true"">
3480 <xs:selector xpath="".//Dimension"" />
3481 <xs:field xpath=""@Number"" />
3485 string xmlschema3 = @"<?xml version=""1.0"" encoding=""utf-16""?>
3486 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3487 <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""Element"" msdata:UseCurrentLocale=""true"">
3489 <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3490 <xs:element name=""Element"">
3492 <xs:attribute name=""Dimension"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
3493 <xs:attribute name=""Number"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
3494 <xs:attribute name=""Title"" type=""xs:string"" use=""required"" />
3499 <xs:unique name=""PK_Element"" msdata:PrimaryKey=""true"">
3500 <xs:selector xpath="".//Element"" />
3501 <xs:field xpath=""@Dimension"" />
3502 <xs:field xpath=""@Number"" />
3506 DataSet ds = new DataSet ("Example");
3508 // Add a DataTable with no ReadOnly columns
3509 DataTable dt1 = new DataTable ("StandAlone");
3510 ds.Tables.Add (dt1);
3512 // Add a ReadOnly column
3513 dt1.Columns.Add (new DataColumn ("ID", typeof (int), "",
3514 MappingType.Attribute));
3515 dt1.Columns["ID"].AllowDBNull = false;
3517 dt1.Columns.Add (new DataColumn ("Desc", typeof
3518 (string), "", MappingType.Attribute));
3519 dt1.Columns["Desc"].AllowDBNull = false;
3521 // Add related DataTables with ReadOnly columns
3522 DataTable dt2 = new DataTable ("Dimension");
3523 ds.Tables.Add (dt2);
3524 dt2.Columns.Add (new DataColumn ("Number", typeof
3525 (int), "", MappingType.Attribute));
3526 dt2.Columns["Number"].AllowDBNull = false;
3527 dt2.Columns["Number"].ReadOnly = true;
3529 dt2.Columns.Add (new DataColumn ("Title", typeof
3530 (string), "", MappingType.Attribute));
3531 dt2.Columns["Title"].AllowDBNull = false;
3533 dt2.Constraints.Add ("PK_Dimension", dt2.Columns["Number"], true);
3535 DataTable dt3 = new DataTable ("Element");
3536 ds.Tables.Add (dt3);
3538 dt3.Columns.Add (new DataColumn ("Dimension", typeof
3539 (int), "", MappingType.Attribute));
3540 dt3.Columns["Dimension"].AllowDBNull = false;
3541 dt3.Columns["Dimension"].ReadOnly = true;
3543 dt3.Columns.Add (new DataColumn ("Number", typeof
3544 (int), "", MappingType.Attribute));
3545 dt3.Columns["Number"].AllowDBNull = false;
3546 dt3.Columns["Number"].ReadOnly = true;
3548 dt3.Columns.Add (new DataColumn ("Title", typeof
3549 (string), "", MappingType.Attribute));
3550 dt3.Columns["Title"].AllowDBNull = false;
3552 dt3.Constraints.Add ("PK_Element", new DataColumn[] {
3553 dt3.Columns ["Dimension"],
3554 dt3.Columns ["Number"] }, true);
3556 ds.AcceptChanges ();
3558 StringWriter sw1 = new StringWriter ();
3559 ds.Tables[0].WriteXmlSchema (sw1);
3560 string result1 = sw1.ToString ();
3561 Assert.AreEqual (xmlschema1.Replace ("\r\n", "\n"), result1.Replace ("\r\n", "\n"));
3563 StringWriter sw2 = new StringWriter ();
3564 ds.Tables[1].WriteXmlSchema (sw2);
3565 string result2 = sw2.ToString ();
3566 Assert.AreEqual (xmlschema2.Replace ("\r\n", "\n"), result2.Replace ("\r\n", "\n"));
3568 StringWriter sw3 = new StringWriter ();
3569 ds.Tables[2].WriteXmlSchema (sw3);
3570 string result3 = sw3.ToString ();
3571 Assert.AreEqual (xmlschema3.Replace ("\r\n", "\n"), result3.Replace ("\r\n", "\n"));
3575 public void WriteXmlSchema6 ()
3577 string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
3578 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3579 <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""MyType"" msdata:UseCurrentLocale=""true"">
3581 <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3582 <xs:element name=""MyType"">
3584 <xs:attribute name=""Desc"">
3586 <xs:restriction base=""xs:string"">
3587 <xs:maxLength value=""32"" />
3597 DataSet ds = new DataSet ("Example");
3599 // Add MyType DataTable
3600 ds.Tables.Add ("MyType");
3602 ds.Tables["MyType"].Columns.Add (new DataColumn (
3603 "Desc", typeof (string), "", MappingType.Attribute));
3604 ds.Tables["MyType"].Columns["Desc"].MaxLength = 32;
3606 ds.AcceptChanges ();
3608 StringWriter sw = new StringWriter ();
3609 ds.Tables[0].WriteXmlSchema (sw);
3611 string result = sw.ToString ();
3613 Assert.AreEqual (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
3617 public void WriteXmlSchema7 ()
3619 DataSet ds = new DataSet ();
3620 DataTable dt = new DataTable ("table");
3621 dt.Columns.Add ("col1");
3622 dt.Columns.Add ("col2");
3624 dt.Rows.Add (new object[] { "foo", "bar" });
3625 StringWriter sw = new StringWriter ();
3626 ds.Tables[0].WriteXmlSchema (sw);
3627 Assert.IsTrue (sw.ToString ().IndexOf ("xmlns=\"\"") > 0);
3631 public void WriteXmlSchema_ConstraintNameWithSpaces ()
3633 DataSet ds = new DataSet ();
3634 DataTable table1 = ds.Tables.Add ("table1");
3635 DataTable table2 = ds.Tables.Add ("table2");
3637 table1.Columns.Add ("col1", typeof (int));
3638 table2.Columns.Add ("col1", typeof (int));
3640 table1.Constraints.Add ("uc 1", table1.Columns[0], false);
3641 table2.Constraints.Add ("fc 1", table1.Columns[0], table2.Columns[0]);
3643 StringWriter sw1 = new StringWriter ();
3644 StringWriter sw2 = new StringWriter ();
3646 //should not throw an exception
3647 ds.Tables[0].WriteXmlSchema (sw1);
3648 ds.Tables[1].WriteXmlSchema (sw2);
3652 public void WriteXmlSchema_ForignKeyConstraint ()
3654 DataSet ds1 = new DataSet ();
3656 DataTable table1 = ds1.Tables.Add ();
3657 DataTable table2 = ds1.Tables.Add ();
3659 DataColumn col1_1 = table1.Columns.Add ("col1", typeof (int));
3660 DataColumn col2_1 = table2.Columns.Add ("col1", typeof (int));
3662 table2.Constraints.Add ("fk", col1_1, col2_1);
3664 StringWriter sw1 = new StringWriter ();
3665 ds1.Tables[0].WriteXmlSchema (sw1);
3666 String xml1 = sw1.ToString ();
3667 Assert.IsTrue (xml1.IndexOf (@"<xs:unique name=""Constraint1"">") != -1, "#1");
3669 StringWriter sw2 = new StringWriter ();
3670 ds1.Tables[1].WriteXmlSchema (sw2);
3671 String xml2 = sw2.ToString ();
3672 Assert.IsTrue (xml2.IndexOf (@"<xs:unique name=""Constraint1"">") == -1, "#2");
3676 public void WriteXmlSchema_Relations_ForeignKeys ()
3678 MemoryStream ms1 = null;
3679 MemoryStream ms2 = null;
3680 MemoryStream msA = null;
3681 MemoryStream msB = null;
3683 DataSet ds1 = new DataSet ();
3685 DataTable table1 = ds1.Tables.Add ("Table 1");
3686 DataTable table2 = ds1.Tables.Add ("Table 2");
3688 DataColumn col1_1 = table1.Columns.Add ("col 1", typeof (int));
3689 DataColumn col1_2 = table1.Columns.Add ("col 2", typeof (int));
3690 DataColumn col1_3 = table1.Columns.Add ("col 3", typeof (int));
3691 DataColumn col1_4 = table1.Columns.Add ("col 4", typeof (int));
3692 DataColumn col1_5 = table1.Columns.Add ("col 5", typeof (int));
3693 DataColumn col1_6 = table1.Columns.Add ("col 6", typeof (int));
3694 DataColumn col1_7 = table1.Columns.Add ("col 7", typeof (int));
3696 DataColumn col2_1 = table2.Columns.Add ("col 1", typeof (int));
3697 DataColumn col2_2 = table2.Columns.Add ("col 2", typeof (int));
3698 DataColumn col2_3 = table2.Columns.Add ("col 3", typeof (int));
3699 DataColumn col2_4 = table2.Columns.Add ("col 4", typeof (int));
3700 DataColumn col2_5 = table2.Columns.Add ("col 5", typeof (int));
3701 DataColumn col2_6 = table2.Columns.Add ("col 6", typeof (int));
3702 DataColumn col2_7 = table2.Columns.Add ("col 7", typeof (int));
3704 ds1.Relations.Add ("rel 1",
3705 new DataColumn[] { col1_1, col1_2 },
3706 new DataColumn[] { col2_1, col2_2 },
3708 ds1.Relations.Add ("rel 2",
3709 new DataColumn[] { col1_3, col1_4 },
3710 new DataColumn[] { col2_3, col2_4 },
3712 table2.Constraints.Add ("fk 1",
3713 new DataColumn[] { col1_5, col1_6 },
3714 new DataColumn[] { col2_5, col2_6 });
3715 table1.Constraints.Add ("fk 2",
3716 new DataColumn[] { col2_5, col2_6 },
3717 new DataColumn[] { col1_5, col1_6 });
3719 table1.Constraints.Add ("pk 1", col1_7, true);
3720 table2.Constraints.Add ("pk 2", col2_7, true);
3722 ms1 = new MemoryStream ();
3723 ds1.Tables[0].WriteXmlSchema (ms1);
3724 ms2 = new MemoryStream ();
3725 ds1.Tables[1].WriteXmlSchema (ms2);
3727 msA = new MemoryStream (ms1.GetBuffer ());
3728 DataTable dtA = new DataTable ();
3729 dtA.ReadXmlSchema (msA);
3731 msB = new MemoryStream (ms2.GetBuffer ());
3732 DataTable dtB = new DataTable ();
3733 dtB.ReadXmlSchema (msB);
3735 Assert.AreEqual (3, dtA.Constraints.Count, "#2");
3736 Assert.AreEqual (2, dtB.Constraints.Count, "#3");
3738 Assert.IsTrue (dtA.Constraints.Contains ("pk 1"), "#5");
3739 Assert.IsTrue (dtA.Constraints.Contains ("Constraint1"), "#6");
3740 Assert.IsTrue (dtA.Constraints.Contains ("Constraint2"), "#7");
3741 Assert.IsTrue (dtB.Constraints.Contains ("pk 2"), "#9");
3742 Assert.IsTrue (dtB.Constraints.Contains ("Constraint1"), "#10");
3746 [Category ("NotWorking")]
3747 public void WriteXmlSchema_DifferentNamespace ()
3749 string schema = @"<xs:schema id='NewDataSet' targetNamespace='urn:bar' xmlns:mstns='urn:bar' xmlns='urn:bar' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' attributeFormDefault='qualified' elementFormDefault='qualified' xmlns:app1='urn:baz' xmlns:app2='urn:foo' msdata:schemafragmentcount='3'>
3750 <xs:import namespace='urn:foo' />
3751 <xs:import namespace='urn:baz' />
3752 <xs:element name='NewDataSet' msdata:IsDataSet='true' msdata:MainDataTable='urn_x003A_foo_x003A_NS1Table' msdata:UseCurrentLocale='true'>
3754 <xs:choice minOccurs='0' maxOccurs='unbounded'>
3755 <xs:element ref='app2:NS1Table' />
3760 <xs:schema targetNamespace='urn:baz' xmlns:mstns='urn:bar' xmlns='urn:baz' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' attributeFormDefault='qualified' elementFormDefault='qualified' xmlns:app1='urn:baz' xmlns:app2='urn:foo'>
3761 <xs:import namespace='urn:foo' />
3762 <xs:import namespace='urn:bar' />
3763 <xs:element name='column2' type='xs:string' />
3765 <xs:schema targetNamespace='urn:foo' xmlns:mstns='urn:bar' xmlns='urn:foo' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' attributeFormDefault='qualified' elementFormDefault='qualified' xmlns:app2='urn:foo' xmlns:app1='urn:baz'>
3766 <xs:import namespace='urn:bar' />
3767 <xs:import namespace='urn:baz' />
3768 <xs:element name='NS1Table'>
3771 <xs:element name='column1' type='xs:string' minOccurs='0' />
3772 <xs:element ref='app1:column2' minOccurs='0' />
3777 DataSet ds = new DataSet ();
3778 DataTable dt = new DataTable ();
3779 dt.TableName = "NS1Table";
3780 dt.Namespace = "urn:foo";
3781 dt.Columns.Add ("column1");
3782 dt.Columns.Add ("column2");
3783 dt.Columns[1].Namespace = "urn:baz";
3785 DataTable dt2 = new DataTable ();
3786 dt2.TableName = "NS2Table";
3787 dt2.Namespace = "urn:bar";
3788 ds.Tables.Add (dt2);
3789 ds.Namespace = "urn:bar";
3791 StringWriter sw1 = new StringWriter ();
3792 XmlTextWriter xw1 = new XmlTextWriter (sw1);
3793 xw1.Formatting = Formatting.Indented;
3794 xw1.QuoteChar = '\'';
3795 ds.Tables[0].WriteXmlSchema (xw1);
3796 string result1 = sw1.ToString ();
3797 Assert.AreEqual (schema, result1.Replace ("\r\n", "\n"), "#1");
3799 StringWriter sw2 = new StringWriter ();
3800 XmlTextWriter xw2 = new XmlTextWriter (sw2);
3801 xw2.Formatting = Formatting.Indented;
3802 xw2.QuoteChar = '\'';
3803 ds.Tables[0].WriteXmlSchema (xw2);
3804 string result2 = sw2.ToString ();
3805 Assert.AreEqual (schema, result2.Replace ("\r\n", "\n"), "#2");
3810 [Category ("NotWorking")]
3812 public void WriteXmlSchema_Hierarchy ()
3814 DataSet ds = new DataSet ();
3815 DataTable table1 = new DataTable ();
3816 DataColumn idColumn = table1.Columns.Add ("ID", typeof (Int32));
3817 table1.Columns.Add ("Name", typeof (String));
3818 table1.PrimaryKey = new DataColumn[] { idColumn };
3819 DataTable table2 = new DataTable ();
3820 table2.Columns.Add (new DataColumn ("OrderID", typeof (Int32)));
3821 table2.Columns.Add (new DataColumn ("CustomerID", typeof (Int32)));
3822 table2.Columns.Add (new DataColumn ("OrderDate", typeof (DateTime)));
3823 table2.PrimaryKey = new DataColumn[] { table2.Columns[0] };
3824 ds.Tables.Add (table1);
3825 ds.Tables.Add (table2);
3826 ds.Relations.Add ("CustomerOrder",
3827 new DataColumn[] { table1.Columns[0] },
3828 new DataColumn[] { table2.Columns[1] }, true);
3830 StringWriter writer1 = new StringWriter ();
3831 table1.WriteXmlSchema (writer1, false);
3832 string expected1 = "<?xml version=\"1.0\" encoding=\"utf-16\"?>\n<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">\n <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"Table1\" msdata:UseCurrentLocale=\"true\">\n <xs:complexType>\n <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">\n <xs:element name=\"Table1\">\n <xs:complexType>\n <xs:sequence>\n <xs:element name=\"ID\" type=\"xs:int\" />\n <xs:element name=\"Name\" type=\"xs:string\" minOccurs=\"0\" />\n </xs:sequence>\n </xs:complexType>\n </xs:element>\n </xs:choice>\n </xs:complexType>\n <xs:unique name=\"Constraint1\" msdata:PrimaryKey=\"true\">\n <xs:selector xpath=\".//Table1\" />\n <xs:field xpath=\"ID\" />\n </xs:unique>\n </xs:element>\n</xs:schema>";
3833 Assert.AreEqual (expected1, writer1.ToString().Replace("\r\n", "\n"), "#1");
3835 StringWriter writer2 = new StringWriter ();
3836 table1.WriteXmlSchema (writer2, true);
3837 string expected2 = "<?xml version=\"1.0\" encoding=\"utf-16\"?>\n<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">\n <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"Table1\" msdata:UseCurrentLocale=\"true\">\n <xs:complexType>\n <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">\n <xs:element name=\"Table1\">\n <xs:complexType>\n <xs:sequence>\n <xs:element name=\"ID\" type=\"xs:int\" />\n <xs:element name=\"Name\" type=\"xs:string\" minOccurs=\"0\" />\n </xs:sequence>\n </xs:complexType>\n </xs:element>\n <xs:element name=\"Table2\">\n <xs:complexType>\n <xs:sequence>\n <xs:element name=\"OrderID\" type=\"xs:int\" />\n <xs:element name=\"CustomerID\" type=\"xs:int\" minOccurs=\"0\" />\n <xs:element name=\"OrderDate\" type=\"xs:dateTime\" minOccurs=\"0\" />\n </xs:sequence>\n </xs:complexType>\n </xs:element>\n </xs:choice>\n </xs:complexType>\n <xs:unique name=\"Constraint1\" msdata:PrimaryKey=\"true\">\n <xs:selector xpath=\".//Table1\" />\n <xs:field xpath=\"ID\" />\n </xs:unique>\n <xs:unique name=\"Table2_Constraint1\" msdata:ConstraintName=\"Constraint1\" msdata:PrimaryKey=\"true\">\n <xs:selector xpath=\".//Table2\" />\n <xs:field xpath=\"OrderID\" />\n </xs:unique>\n <xs:keyref name=\"CustomerOrder\" refer=\"Constraint1\">\n <xs:selector xpath=\".//Table2\" />\n <xs:field xpath=\"CustomerID\" />\n </xs:keyref>\n </xs:element>\n</xs:schema>";
3838 Assert.AreEqual (expected2, writer2.ToString ().Replace("\r\n", "\n"), "#2");
3842 [Ignore ("MS behavior is far from consistent to be regarded as a reference implementation.")]
3843 // See the same-named tests in DataSetTest.cs
3845 [Category ("NotWorking")]
3847 // WriteXmlSchema doesn't have overload wityh 2 parameters in System.Data
3848 // and is commented-out TWICE below
3849 public void ReadWriteXmlSchema()
3851 DataSet ds = new DataSet();
3852 ds.ReadXmlSchema("Test/System.Data/store.xsd");
3853 // check dataset properties before testing write
3854 AssertDataSet("ds", ds, "NewDataSet", 3, 2);
3855 AssertDataTable("tab1", ds.Tables[0], "bookstore", 1, 0, 0, 1, 1, 1);
3856 AssertDataTable("tab2", ds.Tables[1], "book", 5, 0, 1, 1, 2, 1);
3857 AssertDataTable("tab3", ds.Tables[2], "author", 3, 0, 1, 0, 1, 0);
3858 // FIXME: currently order is not compatible. Use name as index
3859 AssertDataRelation("rel1", ds.Relations["book_author"], "book_author", true, new string[] { "book_Id" }, new string[] { "book_Id" }, true, true);
3860 AssertDataRelation("rel2", ds.Relations["bookstore_book"], "bookstore_book", true, new string[] { "bookstore_Id" }, new string[] { "bookstore_Id" }, true, true);
3862 ds.ReadXml("Test/System.Data/region.xml", XmlReadMode.InferSchema);
3863 ds.Relations.Clear(); // because can not call WriteXmlSchema with nested relations.
3865 TextWriter writer1 = new StringWriter();
3866 ds.Tables[0].WriteXmlSchema(writer1);
3867 //string TextString1 = GetNormalizedSchema(writer1.ToString());
3868 string TextString1 = writer1.ToString();
3869 string expected1 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3870 @"<xs:schema id=""Root"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3871 @"<xs:complexType name=""bookstoreType"">" +
3872 @"</xs:complexType>" +
3873 @"<xs:element name=""bookstore"" type=""bookstoreType"" />" +
3874 @"<xs:element name=""Root"" msdata:IsDataSet=""true"" msdata:MainDataTable=""bookstore"" msdata:Locale=""en-US"">" +
3875 @"<xs:complexType>" +
3876 @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3877 @"<xs:element ref=""bookstore"" />" +
3879 @"</xs:complexType>" +
3882 Assert.AreEqual(expected1.Replace("\n", ""), TextString1.Replace("\r\n", "").Replace(" ", "").Replace("\n", ""), "#1");
3884 TextWriter writer2 = new StringWriter();
3885 ds.Tables[1].WriteXmlSchema(writer2, false);
3886 //string TextString2 = GetNormalizedSchema(writer2.ToString());
3887 string TextString2 = writer2.ToString();
3888 string expected2 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3889 @"<xs:schema id=""Root"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3890 @"<xs:complexType name=""bookType"">" +
3892 @"<xs:element name=""title"" type=""xs:string"" msdata:Ordinal=""1"" />" +
3893 @"<xs:element name=""price"" type=""xs:decimal"" msdata:Ordinal=""2"" />" +
3895 @"<xs:attribute name=""genre"" type=""xs:string"" />" +
3896 @"<xs:attribute name=""bookstore_Id"" type=""xs:int"" use=""prohibited"" />" +
3897 @"</xs:complexType>" +
3898 @"<xs:element name=""book"" type=""bookType"" />" +
3899 @"<xs:element name=""Root"" msdata:IsDataSet=""true"" msdata:MainDataTable=""book"" msdata:Locale=""en-US"">" +
3900 @"<xs:complexType>" +
3901 @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3902 @"<xs:element ref=""book"" />" +
3904 @"</xs:complexType>" +
3907 Assert.AreEqual(expected2, TextString2.Replace("\r\n", "").Replace(" ", ""), "#2");
3909 TextWriter writer3 = new StringWriter();
3910 ds.Tables[2].WriteXmlSchema(writer3);
3911 //string TextString3 = GetNormalizedSchema(writer3.ToString());
3912 string TextString3 = writer3.ToString();
3913 string expected3 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3914 @"<xs:schema id=""Root"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3915 @"<xs:complexType name=""authorName"">" +
3917 @"<xs:element name=""first-name"" type=""xs:string"" msdata:Ordinal=""0"" />" +
3918 @"<xs:element name=""last-name"" type=""xs:string"" msdata:Ordinal=""1"" />" +
3920 @"<xs:attribute name=""book_Id"" type=""xs:int"" use=""prohibited"" />" +
3921 @"</xs:complexType>" +
3922 @"<xs:element name=""author"" type=""authorName"" />" +
3923 @"<xs:element name=""Root"" msdata:IsDataSet=""true"" msdata:MainDataTable=""author"" msdata:Locale=""en-US"">" +
3924 @"<xs:complexType>" +
3925 @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3926 @"<xs:element ref=""author"" />" +
3928 @"</xs:complexType>" +
3931 Assert.AreEqual(expected3, TextString3.Replace("\r\n", "").Replace(" ", ""), "#3");
3933 TextWriter writer4 = new StringWriter();
3934 ds.Tables[3].WriteXmlSchema(writer4);
3935 //string TextString4 = GetNormalizedSchema(writer4.ToString());
3936 string TextString4 = writer4.ToString();
3937 string expected4 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3938 @"<xs:schema id=""Root"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3939 @"<xs:element name=""Root"" msdata:IsDataSet=""true"" msdata:MainDataTable=""Region"" msdata:Locale=""en-US"">" +
3940 @"<xs:complexType>" +
3941 @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3942 @"<xs:element name=""Region"">" +
3943 @"<xs:complexType>" +
3945 @"<xs:element name=""RegionID"" type=""xs:string"" minOccurs=""0"" />" +
3946 @"<xs:element name=""RegionDescription"" type=""xs:string"" minOccurs=""0"" />" +
3948 @"</xs:complexType>" +
3951 @"</xs:complexType>" +
3954 Assert.AreEqual(expected4, TextString4.Replace("\r\n", "").Replace(" ", ""), "#4");
3958 [Ignore ("MS behavior is far from consistent to be regarded as a reference implementation.")]
3959 // See the same-named tests in DataSetTest.cs
3961 [Category ("NotWorking")]
3963 public void ReadWriteXmlSchema_IgnoreSchema ()
3965 DataSet ds = new DataSet ();
3966 ds.ReadXmlSchema ("Test/System.Data/store.xsd");
3967 // check dataset properties before testing write
3968 AssertDataSet ("ds", ds, "NewDataSet", 3, 2);
3969 AssertDataTable ("tab1", ds.Tables[0], "bookstore", 1, 0, 0, 1, 1, 1);
3970 AssertDataTable ("tab2", ds.Tables[1], "book", 5, 0, 1, 1, 2, 1);
3971 AssertDataTable ("tab3", ds.Tables[2], "author", 3, 0, 1, 0, 1, 0);
3972 // FIXME: currently order is not compatible. Use name as index
3973 AssertDataRelation ("rel1", ds.Relations["book_author"], "book_author", true, new string[] { "book_Id" }, new string[] { "book_Id" }, true, true);
3974 AssertDataRelation ("rel2", ds.Relations["bookstore_book"], "bookstore_book", true, new string[] { "bookstore_Id" }, new string[] { "bookstore_Id" }, true, true);
3976 ds.ReadXml ("Test/System.Data/region.xml", XmlReadMode.IgnoreSchema);
3977 ds.Relations.Clear (); // because can not call WriteXmlSchema with nested relations.
3979 TextWriter writer1 = new StringWriter ();
3980 ds.Tables[0].WriteXmlSchema (writer1);
3981 //string TextString1 = GetNormalizedSchema (writer1.ToString ());
3982 string TextString1 = writer1.ToString ();
3983 string expected1 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3984 @"<xs:schema id=""NewDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3985 @"<xs:complexType name=""bookstoreType"">" +
3986 @"</xs:complexType>" +
3987 @"<xs:element name=""bookstore"" type=""bookstoreType"" />" +
3988 @"<xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""bookstore"" msdata:UseCurrentLocale=""true"">" +
3989 @"<xs:complexType>" +
3990 @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3991 @"<xs:element ref=""bookstore"" />" +
3993 @"</xs:complexType>" +
3996 Console.WriteLine ("{0} - {1}", TextString1, expected1);
3997 Assert.AreEqual (expected1, TextString1.Replace ("\r\n", "").Replace (" ", "").Replace ("\n", ""), "#1");
3999 TextWriter writer2 = new StringWriter ();
4000 ds.Tables[1].WriteXmlSchema (writer2, false);
4001 string TextString2 = GetNormalizedSchema (writer2.ToString ());
4002 string expected2 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
4003 @"<xs:schema id=""NewDataSet"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"" xmlns:xs=""http://www.w3.org/2001/XMLSchema"">" +
4004 @"<xs:complexType name=""bookType"">" +
4006 @"<xs:element msdata:Ordinal=""1"" name=""title"" type=""xs:string"" />" +
4007 @"<xs:element msdata:Ordinal=""2"" name=""price"" type=""xs:decimal"" />" +
4009 @"<xs:attribute name=""genre"" type=""xs:string"" />" +
4010 @"<xs:attribute name=""bookstore_Id"" type=""xs:int"" use=""prohibited"" />" +
4011 @"</xs:complexType>" +
4012 @"<xs:element name=""book"" type=""bookType"" />" +
4013 @"<xs:element msdata:IsDataSet=""true"" msdata:MainDataTable=""book"" msdata:UseCurrentLocale=""true"" name=""NewDataSet"">" +
4014 @"<xs:complexType>" +
4015 @"<xs:choice maxOccurs=""unbounded"" minOccurs=""0"">" +
4016 @"<xs:element ref=""book"" />" +
4018 @"</xs:complexType>" +
4021 Assert.AreEqual (expected2, TextString2.Replace ("\r\n", "").Replace (" ", ""), "#2");
4023 TextWriter writer3 = new StringWriter ();
4024 ds.Tables[2].WriteXmlSchema (writer3);
4025 string TextString3 = GetNormalizedSchema (writer3.ToString ());
4026 string expected3 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
4027 @"<xs:schema id=""NewDataSet"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"" xmlns:xs=""http://www.w3.org/2001/XMLSchema"">" +
4028 @"<xs:complexType name=""authorName"">" +
4030 @"<xs:element msdata:Ordinal=""0"" name=""first-name"" type=""xs:string"" />" +
4031 @"<xs:element msdata:Ordinal=""1"" name=""last-name"" type=""xs:string"" />" +
4033 @"<xs:attribute name=""book_Id"" type=""xs:int"" use=""prohibited"" />" +
4034 @"</xs:complexType>" +
4035 @"<xs:element name=""author"" type=""authorName"" />" +
4036 @"<xs:element msdata:IsDataSet=""true"" msdata:MainDataTable=""author"" msdata:UseCurrentLocale=""true"" name=""NewDataSet"">" +
4037 @"<xs:complexType>" +
4038 @"<xs:choice maxOccurs=""unbounded"" minOccurs=""0"">" +
4039 @"<xs:element ref=""author"" />" +
4041 @"</xs:complexType>" +
4044 Assert.AreEqual (expected3, TextString3.Replace ("\r\n", "").Replace (" ", ""), "#3");
4046 TextWriter writer4 = new StringWriter ();
4049 ds.Tables [3].WriteXmlSchema (writer4);
4050 Assert.Fail ("expected exception");
4051 } catch (InvalidOperationException ex) {
4057 public void ReadWriteXmlSchema_2 ()
4059 DataSet ds = new DataSet ("dataset");
4060 ds.Tables.Add ("table1");
4061 ds.Tables.Add ("table2");
4062 ds.Tables[0].Columns.Add ("col");
4063 ds.Tables[1].Columns.Add ("col");
4064 ds.Relations.Add ("rel", ds.Tables[0].Columns[0], ds.Tables[1].Columns[0], true);
4066 MemoryStream ms1 = new MemoryStream ();
4067 ds.Tables[0].WriteXmlSchema (ms1);
4068 MemoryStream ms2 = new MemoryStream ();
4069 ds.Tables[1].WriteXmlSchema (ms2);
4071 DataSet ds1 = new DataSet ();
4074 ds1.Tables[0].ReadXmlSchema (new MemoryStream (ms1.GetBuffer ()));
4075 ds1.Tables[1].ReadXmlSchema (new MemoryStream (ms2.GetBuffer ()));
4077 Assert.AreEqual (0, ds1.Relations.Count, "#1");
4078 Assert.AreEqual (1, ds1.Tables[0].Columns.Count, "#2");
4079 Assert.AreEqual (1, ds1.Tables[1].Columns.Count, "#3");
4083 public void ReadWriteXmlSchemaExp_NoRootElmnt ()
4085 MemoryStream ms = new MemoryStream ();
4086 DataTable dtr = new DataTable ();
4088 dtr.ReadXmlSchema (ms);
4090 } catch (XmlException) {
4095 public void ReadWriteXmlSchemaExp_NoTableName ()
4097 DataTable dtw = new DataTable ();
4098 MemoryStream ms = new MemoryStream ();
4100 dtw.WriteXmlSchema (ms);
4102 } catch (InvalidOperationException) {
4107 public void ReadWriteXmlSchemaExp_NoFileName ()
4109 DataTable dtw = new DataTable ();
4111 dtw.WriteXmlSchema (string.Empty);
4113 } catch (ArgumentException) {
4118 public void ReadWriteXmlSchemaExp_TableNameConflict ()
4120 DataTable dtw = new DataTable ("Table1");
4121 StringWriter writer1 = new StringWriter ();
4122 dtw.WriteXmlSchema (writer1);
4123 DataTable dtr = new DataTable ("Table2");
4124 StringReader reader1 = new StringReader (writer1.ToString());
4126 dtr.ReadXmlSchema (reader1);
4128 } catch (ArgumentException) {
4132 #endregion // Read/Write XML Tests
4136 public class MyDataTable : DataTable
4138 public static int count = 0;
4140 public MyDataTable()
4148 public class AppDomainsAndFormatInfo
4150 public void Remote ()
4152 int n = (int) Convert.ChangeType ("5", typeof (int));
4153 Assert.AreEqual (5, n, "n");
4158 public void NFIFromBug55978 ()
4160 AppDomain domain = AppDomain.CreateDomain ("testdomain", null,
4161 AppDomain.CurrentDomain.SetupInformation);
4162 AppDomainsAndFormatInfo test = new AppDomainsAndFormatInfo ();
4164 domain.DoCallBack (new CrossAppDomainDelegate (test.Remote));
4165 AppDomain.Unload (domain);
4170 public void Bug55978 ()
4172 DataTable dt = new DataTable ();
4173 dt.Columns.Add ("StartDate", typeof (DateTime));
4176 DateTime date = DateTime.Now;
4178 for (int i = 0; i < 10; i++) {
4180 dr ["StartDate"] = date.AddDays (i);
4184 DataView dv = dt.DefaultView;
4185 dv.RowFilter = String.Format (CultureInfo.InvariantCulture,
4186 "StartDate >= '{0}' and StartDate <= '{1}'",
4187 DateTime.Now.AddDays (2),
4188 DateTime.Now.AddDays (4));
4189 Assert.AreEqual (10, dt.Rows.Count, "Table");
4190 Assert.AreEqual (2, dv.Count, "View");
4194 public void Bug82109 ()
4196 DataTable tbl = new DataTable ();
4197 tbl.Columns.Add ("data", typeof (DateTime));
4198 DataRow row = tbl.NewRow ();
4199 row ["Data"] = new DateTime (2007, 7, 1);
4202 CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
4203 Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
4206 Thread.CurrentThread.CurrentCulture = new CultureInfo ("it-IT");
4209 Thread.CurrentThread.CurrentCulture = new CultureInfo ("fr-FR");
4211 Thread.CurrentThread.CurrentCulture = currentCulture;
4214 private static void Select (DataTable tbl)
4216 tbl.Locale = CultureInfo.InvariantCulture;
4217 string filter = string.Format ("Data = '{0}'", new DateTime (2007, 7, 1).ToString (CultureInfo.InvariantCulture));
4218 DataRow [] rows = tbl.Select (filter);
4219 Assert.AreEqual (1, rows.Length, "Incorrect number of rows found");