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)
15 // Permission is hereby granted, free of charge, to any person obtaining
16 // a copy of this software and associated documentation files (the
17 // "Software"), to deal in the Software without restriction, including
18 // without limitation the rights to use, copy, modify, merge, publish,
19 // distribute, sublicense, and/or sell copies of the Software, and to
20 // permit persons to whom the Software is furnished to do so, subject to
21 // the following conditions:
23 // The above copyright notice and this permission notice shall be
24 // included in all copies or substantial portions of the Software.
26 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
30 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
31 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
32 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
35 using NUnit.Framework;
38 using System.Data.SqlTypes;
39 using System.Globalization;
41 using System.Runtime.Serialization.Formatters.Binary;
43 using MonoTests.System.Data.Utils;
44 using System.Collections;
45 using System.Threading;
47 namespace MonoTests.System.Data
50 public class DataTableTest : DataSetAssertion
52 string EOL = Environment.NewLine;
57 DataTable dt = new DataTable();
59 Assert.IsFalse (dt.CaseSensitive, "CaseSensitive must be false.");
60 Assert.IsTrue (dt.Columns != null, "Col");
61 //Assert.IsTrue (dt.ChildRelations != null);
62 Assert.IsTrue (dt.Constraints != null, "Const");
63 Assert.IsTrue (dt.DataSet == null, "ds");
64 Assert.IsTrue (dt.DefaultView != null, "dv");
65 Assert.IsTrue (dt.DisplayExpression == "", "de");
66 Assert.IsTrue (dt.ExtendedProperties != null, "ep");
67 Assert.IsTrue (dt.HasErrors == false, "he");
68 Assert.IsTrue (dt.Locale != null, "lc");
69 Assert.IsTrue (dt.MinimumCapacity == 50, "mc"); //LAMESPEC:
70 Assert.IsTrue (dt.Namespace == "", "ns");
71 //Assert.IsTrue (dt.ParentRelations != null);
72 Assert.IsTrue (dt.Prefix == "", "pf");
73 Assert.IsTrue (dt.PrimaryKey != null, "pk");
74 Assert.IsTrue (dt.Rows != null, "rows");
75 Assert.IsTrue (dt.Site == null, "Site");
76 Assert.IsTrue (dt.TableName == "", "tname");
83 DataSet Set = new DataSet ();
84 DataTable Mom = new DataTable ("Mom");
85 DataTable Child = new DataTable ("Child");
87 Set.Tables.Add (Child);
89 DataColumn Col = new DataColumn ("Name");
90 DataColumn Col2 = new DataColumn ("ChildName");
91 Mom.Columns.Add (Col);
92 Mom.Columns.Add (Col2);
94 DataColumn Col3 = new DataColumn ("Name");
95 DataColumn Col4 = new DataColumn ("Age");
96 Col4.DataType = Type.GetType ("System.Int16");
97 Child.Columns.Add (Col3);
98 Child.Columns.Add (Col4);
100 DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);
101 Set.Relations.Add (Relation);
103 DataRow Row = Mom.NewRow ();
129 Row [0] = "'Jhon O'' Collenal'";
133 Row = Child.NewRow ();
136 Child.Rows.Add (Row);
138 Row = Child.NewRow ();
141 Child.Rows.Add (Row);
143 Row = Child.NewRow ();
146 Child.Rows.Add (Row);
148 Row = Child.NewRow ();
151 Child.Rows.Add (Row);
153 Row = Child.NewRow ();
156 Child.Rows.Add (Row);
158 Row = Child.NewRow ();
161 Child.Rows.Add (Row);
163 Row = Child.NewRow ();
166 Child.Rows.Add (Row);
168 DataRow [] Rows = Mom.Select ("Name = 'Teresa'");
169 Assert.AreEqual (2, Rows.Length, "test#01");
171 // test with apos escaped
172 Rows = Mom.Select ("Name = '''Jhon O'''' Collenal'''");
173 Assert.AreEqual (1, Rows.Length, "test#01.1");
175 Rows = Mom.Select ("Name = 'Teresa' and ChildName = 'Nick'");
176 Assert.AreEqual (0, Rows.Length, "test#02");
178 Rows = Mom.Select ("Name = 'Teresa' and ChildName = 'Jack'");
179 Assert.AreEqual (1, Rows.Length, "test#03");
181 Rows = Mom.Select ("Name = 'Teresa' and ChildName <> 'Jack'");
182 Assert.AreEqual ("Mack", Rows [0] [1], "test#04");
184 Rows = Mom.Select ("Name = 'Teresa' or ChildName <> 'Jack'");
185 Assert.AreEqual (6, Rows.Length, "test#05");
187 Rows = Child.Select ("age = 20 - 1");
188 Assert.AreEqual (1, Rows.Length, "test#06");
190 Rows = Child.Select ("age <= 20");
191 Assert.AreEqual (3, Rows.Length, "test#07");
193 Rows = Child.Select ("age >= 20");
194 Assert.AreEqual (4, Rows.Length, "test#08");
196 Rows = Child.Select ("age >= 20 and name = 'Mack' or name = 'Nick'");
197 Assert.AreEqual (2, Rows.Length, "test#09");
199 Rows = Child.Select ("age >= 20 and (name = 'Mack' or name = 'Nick')");
200 Assert.AreEqual (1, Rows.Length, "test#10");
201 Assert.AreEqual ("Mack", Rows [0] [0], "test#11");
203 Rows = Child.Select ("not (Name = 'Jack')");
204 Assert.AreEqual (6, Rows.Length, "test#12");
208 public void Select2 ()
210 DataSet Set = new DataSet ();
211 DataTable Child = new DataTable ("Child");
213 Set.Tables.Add (Child);
215 DataColumn Col3 = new DataColumn ("Name");
216 DataColumn Col4 = new DataColumn ("Age");
217 Col4.DataType = Type.GetType ("System.Int16");
218 Child.Columns.Add (Col3);
219 Child.Columns.Add (Col4);
221 DataRow Row = Child.NewRow ();
224 Child.Rows.Add (Row);
226 Row = Child.NewRow ();
229 Child.Rows.Add (Row);
231 Row = Child.NewRow ();
234 Child.Rows.Add (Row);
236 Row = Child.NewRow ();
239 Child.Rows.Add (Row);
241 Row = Child.NewRow ();
244 Child.Rows.Add (Row);
246 Row = Child.NewRow ();
249 Child.Rows.Add (Row);
251 DataRow [] Rows = Child.Select ("age >= 20", "age DESC");
252 Assert.AreEqual (3, Rows.Length, "test#01");
253 Assert.AreEqual ("Mack", Rows [0] [0], "test#02");
254 Assert.AreEqual ("Mick", Rows [1] [0], "test#03");
255 Assert.AreEqual ("Dick", Rows [2] [0], "test#04");
257 Rows = Child.Select ("age >= 20", "age asc");
258 Assert.AreEqual (3, Rows.Length, "test#05");
259 Assert.AreEqual ("Dick", Rows [0] [0], "test#06");
260 Assert.AreEqual ("Mick", Rows [1] [0], "test#07");
261 Assert.AreEqual ("Mack", Rows [2] [0], "test#08");
263 Rows = Child.Select ("age >= 20", "name asc");
264 Assert.AreEqual (3, Rows.Length, "test#09");
265 Assert.AreEqual ("Dick", Rows [0] [0], "test#10");
266 Assert.AreEqual ("Mack", Rows [1] [0], "test#11");
267 Assert.AreEqual ("Mick", Rows [2] [0], "test#12");
269 Rows = Child.Select ("age >= 20", "name desc");
270 Assert.AreEqual (3, Rows.Length, "test#09");
271 Assert.AreEqual ("Mick", Rows [0] [0], "test#10");
272 Assert.AreEqual ("Mack", Rows [1] [0], "test#11");
273 Assert.AreEqual ("Dick", Rows [2] [0], "test#12");
278 public void SelectParsing ()
280 DataTable T = new DataTable ("test");
281 DataColumn C = new DataColumn ("name");
283 C = new DataColumn ("age");
284 C.DataType = typeof (int);
286 C = new DataColumn ("id");
289 DataSet Set = new DataSet ("TestSet");
293 for (int i = 0; i < 100; i++) {
295 Row [0] = "human" + i;
307 Assert.AreEqual (12, T.Select ("age<=10").Length, "test#01");
309 Assert.AreEqual (12, T.Select ("age\n\t<\n\t=\t\n10").Length, "test#02");
312 T.Select ("name = 1human ");
313 Assert.Fail ("test#03");
314 } catch (Exception e) {
316 // missing operand after 'human' operand
317 Assert.AreEqual (typeof (SyntaxErrorException), e.GetType (), "test#04");
321 T.Select ("name = 1");
322 Assert.Fail ("test#05");
323 } catch (Exception 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");
334 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) {}
350 public void SelectOperators ()
352 DataTable T = new DataTable ("test");
353 DataColumn C = new DataColumn ("name");
355 C = new DataColumn ("age");
356 C.DataType = typeof (int);
358 C = new DataColumn ("id");
361 DataSet Set = new DataSet ("TestSet");
365 for (int i = 0; i < 100; i++) {
367 Row [0] = "human" + i;
379 Assert.AreEqual (11, T.Select ("age < 10").Length, "test#01");
380 Assert.AreEqual (12, T.Select ("age <= 10").Length, "test#02");
381 Assert.AreEqual (12, T.Select ("age< =10").Length, "test#03");
382 Assert.AreEqual (89, T.Select ("age > 10").Length, "test#04");
383 Assert.AreEqual (90, T.Select ("age >= 10").Length, "test#05");
384 Assert.AreEqual (100, T.Select ("age <> 10").Length, "test#06");
385 Assert.AreEqual (3, T.Select ("name < 'human10'").Length, "test#07");
386 Assert.AreEqual (3, T.Select ("id < '10'").Length, "test#08");
387 // FIXME: Somebody explain how this can be possible.
388 // it seems that it is no matter between 10 - 30. The
389 // result is allways 25 :-P
390 //Assert.AreEqual (25, T.Select ("id < 10").Length, "test#09");
395 public void SelectExceptions ()
397 DataTable T = new DataTable ("test");
398 DataColumn C = new DataColumn ("name");
400 C = new DataColumn ("age");
401 C.DataType = typeof (int);
403 C = new DataColumn ("id");
406 for (int i = 0; i < 100; i++) {
407 DataRow Row = T.NewRow ();
408 Row [0] = "human" + i;
415 T.Select ("name = human1");
416 Assert.Fail ("test#01");
417 } catch (Exception 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 (Exception e) {
431 // no operands after k3 operator
432 Assert.AreEqual (typeof (SyntaxErrorException), e.GetType (), "test#07");
437 public void SelectStringOperators ()
439 DataTable T = new DataTable ("test");
440 DataColumn C = new DataColumn ("name");
442 C = new DataColumn ("age");
443 C.DataType = typeof (int);
445 C = new DataColumn ("id");
448 DataSet Set = new DataSet ("TestSet");
452 for (int i = 0; i < 100; i++) {
454 Row [0] = "human" + i;
465 Assert.AreEqual (1, T.Select ("name = 'human' + 1").Length, "test#01");
467 Assert.AreEqual ("human1", T.Select ("name = 'human' + 1") [0] ["name"], "test#02");
468 Assert.AreEqual (1, T.Select ("name = 'human' + '1'").Length, "test#03");
469 Assert.AreEqual ("human1", T.Select ("name = 'human' + '1'") [0] ["name"], "test#04");
470 Assert.AreEqual (1, T.Select ("name = 'human' + 1 + 2").Length, "test#05");
471 Assert.AreEqual ("human12", T.Select ("name = 'human' + '1' + '2'") [0] ["name"], "test#06");
473 Assert.AreEqual (1, T.Select ("name = 'huMAn' + 1").Length, "test#07");
475 Set.CaseSensitive = true;
476 Assert.AreEqual (0, T.Select ("name = 'huMAn' + 1").Length, "test#08");
478 T.CaseSensitive = false;
479 Assert.AreEqual (1, T.Select ("name = 'huMAn' + 1").Length, "test#09");
481 T.CaseSensitive = true;
482 Assert.AreEqual (0, T.Select ("name = 'huMAn' + 1").Length, "test#10");
484 Set.CaseSensitive = false;
485 Assert.AreEqual (0, T.Select ("name = 'huMAn' + 1").Length, "test#11");
487 T.CaseSensitive = false;
488 Assert.AreEqual (1, T.Select ("name = 'huMAn' + 1").Length, "test#12");
490 Assert.AreEqual (0, T.Select ("name = 'human1*'").Length, "test#13");
491 Assert.AreEqual (11, T.Select ("name like 'human1*'").Length, "test#14");
492 Assert.AreEqual (11, T.Select ("name like 'human1%'").Length, "test#15");
495 Assert.AreEqual (11, T.Select ("name like 'h*an1'").Length, "test#16");
496 Assert.Fail ("test#16");
497 } catch (Exception e) {
499 // 'h*an1' is invalid
500 Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#17");
504 Assert.AreEqual (11, T.Select ("name like 'h%an1'").Length, "test#18");
505 Assert.Fail ("test#19");
506 } catch (Exception e) {
508 // 'h%an1' is invalid
509 Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#20");
512 Assert.AreEqual (0, T.Select ("name like 'h[%]an'").Length, "test#21");
513 Assert.AreEqual (1, T.Select ("name like 'h[*]an'").Length, "test#22");
518 public void SelectAggregates ()
520 DataTable T = new DataTable ("test");
521 DataColumn C = new DataColumn ("name");
523 C = new DataColumn ("age");
524 C.DataType = typeof (int);
526 C = new DataColumn ("id");
530 for (int i = 0; i < 1000; i++) {
532 Row [0] = "human" + i;
538 Assert.AreEqual (1000, T.Select ("Sum(age) > 10").Length, "test#01");
539 Assert.AreEqual (1000, T.Select ("avg(age) = 499").Length, "test#02");
540 Assert.AreEqual (1000, T.Select ("min(age) = 0").Length, "test#03");
541 Assert.AreEqual (1000, T.Select ("max(age) = 999").Length, "test#04");
542 Assert.AreEqual (1000, T.Select ("count(age) = 1000").Length, "test#05");
543 Assert.AreEqual (1000, T.Select ("stdev(age) > 287 and stdev(age) < 289").Length, "test#06");
544 Assert.AreEqual (1000, T.Select ("var(age) < 83417 and var(age) > 83416").Length, "test#07");
548 public void SelectFunctions ()
550 DataTable T = new DataTable ("test");
551 DataColumn C = new DataColumn ("name");
553 C = new DataColumn ("age");
554 C.DataType = typeof (int);
556 C = new DataColumn ("id");
560 for (int i = 0; i < 1000; i++) {
562 Row [0] = "human" + i;
569 Row [0] = "human" + "test";
570 Row [1] = DBNull.Value;
571 Row [2] = DBNull.Value;
574 //TODO: How to test Convert-function
575 Assert.AreEqual (25, T.Select ("age = 5*5") [0]["age"], "test#01");
576 Assert.AreEqual (901, T.Select ("len(name) > 7").Length, "test#02");
577 Assert.AreEqual (125, T.Select ("age = 5*5*5 AND len(name)>7") [0]["age"], "test#03");
578 Assert.AreEqual (1, T.Select ("isnull(id, 'test') = 'test'").Length, "test#04");
579 Assert.AreEqual (1000, T.Select ("iif(id = '56', 'test', 'false') = 'false'").Length, "test#05");
580 Assert.AreEqual (1, T.Select ("iif(id = '56', 'test', 'false') = 'test'").Length, "test#06");
581 Assert.AreEqual (9, T.Select ("substring(id, 2, 3) = '23'").Length, "test#07");
582 Assert.AreEqual ("123", T.Select ("substring(id, 2, 3) = '23'") [0] ["id"], "test#08");
583 Assert.AreEqual ("423", T.Select ("substring(id, 2, 3) = '23'") [3] ["id"], "test#09");
584 Assert.AreEqual ("923", T.Select ("substring(id, 2, 3) = '23'") [8] ["id"], "test#10");
589 public void SelectRelations ()
591 DataSet Set = new DataSet ();
592 DataTable Mom = new DataTable ("Mom");
593 DataTable Child = new DataTable ("Child");
595 Set.Tables.Add (Mom);
596 Set.Tables.Add (Child);
598 DataColumn Col = new DataColumn ("Name");
599 DataColumn Col2 = new DataColumn ("ChildName");
600 Mom.Columns.Add (Col);
601 Mom.Columns.Add (Col2);
603 DataColumn Col3 = new DataColumn ("Name");
604 DataColumn Col4 = new DataColumn ("Age");
605 Col4.DataType = Type.GetType ("System.Int16");
606 Child.Columns.Add (Col3);
607 Child.Columns.Add (Col4);
609 DataRelation Relation = new DataRelation ("Rel", Mom.Columns [1], Child.Columns [0]);
610 Set.Relations.Add (Relation);
612 DataRow Row = Mom.NewRow ();
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 Row = Child.NewRow ();
665 Child.Rows.Add (Row);
667 DataRow [] Rows = Child.Select ("name = Parent.Childname");
668 Assert.AreEqual (6, Rows.Length, "test#01");
669 Rows = Child.Select ("Parent.childname = 'Jack'");
670 Assert.AreEqual (1, Rows.Length, "test#02");
674 // FIXME: LAMESPEC: Why the exception is thrown why... why...
675 Mom.Select ("Child.Name = 'Jack'");
676 Assert.Fail ("test#03");
677 } catch (Exception e) {
678 Assert.AreEqual (typeof (SyntaxErrorException), e.GetType (), "test#04");
679 Assert.AreEqual ("Cannot interpret token 'Child' at position 1.", e.Message, "test#05");
683 Rows = Child.Select ("Parent.name = 'Laura'");
684 Assert.AreEqual (3, Rows.Length, "test#06");
686 DataTable Parent2 = new DataTable ("Parent2");
687 Col = new DataColumn ("Name");
688 Col2 = new DataColumn ("ChildName");
690 Parent2.Columns.Add (Col);
691 Parent2.Columns.Add (Col2);
692 Set.Tables.Add (Parent2);
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 Row = Parent2.NewRow ();
717 Parent2.Rows.Add (Row);
719 Relation = new DataRelation ("Rel2", Parent2.Columns [1], Child.Columns [0]);
720 Set.Relations.Add (Relation);
723 Rows = Child.Select ("Parent.ChildName = 'Jack'");
724 Assert.Fail ("test#07");
725 } catch (Exception e) {
726 Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#08");
727 //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");
730 Rows = Child.Select ("Parent(rel).ChildName = 'Jack'");
731 Assert.AreEqual (1, Rows.Length, "test#10");
733 Rows = Child.Select ("Parent(Rel2).ChildName = 'Jack'");
734 Assert.AreEqual (1, Rows.Length, "test#10");
737 Mom.Select ("Parent.name = 'John'");
738 } catch (Exception e) {
739 Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (), "test#11");
740 Assert.AreEqual ("Cannot find relation 0.", e.Message, "test#12");
746 public void SelectRowState()
748 DataTable d = new DataTable();
749 d.Columns.Add (new DataColumn ("aaa"));
750 DataRow [] rows = d.Select (null, null, DataViewRowState.Deleted);
751 Assert.AreEqual (0, rows.Length);
752 d.Rows.Add (new object [] {"bbb"});
753 d.Rows.Add (new object [] {"bbb"});
754 rows = d.Select (null, null, DataViewRowState.Deleted);
755 Assert.AreEqual (0, rows.Length);
759 public void ToStringTest()
761 DataTable dt = new DataTable();
762 dt.Columns.Add("Col1",typeof(int));
764 dt.TableName = "Mytable";
765 dt.DisplayExpression = "Col1";
768 string cmpr = dt.TableName + " + " + dt.DisplayExpression;
769 Assert.AreEqual (cmpr, dt.ToString());
773 public void PrimaryKey ()
775 DataTable dt = new DataTable ();
776 DataColumn Col = new DataColumn ();
777 Col.AllowDBNull = false;
778 Col.DataType = typeof (int);
779 dt.Columns.Add (Col);
784 Assert.AreEqual (0, dt.PrimaryKey.Length, "test#01");
786 dt.PrimaryKey = new DataColumn [] {dt.Columns [0]};
787 Assert.AreEqual (1, dt.PrimaryKey.Length, "test#02");
788 Assert.AreEqual ("Column1", dt.PrimaryKey [0].ColumnName, "test#03");
790 dt.PrimaryKey = null;
791 Assert.AreEqual (0, dt.PrimaryKey.Length, "test#04");
793 Col = new DataColumn ("failed");
796 dt.PrimaryKey = new DataColumn [] {Col};
797 Assert.Fail ("test#05");
798 } catch (Exception e) {
799 Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#06");
800 Assert.AreEqual ("Column must belong to a table.", e.Message, "test#07");
803 DataTable dt2 = new DataTable ();
807 dt.PrimaryKey = new DataColumn [] {dt2.Columns [0]};
808 Assert.Fail ("test#08");
809 } catch (Exception e) {
810 Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#09");
811 Assert.AreEqual ("PrimaryKey columns do not belong to this table.", e.Message, "test#10");
815 Assert.AreEqual (0, dt.Constraints.Count, "test#11");
817 dt.PrimaryKey = new DataColumn [] {dt.Columns [0], dt.Columns [1]};
818 Assert.AreEqual (2, dt.PrimaryKey.Length, "test#12");
819 Assert.AreEqual (1, dt.Constraints.Count, "test#13");
820 Assert.IsTrue (dt.Constraints [0] is UniqueConstraint, "test#14");
821 Assert.AreEqual ("Column1", dt.PrimaryKey [0].ColumnName, "test#15");
822 Assert.AreEqual ("Column2", dt.PrimaryKey [1].ColumnName, "test#16");
827 public void PropertyExceptions ()
829 DataSet set = new DataSet ();
830 DataTable table = new DataTable ();
831 DataTable table1 = new DataTable ();
832 set.Tables.Add (table);
833 set.Tables.Add (table1);
835 DataColumn col = new DataColumn ();
836 col.ColumnName = "Id";
837 col.DataType = Type.GetType ("System.Int32");
838 table.Columns.Add (col);
839 UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
840 table.Constraints.Add (uc);
841 table.CaseSensitive = false;
843 col = new DataColumn ();
844 col.ColumnName = "Name";
845 col.DataType = Type.GetType ("System.String");
846 table.Columns.Add (col);
848 col = new DataColumn ();
849 col.ColumnName = "Id";
850 col.DataType = Type.GetType ("System.Int32");
851 table1.Columns.Add (col);
852 col = new DataColumn ();
853 col.ColumnName = "Name";
854 col.DataType = Type.GetType ("System.String");
855 table1.Columns.Add (col);
857 DataRelation dr = new DataRelation ("DR", table.Columns[0], table1.Columns[0]);
858 set.Relations.Add (dr);
861 table.CaseSensitive = true;
862 table1.CaseSensitive = true;
863 Assert.Fail ("#A01");
865 catch (Exception e) {
866 if (e.GetType () != typeof (AssertionException))
867 Assert.AreEqual ("Cannot change CaseSensitive or Locale property. This change would lead to at least one DataRelation or Constraint to have different Locale or CaseSensitive settings between its related tables.", e.Message, "#A02");
869 Console.WriteLine (e);
872 CultureInfo cultureInfo = new CultureInfo ("en-gb");
873 table.Locale = cultureInfo;
874 table1.Locale = cultureInfo;
875 Assert.Fail ("#A03");
877 catch (Exception e) {
878 if (e.GetType () != typeof (AssertionException))
879 Assert.AreEqual ("Cannot change CaseSensitive or Locale property. This change would lead to at least one DataRelation or Constraint to have different Locale or CaseSensitive settings between its related tables.", e.Message, "#A04");
881 Console.WriteLine (e);
884 table.Prefix = "Prefix#1";
885 Assert.Fail ("#A05");
888 if (e.GetType () != typeof (AssertionException))
889 Assert.AreEqual ("Prefix 'Prefix#1' is not valid, because it contains special characters.",e.Message, "#A06");
891 Console.WriteLine (e);
897 public void GetErrors ()
899 DataTable table = new DataTable ();
901 DataColumn col = new DataColumn ();
902 col.ColumnName = "Id";
903 col.DataType = Type.GetType ("System.Int32");
904 table.Columns.Add (col);
906 col = new DataColumn ();
907 col.ColumnName = "Name";
908 col.DataType = Type.GetType ("System.String");
909 table.Columns.Add (col);
911 DataRow row = table.NewRow ();
913 row ["name"] = "Abc";
914 row.RowError = "Error#1";
915 table.Rows.Add (row);
917 Assert.AreEqual (1, table.GetErrors ().Length, "#A01");
918 Assert.AreEqual ("Error#1", (table.GetErrors ())[0].RowError, "#A02");
922 public void NewRowAddedTest ()
924 DataTable table = new DataTable ();
926 DataColumn col = new DataColumn ();
927 col.ColumnName = "Id";
928 col.DataType = Type.GetType ("System.Int32");
929 table.Columns.Add (col);
931 col = new DataColumn ();
932 col.ColumnName = "Name";
933 col.DataType = Type.GetType ("System.String");
934 table.Columns.Add (col);
936 _tableNewRowAddedEventFired = false;
937 table.TableNewRow += new DataTableNewRowEventHandler (OnTableNewRowAdded);
938 DataRow row = table.NewRow ();
940 row ["name"] = "Abc";
941 table.Rows.Add (row);
943 Assert.IsTrue (_tableNewRowAddedEventFired, "#NewRowAdded Event #01");
947 public void CloneCopyTest ()
949 DataTable table = new DataTable ();
950 table.TableName = "Table#1";
951 DataTable table1 = new DataTable ();
952 table1.TableName = "Table#2";
954 table.AcceptChanges ();
956 DataSet set = new DataSet ("Data Set#1");
957 set.DataSetName = "Dataset#1";
958 set.Tables.Add (table);
959 set.Tables.Add (table1);
961 DataColumn col = new DataColumn ();
962 col.ColumnName = "Id";
963 col.DataType = Type.GetType ("System.Int32");
964 table.Columns.Add (col);
965 UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
966 table.Constraints.Add (uc);
968 col = new DataColumn ();
969 col.ColumnName = "Id";
970 col.DataType = Type.GetType ("System.Int32");
971 table1.Columns.Add (col);
973 col = new DataColumn ();
974 col.ColumnName = "Name";
975 col.DataType = Type.GetType ("System.String");
976 table.Columns.Add (col);
978 col = new DataColumn ();
979 col.ColumnName = "Name";
980 col.DataType = Type.GetType ("System.String");
981 table1.Columns.Add (col);
982 DataRow row = table.NewRow ();
984 row ["name"] = "Abc";
985 row.RowError = "Error#1";
986 table.Rows.Add (row);
988 row = table.NewRow ();
990 row ["name"] = "Efg";
991 table.Rows.Add (row);
992 table.AcceptChanges ();
994 table.CaseSensitive = true;
995 table1.CaseSensitive = true;
996 table.MinimumCapacity = 100;
997 table.Prefix = "PrefixNo:1";
998 table.Namespace = "Namespace#1";
999 table.DisplayExpression = "Id / Name + (Id * Id)";
1000 DataColumn[] colArray = {table.Columns[0]};
1001 table.PrimaryKey = colArray;
1002 table.ExtendedProperties.Add ("TimeStamp", DateTime.Now);
1003 #if NET_1_1 // This prevents further tests after .NET 1.1.
1005 CultureInfo cultureInfo = new CultureInfo ("en-gb");
1006 table.Locale = cultureInfo;
1009 row = table1.NewRow ();
1010 row ["Name"] = "Abc";
1012 table1.Rows.Add (row);
1014 row = table1.NewRow ();
1016 row ["Name"] = "Efg";
1017 table1.Rows.Add (row);
1019 DataRelation dr = new DataRelation ("DR", table.Columns[0], table1.Columns[0]);
1020 set.Relations.Add (dr);
1022 //Testing properties of clone
1023 DataTable cloneTable = table.Clone ();
1024 Assert.IsTrue (cloneTable.CaseSensitive, "#A01");
1025 Assert.AreEqual (0 , cloneTable.ChildRelations.Count, "#A02");
1026 Assert.AreEqual (0 , cloneTable.ParentRelations.Count, "#A03");
1027 Assert.AreEqual (2, cloneTable.Columns.Count, "#A04");
1028 Assert.AreEqual (1, cloneTable.Constraints.Count, "#A05");
1029 Assert.AreEqual ("Id / Name + (Id * Id)", cloneTable.DisplayExpression, "#A06");
1030 Assert.AreEqual (1, cloneTable.ExtendedProperties.Count, "#A07");
1031 Assert.IsFalse (cloneTable.HasErrors, "#A08");
1034 Assert.AreEqual (2057, cloneTable.Locale.LCID, "#A09");
1036 Assert.AreEqual (100, cloneTable.MinimumCapacity, "#A10");
1037 Assert.AreEqual ("Namespace#1", cloneTable.Namespace, "#A11");
1038 Assert.AreEqual ("PrefixNo:1", cloneTable.Prefix, "#A12");
1039 Assert.AreEqual ("Id", cloneTable.PrimaryKey[0].ColumnName, "#A13");
1040 Assert.AreEqual (0, cloneTable.Rows.Count , "#A14");
1041 Assert.AreEqual ("Table#1", cloneTable.TableName, "#A15");
1043 //Testing properties of copy
1044 DataTable copyTable = table.Copy ();
1045 Assert.IsTrue (copyTable.CaseSensitive, "#A16");
1046 Assert.AreEqual (0 , copyTable.ChildRelations.Count, "#A17");
1047 Assert.AreEqual (0 , copyTable.ParentRelations.Count, "#A18");
1048 Assert.AreEqual (2, copyTable.Columns.Count, "#A19");
1049 Assert.AreEqual (1, copyTable.Constraints.Count, "#A20");
1050 Assert.AreEqual ("Id / Name + (Id * Id)", copyTable.DisplayExpression, "#A21");
1051 Assert.AreEqual (1, copyTable.ExtendedProperties.Count, "#A22");
1052 Assert.IsTrue (copyTable.HasErrors, "#A23");
1055 Assert.AreEqual (2057, copyTable.Locale.LCID, "#A24");
1057 Assert.AreEqual (100, copyTable.MinimumCapacity, "#A25");
1058 Assert.AreEqual ("Namespace#1", copyTable.Namespace, "#A26");
1059 Assert.AreEqual ("PrefixNo:1", copyTable.Prefix, "#A27");
1060 Assert.AreEqual ("Id", copyTable.PrimaryKey[0].ColumnName, "#A28");
1061 Assert.AreEqual (2, copyTable.Rows.Count, "#A29");
1062 Assert.AreEqual ("Table#1", copyTable.TableName, "#A30");
1066 public void LoadDataException ()
1068 DataTable table = new DataTable ();
1069 DataColumn col = new DataColumn ();
1070 col.ColumnName = "Id";
1071 col.DataType = Type.GetType ("System.Int32");
1072 col.DefaultValue = 47;
1073 table.Columns.Add (col);
1074 UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
1075 table.Constraints.Add (uc);
1077 col = new DataColumn ();
1078 col.ColumnName = "Name";
1079 col.DataType = Type.GetType ("System.String");
1080 col.DefaultValue = "Hello";
1081 table.Columns.Add (col);
1083 table.BeginLoadData();
1084 object[] row = {147, "Abc"};
1085 DataRow newRow = table.LoadDataRow (row, true);
1087 object[] row1 = {147, "Efg"};
1088 DataRow newRow1 = table.LoadDataRow (row1, true);
1090 object[] row2 = {143, "Hij"};
1091 DataRow newRow2 = table.LoadDataRow (row2, true);
1094 table.EndLoadData ();
1095 Assert.Fail ("#A01");
1097 catch (ConstraintException) {
1101 public void Changes () //To test GetChanges and RejectChanges
1103 DataTable table = new DataTable ();
1105 DataColumn col = new DataColumn ();
1106 col.ColumnName = "Id";
1107 col.DataType = Type.GetType ("System.Int32");
1108 table.Columns.Add (col);
1109 UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
1110 table.Constraints.Add (uc);
1112 col = new DataColumn ();
1113 col.ColumnName = "Name";
1114 col.DataType = Type.GetType ("System.String");
1115 table.Columns.Add (col);
1117 DataRow row = table.NewRow ();
1119 row ["name"] = "Abc";
1120 table.Rows.Add (row);
1121 table.AcceptChanges ();
1123 row = table.NewRow ();
1125 row ["name"] = "Efg";
1126 table.Rows.Add (row);
1128 //Testing GetChanges
1129 DataTable changesTable = table.GetChanges ();
1130 Assert.AreEqual (1, changesTable.Rows.Count, "#A01");
1131 Assert.AreEqual ("Efg", changesTable.Rows[0]["Name"], "#A02");
1132 table.AcceptChanges ();
1133 changesTable = table.GetChanges ();
1135 int cnt = changesTable.Rows.Count;
1137 catch(Exception e) {
1138 if (e.GetType () != typeof (AssertionException))
1139 Assert.AreEqual (typeof(NullReferenceException), e.GetType (), "#A03");
1141 Console.WriteLine (e);
1144 //Testing RejectChanges
1145 row = table.NewRow ();
1147 row ["name"] = "Hij";
1148 table.Rows.Add (row);
1150 (table.Rows [0])["Name"] = "AaBbCc";
1151 table.RejectChanges ();
1152 Assert.AreEqual ("Abc" , (table.Rows [0]) ["Name"], "#A03");
1153 Assert.AreEqual (2, table.Rows.Count, "#A04");
1157 public void ImportRowTest ()
1159 // build source table
1160 DataTable src = new DataTable ();
1161 src.Columns.Add ("id", typeof (int));
1162 src.Columns.Add ("name", typeof (string));
1164 src.PrimaryKey = new DataColumn [] {src.Columns [0]} ;
1166 src.Rows.Add (new object [] { 1, "mono 1" });
1167 src.Rows.Add (new object [] { 2, "mono 2" });
1168 src.Rows.Add (new object [] { 3, "mono 3" });
1169 src.AcceptChanges ();
1171 src.Rows [0] [1] = "mono changed 1"; // modify 1st row
1172 src.Rows [1].Delete (); // delete 2nd row
1173 // 3rd row is unchanged
1174 src.Rows.Add (new object [] { 4, "mono 4" }); // add 4th row
1176 // build target table
1177 DataTable target = new DataTable ();
1178 target.Columns.Add ("id", typeof (int));
1179 target.Columns.Add ("name", typeof (string));
1181 target.PrimaryKey = new DataColumn [] {target.Columns [0]} ;
1184 target.ImportRow (src.Rows [0]); // import 1st row
1185 target.ImportRow (src.Rows [1]); // import 2nd row
1186 target.ImportRow (src.Rows [2]); // import 3rd row
1187 target.ImportRow (src.Rows [3]); // import 4th row
1190 target.ImportRow (src.Rows [2]); // import 3rd row again
1191 Assert.Fail ("#AA1 Should have thrown exception violativ PK");
1192 } catch (ConstraintException e) {}
1195 Assert.AreEqual (src.Rows [0].RowState, target.Rows [0].RowState, "#A1");
1196 Assert.AreEqual (src.Rows [1].RowState, target.Rows [1].RowState, "#A2");
1197 Assert.AreEqual (src.Rows [2].RowState, target.Rows [2].RowState, "#A3");
1198 Assert.AreEqual (src.Rows [3].RowState, target.Rows [3].RowState, "#A4");
1200 // check for modified row (1st row)
1201 Assert.AreEqual ((string) src.Rows [0] [1], (string) target.Rows [0] [1], "#B1");
1202 Assert.AreEqual ((string) src.Rows [0] [1, DataRowVersion.Default], (string) target.Rows [0] [1, DataRowVersion.Default], "#B2");
1203 Assert.AreEqual ((string) src.Rows [0] [1, DataRowVersion.Original], (string) target.Rows [0] [1, DataRowVersion.Original], "#B3");
1204 Assert.AreEqual ((string) src.Rows [0] [1, DataRowVersion.Current], (string) target.Rows [0] [1, DataRowVersion.Current], "#B4");
1205 Assert.IsFalse (target.Rows [0].HasVersion(DataRowVersion.Proposed), "#B5");
1207 // check for deleted row (2nd row)
1208 Assert.AreEqual ((string) src.Rows [1] [1, DataRowVersion.Original], (string) target.Rows [1] [1, DataRowVersion.Original], "#C1");
1210 // check for unchanged row (3rd row)
1211 Assert.AreEqual ((string) src.Rows [2] [1], (string) target.Rows [2] [1], "#D1");
1212 Assert.AreEqual ((string) src.Rows [2] [1, DataRowVersion.Default], (string) target.Rows [2] [1, DataRowVersion.Default], "#D2");
1213 Assert.AreEqual ((string) src.Rows [2] [1, DataRowVersion.Original], (string) target.Rows [2] [1, DataRowVersion.Original], "#D3");
1214 Assert.AreEqual ((string) src.Rows [2] [1, DataRowVersion.Current], (string) target.Rows [2] [1, DataRowVersion.Current], "#D4");
1216 // check for newly added row (4th row)
1217 Assert.AreEqual ((string) src.Rows [3] [1], (string) target.Rows [3] [1], "#E1");
1218 Assert.AreEqual ((string) src.Rows [3] [1, DataRowVersion.Default], (string) target.Rows [3] [1, DataRowVersion.Default], "#E2");
1219 Assert.AreEqual ((string) src.Rows [3] [1, DataRowVersion.Current], (string) target.Rows [3] [1, DataRowVersion.Current], "#E3");
1223 public void ImportRowDetachedTest ()
1225 DataTable table = new DataTable ();
1226 DataColumn col = new DataColumn ();
1227 col.ColumnName = "Id";
1228 col.DataType = Type.GetType ("System.Int32");
1229 table.Columns.Add (col);
1231 table.PrimaryKey = new DataColumn [] {col};
1233 col = new DataColumn ();
1234 col.ColumnName = "Name";
1235 col.DataType = Type.GetType ("System.String");
1236 table.Columns.Add (col);
1238 DataRow row = table.NewRow ();
1240 row ["name"] = "Abc";
1242 // keep silent as ms.net ;-), though this is not useful.
1243 table.ImportRow (row);
1245 //if RowState is detached, then dont import the row.
1246 Assert.AreEqual (0, table.Rows.Count, "#1");
1250 public void ImportRowDeletedTest ()
1252 DataTable table = new DataTable ();
1253 table.Columns.Add ("col", typeof (int));
1254 table.Columns.Add ("col1", typeof (int));
1256 DataRow row = table.Rows.Add (new object[] {1,2});
1257 table.PrimaryKey = new DataColumn[] {table.Columns[0]};
1258 table.AcceptChanges ();
1260 // If row is in Deleted state, then ImportRow loads the
1263 table.ImportRow (row);
1264 Assert.AreEqual (2, table.Rows.Count, "#1");
1266 // Both the deleted rows shud be now gone
1267 table.AcceptChanges ();
1268 Assert.AreEqual (0, table.Rows.Count, "#2");
1270 //just add another row
1271 row = table.Rows.Add (new object[] {1,2});
1272 // no exception shud be thrown
1273 table.AcceptChanges ();
1275 // If row is in Deleted state, then ImportRow loads the
1276 // row and validate only on RejectChanges
1278 table.ImportRow (row);
1279 Assert.AreEqual (2, table.Rows.Count, "#3");
1280 Assert.AreEqual (DataRowState.Deleted, table.Rows[1].RowState, "#4");
1283 table.RejectChanges ();
1285 } catch (ConstraintException e) {
1290 public void ClearReset () //To test Clear and Reset methods
1292 DataTable table = new DataTable ("table");
1293 DataTable table1 = new DataTable ("table1");
1295 DataSet set = new DataSet ();
1296 set.Tables.Add (table);
1297 set.Tables.Add (table1);
1299 table.Columns.Add ("Id", typeof (int));
1300 table.Columns.Add ("Name", typeof (string));
1301 table.Constraints.Add (new UniqueConstraint ("UK1", table.Columns [0]));
1302 table.CaseSensitive = false;
1304 table1.Columns.Add ("Id", typeof (int));
1305 table1.Columns.Add ("Name", typeof (string));
1307 DataRelation dr = new DataRelation ("DR", table.Columns[0], table1.Columns[0]);
1308 set.Relations.Add (dr);
1310 DataRow row = table.NewRow ();
1312 row ["name"] = "Roopa";
1313 table.Rows.Add (row);
1315 row = table.NewRow ();
1317 row ["Name"] = "roopa";
1318 table.Rows.Add (row);
1320 Assert.AreEqual (2, table.Rows.Count);
1321 Assert.AreEqual (1, table.ChildRelations.Count);
1324 Assert.Fail ("#A01, should have thrown ArgumentException");
1326 catch (ArgumentException) {
1328 Assert.AreEqual (0, table.Rows.Count, "#CT01");
1329 Assert.AreEqual (0, table.ChildRelations.Count, "#CT02");
1330 Assert.AreEqual (0, table.ParentRelations.Count, "#CT03");
1331 Assert.AreEqual (0, table.Constraints.Count, "#CT04");
1334 Assert.AreEqual (0, table1.Rows.Count, "#A05");
1335 Assert.AreEqual (0, table1.Constraints.Count, "#A06");
1336 Assert.AreEqual (0, table1.ParentRelations.Count, "#A07");
1340 Assert.AreEqual (0, table.Rows.Count, "#A08");
1342 Assert.AreEqual (0, table.Constraints.Count, "#A09");
1344 Assert.AreEqual (1, table.Constraints.Count, "#A09");
1346 Assert.AreEqual (0, table.ChildRelations.Count, "#A10");
1351 public void ClearTest ()
1353 DataTable table = new DataTable ("test");
1354 table.Columns.Add ("id", typeof (int));
1355 table.Columns.Add ("name", typeof (string));
1357 table.PrimaryKey = new DataColumn [] { table.Columns [0] } ;
1359 table.Rows.Add (new object [] { 1, "mono 1" });
1360 table.Rows.Add (new object [] { 2, "mono 2" });
1361 table.Rows.Add (new object [] { 3, "mono 3" });
1362 table.Rows.Add (new object [] { 4, "mono 4" });
1364 table.AcceptChanges ();
1366 _tableClearedEventFired = false;
1367 table.TableCleared += new DataTableClearEventHandler (OnTableCleared);
1368 _tableClearingEventFired = false;
1369 table.TableClearing += new DataTableClearEventHandler (OnTableClearing);
1374 Assert.IsTrue (_tableClearingEventFired, "#3 should have fired cleared event");
1375 Assert.IsTrue (_tableClearedEventFired, "#0 should have fired cleared event");
1378 DataRow r = table.Rows.Find (1);
1379 Assert.IsTrue (r == null, "#1 should have cleared");
1381 // try adding new row. indexes should have cleared
1382 table.Rows.Add (new object [] { 2, "mono 2" });
1383 Assert.AreEqual (1, table.Rows.Count, "#2 should add row");
1386 private bool _tableClearedEventFired = false;
1387 private void OnTableCleared (object src, DataTableClearEventArgs args)
1389 _tableClearedEventFired = true;
1391 private bool _tableClearingEventFired = false;
1392 private void OnTableClearing (object src, DataTableClearEventArgs args)
1394 _tableClearingEventFired = true;
1396 private bool _tableNewRowAddedEventFired = false;
1397 private void OnTableNewRowAdded (object src, DataTableNewRowEventArgs args)
1399 _tableNewRowAddedEventFired = true;
1406 public void TestWriteXmlSchema1 ()
1408 DataTable dt = new DataTable("TestWriteXmlSchema");
1409 dt.Columns.Add("Col1", typeof(int));
1410 dt.Columns.Add("Col2", typeof(int));
1411 DataRow dr = dt.NewRow();
1415 DataTable dt1 = new DataTable("HelloWorld");
1416 dt1.Columns.Add("T1", typeof(int));
1417 dt1.Columns.Add("T2", typeof(int));
1418 DataRow dr1 = dt1.NewRow();
1422 TextWriter writer = new StringWriter ();
1423 dt.WriteXmlSchema (writer);
1424 string TextString = writer.ToString ();
1425 string substring = TextString.Substring (0, TextString.IndexOf(EOL));
1426 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1427 Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
1429 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1430 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1431 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");
1432 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1433 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1434 Assert.AreEqual (" <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring, "test#03");
1435 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1436 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1437 Assert.AreEqual (" <xs:complexType>", substring, "test#04");
1439 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1440 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1441 Assert.AreEqual (" <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring, "test#05");
1443 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1444 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1445 Assert.AreEqual (" <xs:element name=\"TestWriteXmlSchema\">", substring, "test#06");
1447 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1448 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1449 Assert.AreEqual (" <xs:complexType>", substring, "test#07");
1451 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1452 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1453 Assert.AreEqual (" <xs:sequence>", substring, "test#08");
1455 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1456 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1457 Assert.AreEqual (" <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#09");
1459 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1460 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1461 Assert.AreEqual (" <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#10");
1463 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1464 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1465 Assert.AreEqual (" </xs:sequence>", substring, "test#11");
1467 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1468 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1469 Assert.AreEqual (" </xs:complexType>", substring, "test#12");
1471 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1472 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1473 Assert.AreEqual (" </xs:element>", substring, "test#13");
1476 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1477 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1478 Assert.AreEqual (" </xs:choice>", substring, "test#14");
1480 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1481 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1482 Assert.AreEqual (" </xs:complexType>", substring, "test#15");
1484 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1485 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1486 Assert.AreEqual (" </xs:element>", substring, "test#16");
1487 Assert.AreEqual ("</xs:schema>", TextString, "test#17");
1490 public void TestWriteXmlSchema2()
1492 DataTable dt = new DataTable("TestWriteXmlSchema");
1493 dt.Columns.Add("Col1", typeof(int));
1494 dt.Columns.Add("Col2", typeof(int));
1495 DataRow dr = dt.NewRow();
1499 DataTable dt1 = new DataTable("HelloWorld");
1500 dt1.Columns.Add("T1", typeof(int));
1501 dt1.Columns.Add("T2", typeof(int));
1502 DataRow dr1 = dt1.NewRow();
1506 DataSet ds = new DataSet();
1509 DataRelation rel = new DataRelation("Relation1", dt.Columns["Col1"], dt1.Columns["T1"]);
1510 ds.Relations.Add(rel);
1511 TextWriter writer = new StringWriter ();
1512 dt.WriteXmlSchema (writer);
1513 string TextString = writer.ToString ();
1514 string substring = TextString.Substring (0, TextString.IndexOf(EOL));
1515 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1516 Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
1518 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1519 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1520 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");
1521 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1522 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1523 Assert.AreEqual (" <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring, "test#03");
1524 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1525 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1526 Assert.AreEqual (" <xs:complexType>", substring, "test#04");
1528 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1529 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1530 Assert.AreEqual (" <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring, "test#05");
1532 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1533 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1534 Assert.AreEqual (" <xs:element name=\"TestWriteXmlSchema\">", substring, "test#06");
1536 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1537 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1538 Assert.AreEqual (" <xs:complexType>", substring, "test#07");
1540 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1541 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1542 Assert.AreEqual (" <xs:sequence>", substring, "test#08");
1544 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1545 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1546 Assert.AreEqual (" <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#09");
1548 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1549 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1550 Assert.AreEqual (" <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#10");
1552 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1553 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1554 Assert.AreEqual (" </xs:sequence>", substring, "test#11");
1556 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1557 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1558 Assert.AreEqual (" </xs:complexType>", substring, "test#12");
1560 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1561 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1562 Assert.AreEqual (" </xs:element>", substring, "test#13");
1564 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1565 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1566 Assert.AreEqual (" </xs:choice>", substring, "test#14");
1568 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1569 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1570 Assert.AreEqual (" </xs:complexType>", substring, "test#15");
1572 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1573 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1574 Assert.AreEqual (" <xs:unique name=\"Constraint1\">", substring, "test#16");
1576 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1577 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1578 Assert.AreEqual (" <xs:selector xpath=\".//TestWriteXmlSchema\" />", substring, "test#17");
1580 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1581 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1582 Assert.AreEqual (" <xs:field xpath=\"Col1\" />", substring, "test#18");
1584 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1585 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1586 Assert.AreEqual (" </xs:unique>", substring, "test#19");
1588 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1589 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1590 Assert.AreEqual (" </xs:element>", substring, "test#20");
1591 Assert.AreEqual ("</xs:schema>", TextString, "test#21");
1594 public void TestWriteXmlSchema3()
1596 DataTable dt = new DataTable("TestWriteXmlSchema");
1597 dt.Columns.Add("Col1", typeof(int));
1598 dt.Columns.Add("Col2", typeof(int));
1599 DataRow dr = dt.NewRow();
1603 DataTable dt1 = new DataTable("HelloWorld");
1604 dt1.Columns.Add("T1", typeof(int));
1605 dt1.Columns.Add("T2", typeof(int));
1606 DataRow dr1 = dt1.NewRow();
1610 DataSet ds = new DataSet();
1613 DataRelation rel = new DataRelation("Relation1", dt.Columns["Col1"], dt1.Columns["T1"]);
1614 ds.Relations.Add(rel);
1615 TextWriter writer = new StringWriter ();
1616 dt.WriteXmlSchema (writer, true);
1617 string TextString = writer.ToString ();
1618 string substring = TextString.Substring (0, TextString.IndexOf(EOL));
1619 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1620 Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
1622 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1623 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1624 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");
1625 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1626 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1627 Assert.AreEqual (" <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring, "test#03");
1628 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1629 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1630 Assert.AreEqual (" <xs:complexType>", substring, "test#04");
1632 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1633 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1634 Assert.AreEqual (" <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring, "test#05");
1636 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1637 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1638 Assert.AreEqual (" <xs:element name=\"TestWriteXmlSchema\">", substring, "test#06");
1640 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1641 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1642 Assert.AreEqual (" <xs:complexType>", substring, "test#07");
1644 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1645 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1646 Assert.AreEqual (" <xs:sequence>", substring, "test#08");
1648 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1649 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1650 Assert.AreEqual (" <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#09");
1652 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1653 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1654 Assert.AreEqual (" <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#10");
1656 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1657 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1658 Assert.AreEqual (" </xs:sequence>", substring, "test#11");
1660 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1661 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1662 Assert.AreEqual (" </xs:complexType>", substring, "test#12");
1664 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1665 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1666 Assert.AreEqual (" </xs:element>", substring, "test#13");
1668 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1669 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1670 Assert.AreEqual (" <xs:element name=\"HelloWorld\">", substring, "test#14");
1672 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1673 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1674 Assert.AreEqual (" <xs:complexType>", substring, "test#15");
1676 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1677 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1678 Assert.AreEqual (" <xs:sequence>", substring, "test#16");
1680 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1681 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1682 Assert.AreEqual (" <xs:element name=\"T1\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#17");
1684 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1685 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1686 Assert.AreEqual (" <xs:element name=\"T2\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#18");
1688 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1689 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1690 Assert.AreEqual (" </xs:sequence>", substring, "test#19");
1692 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1693 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1694 Assert.AreEqual (" </xs:complexType>", substring, "test#20");
1696 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1697 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1698 Assert.AreEqual (" </xs:element>", substring, "test#21");
1700 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1701 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1702 Assert.AreEqual (" </xs:choice>", substring, "test#22");
1704 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1705 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1706 Assert.AreEqual (" </xs:complexType>", substring, "test#23");
1708 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1709 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1710 Assert.AreEqual (" <xs:unique name=\"Constraint1\">", substring, "test#24");
1712 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1713 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1714 Assert.AreEqual (" <xs:selector xpath=\".//TestWriteXmlSchema\" />", substring, "test#25");
1716 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1717 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1718 Assert.AreEqual (" <xs:field xpath=\"Col1\" />", substring, "test#26");
1720 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1721 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1722 Assert.AreEqual (" </xs:unique>", substring, "test#27");
1724 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1725 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1726 Assert.AreEqual (" <xs:keyref name=\"Relation1\" refer=\"Constraint1\">", substring, "test#28");
1728 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1729 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1730 Assert.AreEqual (" <xs:selector xpath=\".//HelloWorld\" />", substring, "test#29");
1732 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1733 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1734 Assert.AreEqual (" <xs:field xpath=\"T1\" />", substring, "test#30");
1736 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1737 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1738 Assert.AreEqual (" </xs:keyref>", substring, "test#31");
1740 substring = TextString.Substring (0, TextString.IndexOf(EOL));
1741 TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
1742 Assert.AreEqual (" </xs:element>", substring, "test#32");
1743 Assert.AreEqual ("</xs:schema>", TextString, "test#33");
1747 public void Serialize ()
1749 MemoryStream fs = new MemoryStream ();
1751 // Construct a BinaryFormatter and use it
1752 // to serialize the data to the stream.
1753 BinaryFormatter formatter = new BinaryFormatter();
1755 // Create an array with multiple elements refering to
1756 // the one Singleton object.
1757 DataTable dt = new DataTable();
1760 dt.Columns.Add(new DataColumn("Id", typeof(string)));
1761 dt.Columns.Add(new DataColumn("ContactName", typeof(string)));
1762 dt.Columns.Add(new DataColumn("ContactTitle", typeof(string)));
1763 dt.Columns.Add(new DataColumn("ContactAreaCode", typeof(string)));
1764 dt.Columns.Add(new DataColumn("ContactPhone", typeof(string)));
1767 loRowToAdd = dt.NewRow();
1768 loRowToAdd[0] = "a";
1769 loRowToAdd[1] = "b";
1770 loRowToAdd[2] = "c";
1771 loRowToAdd[3] = "d";
1772 loRowToAdd[4] = "e";
1774 dt.Rows.Add(loRowToAdd);
1776 DataTable[] dtarr = new DataTable[] {dt};
1778 // Serialize the array elements.
1779 formatter.Serialize(fs, dtarr);
1781 // Deserialize the array elements.
1783 DataTable[] a2 = (DataTable[]) formatter.Deserialize(fs);
1785 DataSet ds = new DataSet();
1786 ds.Tables.Add(a2[0]);
1788 StringWriter sw = new StringWriter ();
1790 XmlDocument doc = new XmlDocument ();
1791 doc.LoadXml (sw.ToString ());
1792 Assert.AreEqual (5, doc.DocumentElement.FirstChild.ChildNodes.Count);
1796 [ExpectedException (typeof (DataException))]
1797 public void SetPrimaryKeyAssertsNonNull ()
1799 DataTable dt = new DataTable ("table");
1800 dt.Columns.Add ("col1");
1801 dt.Columns.Add ("col2");
1802 dt.Constraints.Add (new UniqueConstraint (dt.Columns [0]));
1803 dt.Rows.Add (new object [] {1, 3});
1804 dt.Rows.Add (new object [] {DBNull.Value, 3});
1806 dt.PrimaryKey = new DataColumn [] {dt.Columns [0]};
1810 [ExpectedException (typeof (NoNullAllowedException))]
1811 public void PrimaryKeyColumnChecksNonNull ()
1813 DataTable dt = new DataTable ("table");
1814 dt.Columns.Add ("col1");
1815 dt.Columns.Add ("col2");
1816 dt.Constraints.Add (new UniqueConstraint (dt.Columns [0]));
1817 dt.PrimaryKey = new DataColumn [] {dt.Columns [0]};
1818 dt.Rows.Add (new object [] {1, 3});
1819 dt.Rows.Add (new object [] {DBNull.Value, 3});
1823 public void PrimaryKey_CheckSetsAllowDBNull ()
1825 DataTable table = new DataTable ();
1826 DataColumn col1 = table.Columns.Add ("col1", typeof (int));
1827 DataColumn col2 = table.Columns.Add ("col2", typeof (int));
1829 Assert.IsTrue (col1.AllowDBNull, "#1" );
1830 Assert.IsTrue (col2.AllowDBNull, "#2" );
1831 Assert.IsFalse (col2.Unique, "#3" );
1832 Assert.IsFalse (col2.Unique, "#4" );
1834 table.PrimaryKey = new DataColumn[] {col1,col2};
1835 Assert.IsFalse (col1.AllowDBNull, "#5" );
1836 Assert.IsFalse (col2.AllowDBNull, "#6" );
1837 // LAMESPEC or bug ??
1838 Assert.IsFalse (col1.Unique, "#7" );
1839 Assert.IsFalse (col2.Unique, "#8" );
1842 void RowChanging (object o, DataRowChangeEventArgs e)
1844 Assert.AreEqual (rowChangingExpectedAction, e.Action, "changing.Action");
1845 rowChangingRowChanging = true;
1848 void RowChanged (object o, DataRowChangeEventArgs e)
1850 Assert.AreEqual (rowChangingExpectedAction, e.Action, "changed.Action");
1851 rowChangingRowChanged = true;
1854 bool rowChangingRowChanging, rowChangingRowChanged;
1855 DataRowAction rowChangingExpectedAction;
1858 public void RowChanging ()
1860 DataTable dt = new DataTable ("table");
1861 dt.Columns.Add ("col1");
1862 dt.Columns.Add ("col2");
1863 dt.RowChanging += new DataRowChangeEventHandler (RowChanging);
1864 dt.RowChanged += new DataRowChangeEventHandler (RowChanged);
1865 rowChangingExpectedAction = DataRowAction.Add;
1866 dt.Rows.Add (new object [] {1, 2});
1867 Assert.IsTrue (rowChangingRowChanging, "changing,Added");
1868 Assert.IsTrue (rowChangingRowChanged, "changed,Added");
1869 rowChangingExpectedAction = DataRowAction.Change;
1870 dt.Rows [0] [0] = 2;
1871 Assert.IsTrue (rowChangingRowChanging, "changing,Changed");
1872 Assert.IsTrue (rowChangingRowChanged, "changed,Changed");
1876 public void CloneSubClassTest()
1878 MyDataTable dt1 = new MyDataTable();
1879 MyDataTable dt = (MyDataTable)(dt1.Clone());
1880 Assert.AreEqual (2, MyDataTable.count, "A#01");
1883 DataRowAction rowActionChanging = DataRowAction.Nothing;
1884 DataRowAction rowActionChanged = DataRowAction.Nothing;
1886 public void AcceptChangesTest ()
1888 DataTable dt = new DataTable ("test");
1889 dt.Columns.Add ("id", typeof (int));
1890 dt.Columns.Add ("name", typeof (string));
1892 dt.Rows.Add (new object [] { 1, "mono 1" });
1894 dt.RowChanged += new DataRowChangeEventHandler (OnRowChanged);
1895 dt.RowChanging += new DataRowChangeEventHandler (OnRowChanging);
1898 rowActionChanged = rowActionChanging = DataRowAction.Nothing;
1899 dt.AcceptChanges ();
1901 Assert.AreEqual (DataRowAction.Commit, rowActionChanging,
1902 "#1 should have fired event and set action to commit");
1903 Assert.AreEqual (DataRowAction.Commit, rowActionChanged,
1904 "#2 should have fired event and set action to commit");
1907 dt.RowChanged -= new DataRowChangeEventHandler (OnRowChanged);
1908 dt.RowChanging -= new DataRowChangeEventHandler (OnRowChanging);
1914 public void ColumnObjectTypeTest() {
1915 DataTable dt = new DataTable();
1916 dt.Columns.Add("Series Label", typeof(SqlInt32));
1917 dt.Rows.Add(new object[] {"sss"});
1918 Assert.AreEqual (1, dt.Rows.Count);
1922 private bool tableInitialized;
1924 public void TableInitializedEventTest1 () {
1925 DataTable dt = new DataTable();
1926 tableInitialized = false;
1927 dt.Initialized += new EventHandler (OnTableInitialized);
1928 dt.Columns.Add("Series Label", typeof(SqlInt32));
1929 dt.Rows.Add(new object[] {"sss"});
1930 Assert.IsFalse (tableInitialized, "TableInitialized #01");
1931 dt.Initialized -= new EventHandler (OnTableInitialized);
1934 public void TableInitializedEventTest2 () {
1935 DataTable dt = new DataTable();
1937 tableInitialized = false;
1938 dt.Initialized += new EventHandler (OnTableInitialized);
1939 dt.Columns.Add("Series Label", typeof(SqlInt32));
1940 dt.Rows.Add(new object[] {"sss"});
1942 dt.Initialized -= new EventHandler (OnTableInitialized);
1943 Assert.IsTrue (tableInitialized, "TableInitialized #02");
1946 public void TableInitializedEventTest3 () {
1947 DataTable dt = new DataTable();
1948 tableInitialized = true;
1949 dt.Initialized += new EventHandler (OnTableInitialized);
1950 dt.Columns.Add("Series Label", typeof(SqlInt32));
1951 dt.Rows.Add(new object[] {"sss"});
1952 Assert.AreEqual (tableInitialized, dt.IsInitialized, "TableInitialized #03");
1953 dt.Initialized -= new EventHandler (OnTableInitialized);
1956 public void TableInitializedEventTest4 () {
1957 DataTable dt = new DataTable();
1958 Assert.IsTrue (dt.IsInitialized, "TableInitialized #04");
1960 tableInitialized = false;
1961 dt.Initialized += new EventHandler (OnTableInitialized);
1962 dt.Columns.Add("Series Label", typeof(SqlInt32));
1963 dt.Rows.Add(new object[] {"sss"});
1964 Assert.IsFalse (dt.IsInitialized, "TableInitialized #05");
1966 Assert.IsTrue (dt.IsInitialized, "TableInitialized #06");
1967 Assert.IsTrue (tableInitialized, "TableInitialized #07");
1968 dt.Initialized -= new EventHandler (OnTableInitialized);
1971 private void OnTableInitialized (object src, EventArgs args)
1973 tableInitialized = true;
1978 public void OnRowChanging (object src, DataRowChangeEventArgs args)
1980 rowActionChanging = args.Action;
1983 public void OnRowChanged (object src, DataRowChangeEventArgs args)
1985 rowActionChanged = args.Action;
1989 private DataTable dt;
1990 private void localSetup () {
1991 dt = new DataTable ("test");
1992 dt.Columns.Add ("id", typeof (int));
1993 dt.Columns.Add ("name", typeof (string));
1994 dt.PrimaryKey = new DataColumn[] { dt.Columns["id"] };
1996 dt.Rows.Add (new object[] { 1, "mono 1" });
1997 dt.Rows.Add (new object[] { 2, "mono 2" });
1998 dt.Rows.Add (new object[] { 3, "mono 3" });
2000 dt.AcceptChanges ();
2003 #region DataTable.CreateDataReader Tests
2006 public void CreateDataReader1 () {
2008 DataTableReader dtr = dt.CreateDataReader ();
2009 Assert.IsTrue (dtr.HasRows, "HasRows");
2010 Assert.AreEqual (dt.Columns.Count, dtr.FieldCount, "CountCols");
2012 while (dtr.Read ()) {
2013 for (int i = 0; i < dtr.FieldCount; i++) {
2014 Assert.AreEqual (dt.Rows[ri][i], dtr[i], "RowData-" + ri + "-" + i);
2021 public void CreateDataReader2 () {
2023 DataTableReader dtr = dt.CreateDataReader ();
2024 Assert.IsTrue (dtr.HasRows, "HasRows");
2025 Assert.AreEqual (dt.Columns.Count, dtr.FieldCount, "CountCols");
2027 Assert.AreEqual (1, dtr[0], "RowData0-0");
2028 Assert.AreEqual ("mono 1", dtr[1], "RowData0-1");
2030 Assert.AreEqual (2, dtr[0], "RowData1-0");
2031 Assert.AreEqual ("mono 2", dtr[1], "RowData1-1");
2033 Assert.AreEqual (3, dtr[0], "RowData2-0");
2034 Assert.AreEqual ("mono 3", dtr[1], "RowData2-1");
2037 #endregion // DataTable.CreateDataReader Tests
2039 #region DataTable.Load Tests
2042 public void Load_Basic () {
2044 DataTable dtLoad = new DataTable ("LoadBasic");
2045 dtLoad.Columns.Add ("id", typeof (int));
2046 dtLoad.Columns.Add ("name", typeof (string));
2047 dtLoad.Columns["id"].ReadOnly = true;
2048 dtLoad.Columns["name"].ReadOnly = true;
2049 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2050 dtLoad.Rows.Add (new object[] { 1, "load 1" });
2051 dtLoad.Rows.Add (new object[] { 2, "load 2" });
2052 dtLoad.Rows.Add (new object[] { 3, "load 3" });
2053 dtLoad.AcceptChanges ();
2054 DataTableReader dtr = dt.CreateDataReader ();
2056 Assert.AreEqual (2, dtLoad.Columns.Count, "NColumns");
2057 Assert.AreEqual (3, dtLoad.Rows.Count, "NRows");
2058 Assert.AreEqual (1, dtLoad.Rows[0][0], "RowData0-0");
2059 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1], "RowData0-1");
2060 Assert.AreEqual (2, dtLoad.Rows[1][0], "RowData1-0");
2061 Assert.AreEqual ("mono 2", dtLoad.Rows[1][1], "RowData1-1");
2062 Assert.AreEqual (3, dtLoad.Rows[2][0], "RowData2-0");
2063 Assert.AreEqual ("mono 3", dtLoad.Rows[2][1], "RowData2-1");
2067 public void Load_NoSchema () {
2069 DataTable dtLoad = new DataTable ("LoadNoSchema");
2070 DataTableReader dtr = dt.CreateDataReader ();
2072 Assert.AreEqual (2, dtLoad.Columns.Count, "NColumns");
2073 Assert.AreEqual (3, dtLoad.Rows.Count, "NRows");
2074 Assert.AreEqual (1, dtLoad.Rows[0][0], "RowData0-0");
2075 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1], "RowData0-1");
2076 Assert.AreEqual (2, dtLoad.Rows[1][0], "RowData1-0");
2077 Assert.AreEqual ("mono 2", dtLoad.Rows[1][1], "RowData1-1");
2078 Assert.AreEqual (3, dtLoad.Rows[2][0], "RowData2-0");
2079 Assert.AreEqual ("mono 3", dtLoad.Rows[2][1], "RowData2-1");
2082 internal struct fillErrorStruct {
2083 internal string error;
2084 internal string tableName;
2085 internal int rowKey;
2086 internal bool contFlag;
2087 internal void init (string tbl, int row, bool cont, string err) {
2094 private fillErrorStruct[] fillErr = new fillErrorStruct[3];
2095 private int fillErrCounter;
2096 private void fillErrorHandler (object sender, FillErrorEventArgs e) {
2097 e.Continue = fillErr[fillErrCounter].contFlag;
2098 Assert.AreEqual (fillErr[fillErrCounter].tableName, e.DataTable.TableName, "fillErr-T");
2099 //Assert.AreEqual (fillErr[fillErrCounter].rowKey, e.Values[0], "fillErr-R");
2100 Assert.AreEqual (fillErr[fillErrCounter].contFlag, e.Continue, "fillErr-C");
2101 //Assert.AreEqual (fillErr[fillErrCounter].error, e.Errors.Message, "fillErr-E");
2106 [ExpectedException (typeof (ArgumentException))]
2107 public void Load_Incompatible () {
2109 DataTable dtLoad = new DataTable ("LoadIncompatible");
2110 dtLoad.Columns.Add ("name", typeof (double));
2111 DataTableReader dtr = dt.CreateDataReader ();
2115 // Load doesn't have a third overload in System.Data
2116 // and is commented-out below
2117 public void Load_IncompatibleEHandlerT () {
2119 fillErr[0].init ("LoadIncompatible", 1, true,
2120 "Input string was not in a correct format.Couldn't store <mono 1> in name Column. Expected type is Double.");
2121 fillErr[1].init ("LoadIncompatible", 2, true,
2122 "Input string was not in a correct format.Couldn't store <mono 2> in name Column. Expected type is Double.");
2123 fillErr[2].init ("LoadIncompatible", 3, true,
2124 "Input string was not in a correct format.Couldn't store <mono 3> in name Column. Expected type is Double.");
2126 DataTable dtLoad = new DataTable ("LoadIncompatible");
2127 dtLoad.Columns.Add ("name", typeof (double));
2128 DataTableReader dtr = dt.CreateDataReader ();
2129 dtLoad.Load (dtr,LoadOption.PreserveChanges,fillErrorHandler);
2132 // Load doesn't have a third overload in System.Data
2133 // and is commented-out below
2134 [ExpectedException (typeof (ArgumentException))]
2135 public void Load_IncompatibleEHandlerF () {
2137 fillErr[0].init ("LoadIncompatible", 1, false,
2138 "Input string was not in a correct format.Couldn't store <mono 1> in name Column. Expected type is Double.");
2140 DataTable dtLoad = new DataTable ("LoadIncompatible");
2141 dtLoad.Columns.Add ("name", typeof (double));
2142 DataTableReader dtr = dt.CreateDataReader ();
2143 dtLoad.Load (dtr, LoadOption.PreserveChanges, fillErrorHandler);
2147 public void Load_ExtraColsEqualVal () {
2149 DataTable dtLoad = new DataTable ("LoadExtraCols");
2150 dtLoad.Columns.Add ("id", typeof (int));
2151 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2152 dtLoad.Rows.Add (new object[] { 1 });
2153 dtLoad.Rows.Add (new object[] { 2 });
2154 dtLoad.Rows.Add (new object[] { 3 });
2155 dtLoad.AcceptChanges ();
2156 DataTableReader dtr = dt.CreateDataReader ();
2158 Assert.AreEqual (2, dtLoad.Columns.Count, "NColumns");
2159 Assert.AreEqual (3, dtLoad.Rows.Count, "NRows");
2160 Assert.AreEqual (1, dtLoad.Rows[0][0], "RowData0-0");
2161 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1], "RowData0-1");
2162 Assert.AreEqual (2, dtLoad.Rows[1][0], "RowData1-0");
2163 Assert.AreEqual ("mono 2", dtLoad.Rows[1][1], "RowData1-1");
2164 Assert.AreEqual (3, dtLoad.Rows[2][0], "RowData2-0");
2165 Assert.AreEqual ("mono 3", dtLoad.Rows[2][1], "RowData2-1");
2169 public void Load_ExtraColsNonEqualVal () {
2171 DataTable dtLoad = new DataTable ("LoadExtraCols");
2172 dtLoad.Columns.Add ("id", typeof (int));
2173 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2174 dtLoad.Rows.Add (new object[] { 4 });
2175 dtLoad.Rows.Add (new object[] { 5 });
2176 dtLoad.Rows.Add (new object[] { 6 });
2177 dtLoad.AcceptChanges ();
2178 DataTableReader dtr = dt.CreateDataReader ();
2180 Assert.AreEqual (2, dtLoad.Columns.Count, "NColumns");
2181 Assert.AreEqual (6, dtLoad.Rows.Count, "NRows");
2182 Assert.AreEqual (4, dtLoad.Rows[0][0], "RowData0-0");
2183 Assert.AreEqual (5, dtLoad.Rows[1][0], "RowData1-0");
2184 Assert.AreEqual (6, dtLoad.Rows[2][0], "RowData2-0");
2185 Assert.AreEqual (1, dtLoad.Rows[3][0], "RowData3-0");
2186 Assert.AreEqual ("mono 1", dtLoad.Rows[3][1], "RowData3-1");
2187 Assert.AreEqual (2, dtLoad.Rows[4][0], "RowData4-0");
2188 Assert.AreEqual ("mono 2", dtLoad.Rows[4][1], "RowData4-1");
2189 Assert.AreEqual (3, dtLoad.Rows[5][0], "RowData5-0");
2190 Assert.AreEqual ("mono 3", dtLoad.Rows[5][1], "RowData5-1");
2194 [ExpectedException (typeof (ConstraintException))]
2195 public void Load_MissingColsNonNullable () {
2197 DataTable dtLoad = new DataTable ("LoadMissingCols");
2198 dtLoad.Columns.Add ("id", typeof (int));
2199 dtLoad.Columns.Add ("name", typeof (string));
2200 dtLoad.Columns.Add ("missing", typeof (string));
2201 dtLoad.Columns["missing"].AllowDBNull = false;
2202 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2203 dtLoad.Rows.Add (new object[] { 4, "mono 4", "miss4" });
2204 dtLoad.Rows.Add (new object[] { 5, "mono 5", "miss5" });
2205 dtLoad.Rows.Add (new object[] { 6, "mono 6", "miss6" });
2206 dtLoad.AcceptChanges ();
2207 DataTableReader dtr = dt.CreateDataReader ();
2212 public void Load_MissingColsDefault () {
2214 DataTable dtLoad = new DataTable ("LoadMissingCols");
2215 dtLoad.Columns.Add ("id", typeof (int));
2216 dtLoad.Columns.Add ("name", typeof (string));
2217 dtLoad.Columns.Add ("missing", typeof (string));
2218 dtLoad.Columns["missing"].AllowDBNull = false;
2219 dtLoad.Columns["missing"].DefaultValue = "DefaultValue";
2220 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2221 dtLoad.Rows.Add (new object[] { 4, "mono 4", "miss4" });
2222 dtLoad.Rows.Add (new object[] { 5, "mono 5", "miss5" });
2223 dtLoad.Rows.Add (new object[] { 6, "mono 6", "miss6" });
2224 dtLoad.AcceptChanges ();
2225 DataTableReader dtr = dt.CreateDataReader ();
2227 Assert.AreEqual (3, dtLoad.Columns.Count, "NColumns");
2228 Assert.AreEqual (6, dtLoad.Rows.Count, "NRows");
2229 Assert.AreEqual (4, dtLoad.Rows[0][0], "RowData0-0");
2230 Assert.AreEqual ("mono 4", dtLoad.Rows[0][1], "RowData0-1");
2231 Assert.AreEqual ("miss4", dtLoad.Rows[0][2], "RowData0-2");
2232 Assert.AreEqual (5, dtLoad.Rows[1][0], "RowData1-0");
2233 Assert.AreEqual ("mono 5", dtLoad.Rows[1][1], "RowData1-1");
2234 Assert.AreEqual ("miss5", dtLoad.Rows[1][2], "RowData1-2");
2235 Assert.AreEqual (6, dtLoad.Rows[2][0], "RowData2-0");
2236 Assert.AreEqual ("mono 6", dtLoad.Rows[2][1], "RowData2-1");
2237 Assert.AreEqual ("miss6", dtLoad.Rows[2][2], "RowData2-2");
2238 Assert.AreEqual (1, dtLoad.Rows[3][0], "RowData3-0");
2239 Assert.AreEqual ("mono 1", dtLoad.Rows[3][1], "RowData3-1");
2240 Assert.AreEqual ("DefaultValue", dtLoad.Rows[3][2], "RowData3-2");
2241 Assert.AreEqual (2, dtLoad.Rows[4][0], "RowData4-0");
2242 Assert.AreEqual ("mono 2", dtLoad.Rows[4][1], "RowData4-1");
2243 Assert.AreEqual ("DefaultValue", dtLoad.Rows[4][2], "RowData4-2");
2244 Assert.AreEqual (3, dtLoad.Rows[5][0], "RowData5-0");
2245 Assert.AreEqual ("mono 3", dtLoad.Rows[5][1], "RowData5-1");
2246 Assert.AreEqual ("DefaultValue", dtLoad.Rows[5][2], "RowData5-2");
2250 public void Load_MissingColsNullable () {
2252 DataTable dtLoad = new DataTable ("LoadMissingCols");
2253 dtLoad.Columns.Add ("id", typeof (int));
2254 dtLoad.Columns.Add ("name", typeof (string));
2255 dtLoad.Columns.Add ("missing", typeof (string));
2256 dtLoad.Columns["missing"].AllowDBNull = true;
2257 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2258 dtLoad.Rows.Add (new object[] { 4, "mono 4", "miss4" });
2259 dtLoad.Rows.Add (new object[] { 5, "mono 5", "miss5" });
2260 dtLoad.Rows.Add (new object[] { 6, "mono 6", "miss6" });
2261 dtLoad.AcceptChanges ();
2262 DataTableReader dtr = dt.CreateDataReader ();
2264 Assert.AreEqual (3, dtLoad.Columns.Count, "NColumns");
2265 Assert.AreEqual (6, dtLoad.Rows.Count, "NRows");
2266 Assert.AreEqual (4, dtLoad.Rows[0][0], "RowData0-0");
2267 Assert.AreEqual ("mono 4", dtLoad.Rows[0][1], "RowData0-1");
2268 Assert.AreEqual ("miss4", dtLoad.Rows[0][2], "RowData0-2");
2269 Assert.AreEqual (5, dtLoad.Rows[1][0], "RowData1-0");
2270 Assert.AreEqual ("mono 5", dtLoad.Rows[1][1], "RowData1-1");
2271 Assert.AreEqual ("miss5", dtLoad.Rows[1][2], "RowData1-2");
2272 Assert.AreEqual (6, dtLoad.Rows[2][0], "RowData2-0");
2273 Assert.AreEqual ("mono 6", dtLoad.Rows[2][1], "RowData2-1");
2274 Assert.AreEqual ("miss6", dtLoad.Rows[2][2], "RowData2-2");
2275 Assert.AreEqual (1, dtLoad.Rows[3][0], "RowData3-0");
2276 Assert.AreEqual ("mono 1", dtLoad.Rows[3][1], "RowData3-1");
2277 //Assert.IsNull (dtLoad.Rows[3][2], "RowData3-2");
2278 Assert.AreEqual (2, dtLoad.Rows[4][0], "RowData4-0");
2279 Assert.AreEqual ("mono 2", dtLoad.Rows[4][1], "RowData4-1");
2280 //Assert.IsNull (dtLoad.Rows[4][2], "RowData4-2");
2281 Assert.AreEqual (3, dtLoad.Rows[5][0], "RowData5-0");
2282 Assert.AreEqual ("mono 3", dtLoad.Rows[5][1], "RowData5-1");
2283 //Assert.IsNull (dtLoad.Rows[5][2], "RowData5-2");
2286 private DataTable setupRowState () {
2287 DataTable tbl = new DataTable ("LoadRowStateChanges");
2288 tbl.RowChanged += new DataRowChangeEventHandler (dtLoad_RowChanged);
2289 tbl.RowChanging += new DataRowChangeEventHandler (dtLoad_RowChanging);
2290 tbl.Columns.Add ("id", typeof (int));
2291 tbl.Columns.Add ("name", typeof (string));
2292 tbl.PrimaryKey = new DataColumn[] { tbl.Columns["id"] };
2293 tbl.Rows.Add (new object[] { 1, "RowState 1" });
2294 tbl.Rows.Add (new object[] { 2, "RowState 2" });
2295 tbl.Rows.Add (new object[] { 3, "RowState 3" });
2296 tbl.AcceptChanges ();
2297 // Update Table with following changes: Row0 unmodified,
2298 // Row1 modified, Row2 deleted, Row3 added, Row4 not-present.
2299 tbl.Rows[1]["name"] = "Modify 2";
2300 tbl.Rows[2].Delete ();
2301 DataRow row = tbl.NewRow ();
2303 row["name"] = "Add 4";
2308 private DataRowAction[] rowChangeAction = new DataRowAction[5];
2309 private bool checkAction = false;
2310 private int rowChagedCounter, rowChangingCounter;
2311 private void rowActionInit (DataRowAction[] act) {
2313 rowChagedCounter = 0;
2314 rowChangingCounter = 0;
2315 for (int i = 0; i < 5; i++)
2316 rowChangeAction[i] = act[i];
2318 private void rowActionEnd () {
2319 checkAction = false;
2321 private void dtLoad_RowChanged (object sender, DataRowChangeEventArgs e) {
2323 Assert.AreEqual (rowChangeAction[rowChagedCounter], e.Action, "RowChanged" + rowChagedCounter);
2327 private void dtLoad_RowChanging (object sender, DataRowChangeEventArgs e) {
2329 Assert.AreEqual (rowChangeAction[rowChangingCounter], e.Action, "RowChanging" + rowChangingCounter);
2330 rowChangingCounter++;
2335 public void Load_RowStateChangesDefault () {
2337 dt.Rows.Add (new object[] { 4, "mono 4" });
2338 dt.Rows.Add (new object[] { 5, "mono 5" });
2339 dt.AcceptChanges ();
2340 DataTableReader dtr = dt.CreateDataReader ();
2341 DataTable dtLoad = setupRowState ();
2342 DataRowAction[] dra = new DataRowAction[] {
2343 DataRowAction.ChangeCurrentAndOriginal,
2344 DataRowAction.ChangeOriginal,
2345 DataRowAction.ChangeOriginal,
2346 DataRowAction.ChangeOriginal,
2347 DataRowAction.ChangeCurrentAndOriginal};
2348 rowActionInit (dra);
2351 // asserting Unchanged Row0
2352 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1,DataRowVersion.Current], "RowData0-C");
2353 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1,DataRowVersion.Original], "RowData0-O");
2354 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[0].RowState, "RowState0");
2355 // asserting Modified Row1
2356 Assert.AreEqual ("Modify 2", dtLoad.Rows[1][1, DataRowVersion.Current], "RowData1-C");
2357 Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Original], "RowData1-O");
2358 Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[1].RowState, "RowState1");
2359 // asserting Deleted Row2
2360 Assert.AreEqual ("mono 3", dtLoad.Rows[2][1, DataRowVersion.Original], "RowData1-O");
2361 Assert.AreEqual (DataRowState.Deleted, dtLoad.Rows[2].RowState, "RowState2");
2362 // asserting Added Row3
2363 Assert.AreEqual ("Add 4", dtLoad.Rows[3][1, DataRowVersion.Current], "RowData3-C");
2364 Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2365 Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[3].RowState, "RowState3");
2366 // asserting Unpresent Row4
2367 Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Current], "RowData4-C");
2368 Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Original], "RowData4-O");
2369 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[4].RowState, "RowState4");
2373 [ExpectedException (typeof (VersionNotFoundException))]
2374 public void Load_RowStateChangesDefaultDelete () {
2376 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2377 dtLoad.Columns.Add ("id", typeof (int));
2378 dtLoad.Columns.Add ("name", typeof (string));
2379 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2380 dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2381 dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2382 dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2383 dtLoad.AcceptChanges ();
2384 dtLoad.Rows[2].Delete ();
2385 DataTableReader dtr = dt.CreateDataReader ();
2387 Assert.AreEqual (" ", dtLoad.Rows[2][1, DataRowVersion.Current], "RowData2-C");
2391 public void Load_RowStatePreserveChanges () {
2393 dt.Rows.Add (new object[] { 4, "mono 4" });
2394 dt.Rows.Add (new object[] { 5, "mono 5" });
2395 dt.AcceptChanges ();
2396 DataTableReader dtr = dt.CreateDataReader ();
2397 DataTable dtLoad = setupRowState ();
2398 DataRowAction[] dra = new DataRowAction[] {
2399 DataRowAction.ChangeCurrentAndOriginal,
2400 DataRowAction.ChangeOriginal,
2401 DataRowAction.ChangeOriginal,
2402 DataRowAction.ChangeOriginal,
2403 DataRowAction.ChangeCurrentAndOriginal};
2404 rowActionInit (dra);
2405 dtLoad.Load (dtr, LoadOption.PreserveChanges);
2407 // asserting Unchanged Row0
2408 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Current], "RowData0-C");
2409 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Original], "RowData0-O");
2410 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[0].RowState, "RowState0");
2411 // asserting Modified Row1
2412 Assert.AreEqual ("Modify 2", dtLoad.Rows[1][1, DataRowVersion.Current], "RowData1-C");
2413 Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Original], "RowData1-O");
2414 Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[1].RowState, "RowState1");
2415 // asserting Deleted Row2
2416 Assert.AreEqual ("mono 3", dtLoad.Rows[2][1, DataRowVersion.Original], "RowData1-O");
2417 Assert.AreEqual (DataRowState.Deleted, dtLoad.Rows[2].RowState, "RowState2");
2418 // asserting Added Row3
2419 Assert.AreEqual ("Add 4", dtLoad.Rows[3][1, DataRowVersion.Current], "RowData3-C");
2420 Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2421 Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[3].RowState, "RowState3");
2422 // asserting Unpresent Row4
2423 Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Current], "RowData4-C");
2424 Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Original], "RowData4-O");
2425 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[4].RowState, "RowState4");
2429 [ExpectedException (typeof (VersionNotFoundException))]
2430 public void Load_RowStatePreserveChangesDelete () {
2432 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2433 dtLoad.Columns.Add ("id", typeof (int));
2434 dtLoad.Columns.Add ("name", typeof (string));
2435 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2436 dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2437 dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2438 dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2439 dtLoad.AcceptChanges ();
2440 dtLoad.Rows[2].Delete ();
2441 DataTableReader dtr = dt.CreateDataReader ();
2442 dtLoad.Load (dtr,LoadOption.PreserveChanges);
2443 Assert.AreEqual (" ", dtLoad.Rows[2][1, DataRowVersion.Current], "RowData2-C");
2447 public void Load_RowStateOverwriteChanges () {
2449 dt.Rows.Add (new object[] { 4, "mono 4" });
2450 dt.Rows.Add (new object[] { 5, "mono 5" });
2451 dt.AcceptChanges ();
2452 DataTableReader dtr = dt.CreateDataReader ();
2453 DataTable dtLoad = setupRowState ();
2454 DataRowAction[] dra = new DataRowAction[] {
2455 DataRowAction.ChangeCurrentAndOriginal,
2456 DataRowAction.ChangeCurrentAndOriginal,
2457 DataRowAction.ChangeCurrentAndOriginal,
2458 DataRowAction.ChangeCurrentAndOriginal,
2459 DataRowAction.ChangeCurrentAndOriginal};
2460 rowActionInit (dra);
2461 dtLoad.Load (dtr, LoadOption.OverwriteChanges);
2463 // asserting Unchanged Row0
2464 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Current], "RowData0-C");
2465 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Original], "RowData0-O");
2466 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[0].RowState, "RowState0");
2467 // asserting Modified Row1
2468 Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Current], "RowData1-C");
2469 Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Original], "RowData1-O");
2470 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[1].RowState, "RowState1");
2471 // asserting Deleted Row2
2472 Assert.AreEqual ("mono 3", dtLoad.Rows[2][1, DataRowVersion.Current], "RowData1-C");
2473 Assert.AreEqual ("mono 3", dtLoad.Rows[2][1, DataRowVersion.Original], "RowData1-O");
2474 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[2].RowState, "RowState2");
2475 // asserting Added Row3
2476 Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Current], "RowData3-C");
2477 Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2478 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[3].RowState, "RowState3");
2479 // asserting Unpresent Row4
2480 Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Current], "RowData4-C");
2481 Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Original], "RowData4-O");
2482 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[4].RowState, "RowState4");
2486 public void Load_RowStateUpsert () {
2488 dt.Rows.Add (new object[] { 4, "mono 4" });
2489 dt.Rows.Add (new object[] { 5, "mono 5" });
2490 dt.AcceptChanges ();
2491 DataTableReader dtr = dt.CreateDataReader ();
2492 DataTable dtLoad = setupRowState ();
2493 // Notice rowChange-Actions only occur 5 times, as number
2494 // of actual rows, ignoring row duplication of the deleted row.
2495 DataRowAction[] dra = new DataRowAction[] {
2496 DataRowAction.Change,
2497 DataRowAction.Change,
2499 DataRowAction.Change,
2501 rowActionInit (dra);
2502 dtLoad.Load (dtr, LoadOption.Upsert);
2504 // asserting Unchanged Row0
2505 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Current], "RowData0-C");
2506 Assert.AreEqual ("RowState 1", dtLoad.Rows[0][1, DataRowVersion.Original], "RowData0-O");
2507 Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[0].RowState, "RowState0");
2508 // asserting Modified Row1
2509 Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Current], "RowData1-C");
2510 Assert.AreEqual ("RowState 2", dtLoad.Rows[1][1, DataRowVersion.Original], "RowData1-O");
2511 Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[1].RowState, "RowState1");
2512 // asserting Deleted Row2 and "Deleted-Added" Row4
2513 Assert.AreEqual ("RowState 3", dtLoad.Rows[2][1, DataRowVersion.Original], "RowData2-O");
2514 Assert.AreEqual (DataRowState.Deleted, dtLoad.Rows[2].RowState, "RowState2");
2515 Assert.AreEqual ("mono 3", dtLoad.Rows[4][1, DataRowVersion.Current], "RowData4-C");
2516 Assert.AreEqual (DataRowState.Added, dtLoad.Rows[4].RowState, "RowState4");
2517 // asserting Added Row3
2518 Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Current], "RowData3-C");
2519 Assert.AreEqual (DataRowState.Added, dtLoad.Rows[3].RowState, "RowState3");
2520 // asserting Unpresent Row5
2521 // Notice row4 is used for added row of deleted row2 and so
2522 // unpresent row4 moves to row5
2523 Assert.AreEqual ("mono 5", dtLoad.Rows[5][1, DataRowVersion.Current], "RowData5-C");
2524 Assert.AreEqual (DataRowState.Added, dtLoad.Rows[5].RowState, "RowState5");
2528 public void Load_RowStateUpsertDuplicateKey1 () {
2530 dt.Rows.Add (new object[] { 4, "mono 4" });
2531 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2532 dtLoad.Columns.Add ("id", typeof (int));
2533 dtLoad.Columns.Add ("name", typeof (string));
2534 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2535 dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2536 dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2537 dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2538 dtLoad.AcceptChanges ();
2539 dtLoad.Rows[2].Delete ();
2540 DataTableReader dtr = dt.CreateDataReader ();
2541 dtLoad.Load (dtr, LoadOption.Upsert);
2542 dtLoad.Rows[3][1] = "NEWVAL";
2543 Assert.AreEqual (DataRowState.Deleted, dtLoad.Rows[2].RowState, "A-RowState2");
2544 Assert.AreEqual (3, dtLoad.Rows[2][0, DataRowVersion.Original], "A-RowData2-id");
2545 Assert.AreEqual ("RowState 3", dtLoad.Rows[2][1, DataRowVersion.Original], "A-RowData2-name");
2546 Assert.AreEqual (DataRowState.Added, dtLoad.Rows[3].RowState, "A-RowState3");
2547 Assert.AreEqual (3, dtLoad.Rows[3][0, DataRowVersion.Current], "A-RowData3-id");
2548 Assert.AreEqual ("NEWVAL", dtLoad.Rows[3][1, DataRowVersion.Current], "A-RowData3-name");
2549 Assert.AreEqual (DataRowState.Added, dtLoad.Rows[4].RowState, "A-RowState4");
2550 Assert.AreEqual (4, dtLoad.Rows[4][0, DataRowVersion.Current], "A-RowData4-id");
2551 Assert.AreEqual ("mono 4", dtLoad.Rows[4][1, DataRowVersion.Current], "A-RowData4-name");
2553 dtLoad.AcceptChanges ();
2555 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[2].RowState, "B-RowState2");
2556 Assert.AreEqual (3, dtLoad.Rows[2][0, DataRowVersion.Current], "B-RowData2-id");
2557 Assert.AreEqual ("NEWVAL", dtLoad.Rows[2][1, DataRowVersion.Current], "B-RowData2-name");
2558 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[3].RowState, "B-RowState3");
2559 Assert.AreEqual (4, dtLoad.Rows[3][0, DataRowVersion.Current], "B-RowData3-id");
2560 Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Current], "B-RowData3-name");
2564 [ExpectedException (typeof (IndexOutOfRangeException))]
2565 public void Load_RowStateUpsertDuplicateKey2 () {
2567 dt.Rows.Add (new object[] { 4, "mono 4" });
2568 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2569 dtLoad.Columns.Add ("id", typeof (int));
2570 dtLoad.Columns.Add ("name", typeof (string));
2571 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2572 dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2573 dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2574 dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2575 dtLoad.AcceptChanges ();
2576 dtLoad.Rows[2].Delete ();
2577 DataTableReader dtr = dt.CreateDataReader ();
2578 dtLoad.Load (dtr, LoadOption.Upsert);
2579 dtLoad.AcceptChanges ();
2580 Assert.AreEqual (" ", dtLoad.Rows[4][1], "RowData4");
2584 [ExpectedException (typeof (VersionNotFoundException))]
2585 public void Load_RowStateUpsertDelete1 () {
2587 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2588 dtLoad.Columns.Add ("id", typeof (int));
2589 dtLoad.Columns.Add ("name", typeof (string));
2590 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2591 dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2592 dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2593 dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2594 dtLoad.AcceptChanges ();
2595 dtLoad.Rows[2].Delete ();
2596 DataTableReader dtr = dt.CreateDataReader ();
2597 dtLoad.Load (dtr, LoadOption.Upsert);
2598 Assert.AreEqual (" ", dtLoad.Rows[2][1, DataRowVersion.Current], "RowData2-C");
2602 [ExpectedException (typeof (VersionNotFoundException))]
2603 public void Load_RowStateUpsertDelete2 () {
2605 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2606 dtLoad.Columns.Add ("id", typeof (int));
2607 dtLoad.Columns.Add ("name", typeof (string));
2608 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2609 dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2610 dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2611 dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2612 dtLoad.AcceptChanges ();
2613 dtLoad.Rows[2].Delete ();
2614 DataTableReader dtr = dt.CreateDataReader ();
2615 dtLoad.Load (dtr, LoadOption.Upsert);
2616 Assert.AreEqual (" ", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2620 [ExpectedException (typeof (VersionNotFoundException))]
2621 public void Load_RowStateUpsertAdd () {
2623 dt.Rows.Add (new object[] { 4, "mono 4" });
2624 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2625 dtLoad.Columns.Add ("id", typeof (int));
2626 dtLoad.Columns.Add ("name", typeof (string));
2627 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2628 dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2629 dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2630 dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2631 dtLoad.AcceptChanges ();
2632 DataRow row = dtLoad.NewRow ();
2634 row["name"] = "Add 4";
2635 dtLoad.Rows.Add (row);
2636 DataTableReader dtr = dt.CreateDataReader ();
2637 dtLoad.Load (dtr, LoadOption.Upsert);
2638 Assert.AreEqual (" ", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2642 [ExpectedException (typeof (VersionNotFoundException))]
2643 public void Load_RowStateUpsertUnpresent () {
2645 dt.Rows.Add (new object[] { 4, "mono 4" });
2646 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2647 dtLoad.Columns.Add ("id", typeof (int));
2648 dtLoad.Columns.Add ("name", typeof (string));
2649 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2650 dtLoad.Rows.Add (new object[] { 1, "RowState 1" });
2651 dtLoad.Rows.Add (new object[] { 2, "RowState 2" });
2652 dtLoad.Rows.Add (new object[] { 3, "RowState 3" });
2653 dtLoad.AcceptChanges ();
2654 DataTableReader dtr = dt.CreateDataReader ();
2655 dtLoad.Load (dtr, LoadOption.Upsert);
2656 Assert.AreEqual (" ", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
2660 public void Load_RowStateUpsertUnchangedEqualVal () {
2662 DataTable dtLoad = new DataTable ("LoadRowStateChanges");
2663 dtLoad.Columns.Add ("id", typeof (int));
2664 dtLoad.Columns.Add ("name", typeof (string));
2665 dtLoad.PrimaryKey = new DataColumn[] { dtLoad.Columns["id"] };
2666 dtLoad.Rows.Add (new object[] { 1, "mono 1" });
2667 dtLoad.AcceptChanges ();
2668 DataTableReader dtr = dt.CreateDataReader ();
2669 DataRowAction[] dra = new DataRowAction[] {
2670 DataRowAction.Nothing,// REAL action
2671 DataRowAction.Nothing,// dummy
2672 DataRowAction.Nothing,// dummy
2673 DataRowAction.Nothing,// dummy
2674 DataRowAction.Nothing};// dummy
2675 rowActionInit (dra);
2676 dtLoad.Load (dtr, LoadOption.Upsert);
2678 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Current], "RowData0-C");
2679 Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Original], "RowData0-O");
2680 Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[0].RowState, "RowState0");
2684 public void LoadDataRow_LoadOptions () {
2685 // LoadDataRow is covered in detail (without LoadOptions) in DataTableTest2
2686 // LoadOption tests are covered in detail in DataTable.Load().
2687 // Therefore only minimal tests of LoadDataRow with LoadOptions are covered here.
2690 dt = CreateDataTableExample ();
2691 dt.PrimaryKey = new DataColumn[] { dt.Columns[0] }; //add ParentId as Primary Key
2692 dt.Columns["String1"].DefaultValue = "Default";
2694 dr = dt.Select ("ParentId=1")[0];
2696 //Update existing row with LoadOptions = OverwriteChanges
2697 dt.BeginLoadData ();
2698 dt.LoadDataRow (new object[] { 1, null, "Changed" },
2699 LoadOption.OverwriteChanges);
2702 // LoadDataRow(update1) - check column String2
2703 Assert.AreEqual ("Changed", dr["String2", DataRowVersion.Current], "DT72-C");
2704 Assert.AreEqual ("Changed", dr["String2", DataRowVersion.Original], "DT72-O");
2706 // LoadDataRow(update1) - check row state
2707 Assert.AreEqual (DataRowState.Unchanged, dr.RowState, "DT73-LO");
2709 //Add New row with LoadOptions = Upsert
2710 dt.BeginLoadData ();
2711 dt.LoadDataRow (new object[] { 99, null, "Changed" },
2715 // LoadDataRow(insert1) - check column String2
2716 dr = dt.Select ("ParentId=99")[0];
2717 Assert.AreEqual ("Changed", dr["String2", DataRowVersion.Current], "DT75-C");
2719 // LoadDataRow(insert1) - check row state
2720 Assert.AreEqual (DataRowState.Added, dr.RowState, "DT76-LO");
2723 public static DataTable CreateDataTableExample () {
2724 DataTable dtParent = new DataTable ("Parent");
2726 dtParent.Columns.Add ("ParentId", typeof (int));
2727 dtParent.Columns.Add ("String1", typeof (string));
2728 dtParent.Columns.Add ("String2", typeof (string));
2730 dtParent.Columns.Add ("ParentDateTime", typeof (DateTime));
2731 dtParent.Columns.Add ("ParentDouble", typeof (double));
2732 dtParent.Columns.Add ("ParentBool", typeof (bool));
2734 dtParent.Rows.Add (new object[] { 1, "1-String1", "1-String2", new DateTime (2005, 1, 1, 0, 0, 0, 0), 1.534, true });
2735 dtParent.Rows.Add (new object[] { 2, "2-String1", "2-String2", new DateTime (2004, 1, 1, 0, 0, 0, 1), -1.534, true });
2736 dtParent.Rows.Add (new object[] { 3, "3-String1", "3-String2", new DateTime (2003, 1, 1, 0, 0, 1, 0), double.MinValue * 10000, false });
2737 dtParent.Rows.Add (new object[] { 4, "4-String1", "4-String2", new DateTime (2002, 1, 1, 0, 1, 0, 0), double.MaxValue / 10000, true });
2738 dtParent.Rows.Add (new object[] { 5, "5-String1", "5-String2", new DateTime (2001, 1, 1, 1, 0, 0, 0), 0.755, true });
2739 dtParent.Rows.Add (new object[] { 6, "6-String1", "6-String2", new DateTime (2000, 1, 1, 0, 0, 0, 0), 0.001, false });
2740 dtParent.AcceptChanges ();
2744 #endregion // DataTable.Load Tests
2746 #region Read/Write XML Tests
2750 [Category ("NotWorking")]
2752 public void ReadXmlSchema () {
2753 DataTable Table = new DataTable ();
2754 Table.ReadXmlSchema ("Test/System.Data/own_schema1.xsd");
2756 Assert.AreEqual ("test_table", Table.TableName, "test#02");
2757 Assert.AreEqual ("", Table.Namespace, "test#03");
2758 Assert.AreEqual (2, Table.Columns.Count, "test#04");
2759 Assert.AreEqual (0, Table.Rows.Count, "test#05");
2760 Assert.IsFalse (Table.CaseSensitive, "test#06");
2761 Assert.AreEqual (1, Table.Constraints.Count, "test#07");
2762 Assert.AreEqual ("", Table.Prefix, "test#08");
2764 Constraint cons = Table.Constraints[0];
2765 Assert.AreEqual ("Constraint1", cons.ConstraintName.ToString (), "test#09");
2766 Assert.AreEqual ("Constraint1", cons.ToString (), "test#10");
2768 DataColumn column = Table.Columns[0];
2769 Assert.IsTrue (column.AllowDBNull, "test#11");
2770 Assert.IsFalse (column.AutoIncrement, "test#12");
2771 Assert.AreEqual (0L, column.AutoIncrementSeed, "test#13");
2772 Assert.AreEqual (1L, column.AutoIncrementStep, "test#14");
2773 Assert.AreEqual ("test", column.Caption, "test#15");
2774 Assert.AreEqual ("Element", column.ColumnMapping.ToString (), "test#16");
2775 Assert.AreEqual ("first", column.ColumnName, "test#17");
2776 Assert.AreEqual ("System.String", column.DataType.ToString (), "test#18");
2777 Assert.AreEqual ("test_default_value", column.DefaultValue.ToString (), "test#19");
2778 Assert.IsFalse (column.DesignMode, "test#20");
2779 Assert.AreEqual ("", column.Expression, "test#21");
2780 Assert.AreEqual (100, column.MaxLength, "test#22");
2781 Assert.AreEqual ("", column.Namespace, "test#23");
2782 Assert.AreEqual (0, column.Ordinal, "test#24");
2783 Assert.AreEqual ("", column.Prefix, "test#25");
2784 Assert.IsFalse (column.ReadOnly, "test#26");
2785 Assert.IsTrue (column.Unique, "test#27");
2787 DataColumn column2 = Table.Columns[1];
2788 Assert.IsTrue (column2.AllowDBNull, "test#28");
2789 Assert.IsFalse (column2.AutoIncrement, "test#29");
2790 Assert.AreEqual (0L, column2.AutoIncrementSeed, "test#30");
2791 Assert.AreEqual (1L, column2.AutoIncrementStep, "test#31");
2792 Assert.AreEqual ("second", column2.Caption, "test#32");
2793 Assert.AreEqual ("Element", column2.ColumnMapping.ToString (), "test#33");
2794 Assert.AreEqual ("second", column2.ColumnName, "test#34");
2795 Assert.AreEqual ("System.Data.SqlTypes.SqlGuid", column2.DataType.ToString (), "test#35");
2796 Assert.AreEqual (SqlGuid.Null, column2.DefaultValue, "test#36");
2797 Assert.AreEqual (typeof (SqlGuid), column2.DefaultValue.GetType (), "test#36-2");
2798 Assert.IsFalse (column2.DesignMode, "test#37");
2799 Assert.AreEqual ("", column2.Expression, "test#38");
2800 Assert.AreEqual (-1, column2.MaxLength, "test#39");
2801 Assert.AreEqual ("", column2.Namespace, "test#40");
2802 Assert.AreEqual (1, column2.Ordinal, "test#41");
2803 Assert.AreEqual ("", column2.Prefix, "test#42");
2804 Assert.IsFalse (column2.ReadOnly, "test#43");
2805 Assert.IsFalse (column2.Unique, "test#44");
2807 DataTable Table2 = new DataTable ();
2808 Table2.ReadXmlSchema ("Test/System.Data/own_schema2.xsd");
2810 Assert.AreEqual ("second_test_table", Table2.TableName, "test#45");
2811 Assert.AreEqual ("", Table2.Namespace, "test#46");
2812 Assert.AreEqual (1, Table2.Columns.Count, "test#47");
2813 Assert.AreEqual (0, Table2.Rows.Count, "test#48");
2814 Assert.IsFalse (Table2.CaseSensitive, "test#49");
2815 Assert.AreEqual (1, Table2.Constraints.Count, "test#50");
2816 Assert.AreEqual ("", Table2.Prefix, "test#51");
2818 DataColumn column3 = Table2.Columns[0];
2819 Assert.IsTrue (column3.AllowDBNull, "test#52");
2820 Assert.IsFalse (column3.AutoIncrement, "test#53");
2821 Assert.AreEqual (0L, column3.AutoIncrementSeed, "test#54");
2822 Assert.AreEqual (1L, column3.AutoIncrementStep, "test#55");
2823 Assert.AreEqual ("second_first", column3.Caption, "test#56");
2824 Assert.AreEqual ("Element", column3.ColumnMapping.ToString (), "test#57");
2825 Assert.AreEqual ("second_first", column3.ColumnName, "test#58");
2826 Assert.AreEqual ("System.String", column3.DataType.ToString (), "test#59");
2827 Assert.AreEqual ("default_value", column3.DefaultValue.ToString (), "test#60");
2828 Assert.IsFalse (column3.DesignMode, "test#61");
2829 Assert.AreEqual ("", column3.Expression, "test#62");
2830 Assert.AreEqual (100, column3.MaxLength, "test#63");
2831 Assert.AreEqual ("", column3.Namespace, "test#64");
2832 Assert.AreEqual (0, column3.Ordinal, "test#65");
2833 Assert.AreEqual ("", column3.Prefix, "test#66");
2834 Assert.IsFalse (column3.ReadOnly, "test#67");
2835 Assert.IsTrue (column3.Unique, "test#68");
2839 public void ReadXmlSchema_2 () {
2840 DataTable dt = new DataTable ();
2841 string xmlData = string.Empty;
2842 xmlData += "<?xml version=\"1.0\"?>";
2843 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\">";
2844 xmlData += "<xs:element name=\"SiteConfiguration\" msdata:IsDataSet=\"true\" msdata:EnforceConstraints=\"False\">";
2845 xmlData += "<xs:complexType>";
2846 xmlData += "<xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">";
2847 xmlData += "<xs:element name=\"Tab\">";
2848 xmlData += "<xs:complexType>";
2849 xmlData += "<xs:sequence>";
2850 xmlData += "<xs:element name=\"Module\" minOccurs=\"0\" maxOccurs=\"unbounded\">";
2851 xmlData += "<xs:complexType>";
2852 xmlData += "<xs:attribute name=\"ModuleId\" form=\"unqualified\" type=\"xs:int\" />";
2853 xmlData += "</xs:complexType>";
2854 xmlData += "</xs:element>";
2855 xmlData += "</xs:sequence>";
2856 xmlData += "<xs:attribute name=\"TabId\" form=\"unqualified\" type=\"xs:int\" />";
2857 xmlData += "</xs:complexType>";
2858 xmlData += "</xs:element>";
2859 xmlData += "</xs:choice>";
2860 xmlData += "</xs:complexType>";
2861 xmlData += "<xs:key name=\"TabKey\" msdata:PrimaryKey=\"true\">";
2862 xmlData += "<xs:selector xpath=\".//mstns:Tab\" />";
2863 xmlData += "<xs:field xpath=\"@TabId\" />";
2864 xmlData += "</xs:key>";
2865 xmlData += "<xs:key name=\"ModuleKey\" msdata:PrimaryKey=\"true\">";
2866 xmlData += "<xs:selector xpath=\".//mstns:Module\" />";
2867 xmlData += "<xs:field xpath=\"@ModuleID\" />";
2868 xmlData += "</xs:key>";
2869 xmlData += "</xs:element>";
2870 xmlData += "</xs:schema>";
2871 dt.ReadXmlSchema (new StringReader (xmlData));
2875 public void ReadXmlSchema_ByStream () {
2876 DataSet ds1 = new DataSet ();
2877 ds1.Tables.Add (DataProvider.CreateParentDataTable ());
2878 ds1.Tables.Add (DataProvider.CreateChildDataTable ());
2880 MemoryStream ms1 = new MemoryStream ();
2881 MemoryStream ms2 = new MemoryStream ();
2882 //write xml schema only
2883 //ds1.WriteXmlSchema (ms);
2884 ds1.Tables[0].WriteXmlSchema (ms1);
2885 ds1.Tables[1].WriteXmlSchema (ms2);
2887 MemoryStream ms11 = new MemoryStream (ms1.GetBuffer ());
2888 MemoryStream ms22 = new MemoryStream (ms2.GetBuffer ());
2890 //DataSet ds2 = new DataSet ();
2891 DataTable dt1 = new DataTable ();
2892 DataTable dt2 = new DataTable ();
2894 //ds2.ReadXmlSchema (ms1);
2895 dt1.ReadXmlSchema (ms11);
2896 dt2.ReadXmlSchema (ms22);
2899 // ReadXmlSchema - Tables count
2900 //Assert.AreEqual (ds2.Tables.Count, ds1.Tables.Count, "DS269");
2902 // ReadXmlSchema - Tables 0 Col count
2903 Assert.AreEqual (ds1.Tables[0].Columns.Count, dt1.Columns.Count, "DS270");
2905 // ReadXmlSchema - Tables 1 Col count
2906 Assert.AreEqual (ds1.Tables[1].Columns.Count, dt2.Columns.Count, "DS271");
2908 //check some colummns types
2909 // ReadXmlSchema - Tables 0 Col type
2910 Assert.AreEqual (ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType (), "DS272");
2912 // ReadXmlSchema - Tables 1 Col type
2913 Assert.AreEqual (ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType (), "DS273");
2915 //check that no data exists
2916 // ReadXmlSchema - Table 1 row count
2917 Assert.AreEqual (0, dt1.Rows.Count, "DS274");
2919 // ReadXmlSchema - Table 2 row count
2920 Assert.AreEqual (0, dt2.Rows.Count, "DS275");
2924 public void ReadWriteXmlSchema_ByFileName () {
2925 string sTempFileName1 = "tmpDataSet_ReadWriteXml_43899-1.xml";
2926 string sTempFileName2 = "tmpDataSet_ReadWriteXml_43899-2.xml";
2928 DataSet ds1 = new DataSet ();
2929 ds1.Tables.Add (DataProvider.CreateParentDataTable ());
2930 ds1.Tables.Add (DataProvider.CreateChildDataTable ());
2932 ds1.Tables[0].WriteXmlSchema (sTempFileName1);
2933 ds1.Tables[1].WriteXmlSchema (sTempFileName2);
2935 DataTable dt1 = new DataTable ();
2936 DataTable dt2 = new DataTable ();
2938 dt1.ReadXmlSchema (sTempFileName1);
2939 dt2.ReadXmlSchema (sTempFileName2);
2941 Assert.AreEqual (ds1.Tables[0].Columns.Count, dt1.Columns.Count, "DS277");
2942 Assert.AreEqual (ds1.Tables[1].Columns.Count, dt2.Columns.Count, "DS278");
2943 Assert.AreEqual (ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType (), "DS279");
2944 Assert.AreEqual (ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType (), "DS280");
2945 Assert.AreEqual (0, dt1.Rows.Count, "DS281");
2946 Assert.AreEqual (0, dt2.Rows.Count, "DS282");
2948 File.Delete (sTempFileName1);
2949 File.Delete (sTempFileName2);
2953 public void ReadXmlSchema_ByTextReader () {
2954 DataSet ds1 = new DataSet ();
2955 ds1.Tables.Add (DataProvider.CreateParentDataTable ());
2956 ds1.Tables.Add (DataProvider.CreateChildDataTable ());
2958 StringWriter sw1 = new StringWriter ();
2959 StringWriter sw2 = new StringWriter ();
2960 //write xml file, schema only
2961 //ds1.WriteXmlSchema (sw);
2962 ds1.Tables[0].WriteXmlSchema (sw1);
2963 ds1.Tables[1].WriteXmlSchema (sw2);
2965 StringReader sr1 = new StringReader (sw1.GetStringBuilder ().ToString ());
2966 StringReader sr2 = new StringReader (sw2.GetStringBuilder ().ToString ());
2967 //copy both data and schema
2968 //DataSet ds2 = new DataSet ();
2969 DataTable dt1 = new DataTable ();
2970 DataTable dt2 = new DataTable ();
2972 //ds2.ReadXmlSchema (sr);
2973 dt1.ReadXmlSchema (sr1);
2974 dt2.ReadXmlSchema (sr2);
2977 // ReadXmlSchema - Tables count
2978 //Assert.AreEqual (ds2.Tables.Count, ds1.Tables.Count, "DS283");
2980 // ReadXmlSchema - Tables 0 Col count
2981 Assert.AreEqual (ds1.Tables[0].Columns.Count, dt1.Columns.Count, "DS284");
2983 // ReadXmlSchema - Tables 1 Col count
2984 Assert.AreEqual (ds1.Tables[1].Columns.Count, dt2.Columns.Count, "DS285");
2986 //check some colummns types
2987 // ReadXmlSchema - Tables 0 Col type
2988 Assert.AreEqual (ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType (), "DS286");
2990 // ReadXmlSchema - Tables 1 Col type
2991 Assert.AreEqual (ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType (), "DS287");
2993 //check that no data exists
2994 // ReadXmlSchema - Table 1 row count
2995 Assert.AreEqual (0, dt1.Rows.Count, "DS288");
2997 // ReadXmlSchema - Table 2 row count
2998 Assert.AreEqual (0, dt2.Rows.Count, "DS289");
3002 public void ReadXmlSchema_ByXmlReader () {
3003 DataSet ds1 = new DataSet ();
3004 ds1.Tables.Add (DataProvider.CreateParentDataTable ());
3005 ds1.Tables.Add (DataProvider.CreateChildDataTable ());
3007 StringWriter sw1 = new StringWriter ();
3008 XmlTextWriter xmlTW1 = new XmlTextWriter (sw1);
3009 StringWriter sw2 = new StringWriter ();
3010 XmlTextWriter xmlTW2 = new XmlTextWriter (sw2);
3012 //write xml file, schema only
3013 ds1.Tables[0].WriteXmlSchema (xmlTW1);
3015 ds1.Tables[1].WriteXmlSchema (xmlTW2);
3018 StringReader sr1 = new StringReader (sw1.ToString ());
3019 XmlTextReader xmlTR1 = new XmlTextReader (sr1);
3020 StringReader sr2 = new StringReader (sw2.ToString ());
3021 XmlTextReader xmlTR2 = new XmlTextReader (sr2);
3023 //copy both data and schema
3024 //DataSet ds2 = new DataSet ();
3025 DataTable dt1 = new DataTable ();
3026 DataTable dt2 = new DataTable ();
3028 //ds2.ReadXmlSchema (xmlTR);
3029 dt1.ReadXmlSchema (xmlTR1);
3030 dt2.ReadXmlSchema (xmlTR2);
3033 // ReadXmlSchema - Tables count
3034 //Assert.AreEqual (ds2.Tables.Count, ds1.Tables.Count, "DS290");
3036 // ReadXmlSchema - Tables 0 Col count
3037 Assert.AreEqual (ds1.Tables[0].Columns.Count, dt1.Columns.Count, "DS291");
3039 // ReadXmlSchema - Tables 1 Col count
3040 Assert.AreEqual (ds1.Tables[1].Columns.Count, dt2.Columns.Count, "DS292");
3042 //check some colummns types
3043 // ReadXmlSchema - Tables 0 Col type
3044 Assert.AreEqual (ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType (), "DS293");
3046 // ReadXmlSchema - Tables 1 Col type
3047 Assert.AreEqual (ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType (), "DS294");
3049 //check that no data exists
3050 // ReadXmlSchema - Table 1 row count
3051 Assert.AreEqual (0, dt1.Rows.Count, "DS295");
3053 // ReadXmlSchema - Table 2 row count
3054 Assert.AreEqual (0, dt2.Rows.Count, "DS296");
3058 public void WriteXmlSchema () {
3059 DataSet ds = new DataSet ();
3060 ds.ReadXml ("Test/System.Data/region.xml");
3061 TextWriter writer = new StringWriter ();
3062 ds.Tables[0].WriteXmlSchema (writer);
3065 string TextString = GetNormalizedSchema (writer.ToString ());
3066 //string TextString = writer.ToString ();
3068 string substring = TextString.Substring (0, TextString.IndexOf (EOL));
3069 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3070 Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
3072 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3073 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3074 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");
3076 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3077 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3078 Assert.AreEqual (" <xs:element msdata:IsDataSet=\"true\" msdata:MainDataTable=\"Region\" msdata:UseCurrentLocale=\"true\" name=\"Root\">", substring, "test#03");
3080 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3081 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3082 Assert.AreEqual (" <xs:complexType>", substring, "test#04");
3084 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3085 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3086 Assert.AreEqual (" <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring, "test#05");
3088 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3089 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3090 Assert.AreEqual (" <xs:element name=\"Region\">", substring, "test#06");
3092 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3093 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3094 Assert.AreEqual (" <xs:complexType>", substring, "test#07");
3096 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3097 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3098 Assert.AreEqual (" <xs:sequence>", substring, "test#08");
3100 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3101 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3102 Assert.AreEqual (" <xs:element minOccurs=\"0\" name=\"RegionID\" type=\"xs:string\" />", substring, "test#09");
3104 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3105 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3106 Assert.AreEqual (" <xs:element minOccurs=\"0\" name=\"RegionDescription\" type=\"xs:string\" />", substring, "test#10");
3108 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3109 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3110 Assert.AreEqual (" </xs:sequence>", substring, "test#11");
3112 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3113 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3114 Assert.AreEqual (" </xs:complexType>", substring, "test#12");
3116 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3117 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3118 Assert.AreEqual (" </xs:element>", substring, "test#13");
3120 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3121 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3122 Assert.AreEqual (" </xs:choice>", substring, "test#14");
3124 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3125 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3126 Assert.AreEqual (" </xs:complexType>", substring, "test#15");
3128 substring = TextString.Substring (0, TextString.IndexOf (EOL));
3129 TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
3130 Assert.AreEqual (" </xs:element>", substring, "test#16");
3132 Assert.AreEqual ("</xs:schema>", TextString, "test#17");
3136 public void WriteXmlSchema2 () {
3137 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>";
3138 string schema = @"<?xml version='1.0' encoding='utf-16'?>
3139 <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'>
3140 <xs:element name='myDataSet' msdata:IsDataSet='true' msdata:MainDataTable='NetFrameWork_x003A_myTable' msdata:UseCurrentLocale='true'>
3142 <xs:choice minOccurs='0' maxOccurs='unbounded'>
3143 <xs:element name='myTable'>
3146 <xs:element name='id' msdata:AutoIncrement='true' type='xs:int' minOccurs='0' />
3147 <xs:element name='item' type='xs:string' minOccurs='0' />
3155 DataSet OriginalDataSet = new DataSet ("myDataSet");
3156 OriginalDataSet.Namespace = "NetFrameWork";
3157 DataTable myTable = new DataTable ("myTable");
3158 DataColumn c1 = new DataColumn ("id", typeof (int));
3159 c1.AutoIncrement = true;
3160 DataColumn c2 = new DataColumn ("item");
3161 myTable.Columns.Add (c1);
3162 myTable.Columns.Add (c2);
3163 OriginalDataSet.Tables.Add (myTable);
3166 for (int i = 0; i < 10; i++) {
3167 newRow = myTable.NewRow ();
3168 newRow["item"] = "item " + i;
3169 myTable.Rows.Add (newRow);
3171 OriginalDataSet.AcceptChanges ();
3173 StringWriter sw = new StringWriter ();
3174 XmlTextWriter xtw = new XmlTextWriter (sw);
3175 xtw.QuoteChar = '\'';
3176 OriginalDataSet.WriteXml (xtw);
3177 string result = sw.ToString ();
3179 Assert.AreEqual (xml, result);
3181 sw = new StringWriter ();
3182 xtw = new XmlTextWriter (sw);
3183 xtw.Formatting = Formatting.Indented;
3184 OriginalDataSet.Tables[0].WriteXmlSchema (xtw);
3185 result = sw.ToString ();
3187 result = result.Replace ("\r\n", "\n").Replace ('"', '\'');
3188 Assert.AreEqual (schema.Replace ("\r\n", "\n"), result);
3192 public void WriteXmlSchema3 () {
3193 string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
3194 <xs:schema id=""ExampleDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3195 <xs:element name=""ExampleDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""ExampleDataTable"" msdata:UseCurrentLocale=""true"">
3197 <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3198 <xs:element name=""ExampleDataTable"">
3200 <xs:attribute name=""PrimaryKeyColumn"" type=""xs:int"" use=""required"" />
3205 <xs:unique name=""PK_ExampleDataTable"" msdata:PrimaryKey=""true"">
3206 <xs:selector xpath="".//ExampleDataTable"" />
3207 <xs:field xpath=""@PrimaryKeyColumn"" />
3211 DataSet ds = new DataSet ("ExampleDataSet");
3213 ds.Tables.Add (new DataTable ("ExampleDataTable"));
3214 ds.Tables["ExampleDataTable"].Columns.Add (
3215 new DataColumn ("PrimaryKeyColumn", typeof (int), "", MappingType.Attribute));
3216 ds.Tables["ExampleDataTable"].Columns["PrimaryKeyColumn"].AllowDBNull = false;
3218 ds.Tables["ExampleDataTable"].Constraints.Add (
3219 "PK_ExampleDataTable",
3220 ds.Tables["ExampleDataTable"].Columns["PrimaryKeyColumn"],
3223 ds.AcceptChanges ();
3224 StringWriter sw = new StringWriter ();
3225 ds.Tables[0].WriteXmlSchema (sw);
3227 string result = sw.ToString ();
3229 Assert.AreEqual (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
3230 //Assert.AreEqual (xmlschema, result.Replace ("\r\n", "\n"));
3234 public void WriteXmlSchema4 () {
3235 string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
3236 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3237 <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""MyType"" msdata:UseCurrentLocale=""true"">
3239 <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3240 <xs:element name=""MyType"">
3242 <xs:attribute name=""ID"" type=""xs:int"" use=""required"" />
3243 <xs:attribute name=""Desc"" type=""xs:string"" />
3250 DataSet ds = new DataSet ("Example");
3252 // Add MyType DataTable
3253 DataTable dt = new DataTable ("MyType");
3256 dt.Columns.Add (new DataColumn ("ID", typeof (int), "",
3257 MappingType.Attribute));
3258 dt.Columns["ID"].AllowDBNull = false;
3260 dt.Columns.Add (new DataColumn ("Desc", typeof
3261 (string), "", MappingType.Attribute));
3263 ds.AcceptChanges ();
3265 StringWriter sw = new StringWriter ();
3266 ds.Tables[0].WriteXmlSchema (sw);
3268 string result = sw.ToString ();
3270 Assert.AreEqual (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
3274 public void WriteXmlSchema5 () {
3275 string xmlschema1 = @"<?xml version=""1.0"" encoding=""utf-16""?>
3276 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3277 <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""StandAlone"" msdata:UseCurrentLocale=""true"">
3279 <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3280 <xs:element name=""StandAlone"">
3282 <xs:attribute name=""ID"" type=""xs:int"" use=""required"" />
3283 <xs:attribute name=""Desc"" type=""xs:string"" use=""required"" />
3290 string xmlschema2 = @"<?xml version=""1.0"" encoding=""utf-16""?>
3291 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3292 <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""Dimension"" msdata:UseCurrentLocale=""true"">
3294 <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3295 <xs:element name=""Dimension"">
3297 <xs:attribute name=""Number"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
3298 <xs:attribute name=""Title"" type=""xs:string"" use=""required"" />
3303 <xs:unique name=""PK_Dimension"" msdata:PrimaryKey=""true"">
3304 <xs:selector xpath="".//Dimension"" />
3305 <xs:field xpath=""@Number"" />
3309 string xmlschema3 = @"<?xml version=""1.0"" encoding=""utf-16""?>
3310 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3311 <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""Element"" msdata:UseCurrentLocale=""true"">
3313 <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3314 <xs:element name=""Element"">
3316 <xs:attribute name=""Dimension"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
3317 <xs:attribute name=""Number"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
3318 <xs:attribute name=""Title"" type=""xs:string"" use=""required"" />
3323 <xs:unique name=""PK_Element"" msdata:PrimaryKey=""true"">
3324 <xs:selector xpath="".//Element"" />
3325 <xs:field xpath=""@Dimension"" />
3326 <xs:field xpath=""@Number"" />
3330 DataSet ds = new DataSet ("Example");
3332 // Add a DataTable with no ReadOnly columns
3333 DataTable dt1 = new DataTable ("StandAlone");
3334 ds.Tables.Add (dt1);
3336 // Add a ReadOnly column
3337 dt1.Columns.Add (new DataColumn ("ID", typeof (int), "",
3338 MappingType.Attribute));
3339 dt1.Columns["ID"].AllowDBNull = false;
3341 dt1.Columns.Add (new DataColumn ("Desc", typeof
3342 (string), "", MappingType.Attribute));
3343 dt1.Columns["Desc"].AllowDBNull = false;
3345 // Add related DataTables with ReadOnly columns
3346 DataTable dt2 = new DataTable ("Dimension");
3347 ds.Tables.Add (dt2);
3348 dt2.Columns.Add (new DataColumn ("Number", typeof
3349 (int), "", MappingType.Attribute));
3350 dt2.Columns["Number"].AllowDBNull = false;
3351 dt2.Columns["Number"].ReadOnly = true;
3353 dt2.Columns.Add (new DataColumn ("Title", typeof
3354 (string), "", MappingType.Attribute));
3355 dt2.Columns["Title"].AllowDBNull = false;
3357 dt2.Constraints.Add ("PK_Dimension", dt2.Columns["Number"], true);
3359 DataTable dt3 = new DataTable ("Element");
3360 ds.Tables.Add (dt3);
3362 dt3.Columns.Add (new DataColumn ("Dimension", typeof
3363 (int), "", MappingType.Attribute));
3364 dt3.Columns["Dimension"].AllowDBNull = false;
3365 dt3.Columns["Dimension"].ReadOnly = true;
3367 dt3.Columns.Add (new DataColumn ("Number", typeof
3368 (int), "", MappingType.Attribute));
3369 dt3.Columns["Number"].AllowDBNull = false;
3370 dt3.Columns["Number"].ReadOnly = true;
3372 dt3.Columns.Add (new DataColumn ("Title", typeof
3373 (string), "", MappingType.Attribute));
3374 dt3.Columns["Title"].AllowDBNull = false;
3376 dt3.Constraints.Add ("PK_Element", new DataColumn[] {
3377 dt3.Columns ["Dimension"],
3378 dt3.Columns ["Number"] }, true);
3380 ds.AcceptChanges ();
3382 StringWriter sw1 = new StringWriter ();
3383 ds.Tables[0].WriteXmlSchema (sw1);
3384 string result1 = sw1.ToString ();
3385 Assert.AreEqual (xmlschema1.Replace ("\r\n", "\n"), result1.Replace ("\r\n", "\n"));
3387 StringWriter sw2 = new StringWriter ();
3388 ds.Tables[1].WriteXmlSchema (sw2);
3389 string result2 = sw2.ToString ();
3390 Assert.AreEqual (xmlschema2.Replace ("\r\n", "\n"), result2.Replace ("\r\n", "\n"));
3392 StringWriter sw3 = new StringWriter ();
3393 ds.Tables[2].WriteXmlSchema (sw3);
3394 string result3 = sw3.ToString ();
3395 Assert.AreEqual (xmlschema3.Replace ("\r\n", "\n"), result3.Replace ("\r\n", "\n"));
3399 public void WriteXmlSchema6 () {
3400 string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
3401 <xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
3402 <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:MainDataTable=""MyType"" msdata:UseCurrentLocale=""true"">
3404 <xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
3405 <xs:element name=""MyType"">
3407 <xs:attribute name=""Desc"">
3409 <xs:restriction base=""xs:string"">
3410 <xs:maxLength value=""32"" />
3420 DataSet ds = new DataSet ("Example");
3422 // Add MyType DataTable
3423 ds.Tables.Add ("MyType");
3425 ds.Tables["MyType"].Columns.Add (new DataColumn (
3426 "Desc", typeof (string), "", MappingType.Attribute));
3427 ds.Tables["MyType"].Columns["Desc"].MaxLength = 32;
3429 ds.AcceptChanges ();
3431 StringWriter sw = new StringWriter ();
3432 ds.Tables[0].WriteXmlSchema (sw);
3434 string result = sw.ToString ();
3436 Assert.AreEqual (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
3440 public void WriteXmlSchema7 () {
3441 DataSet ds = new DataSet ();
3442 DataTable dt = new DataTable ("table");
3443 dt.Columns.Add ("col1");
3444 dt.Columns.Add ("col2");
3446 dt.Rows.Add (new object[] { "foo", "bar" });
3447 StringWriter sw = new StringWriter ();
3448 ds.Tables[0].WriteXmlSchema (sw);
3449 Assert.IsTrue (sw.ToString ().IndexOf ("xmlns=\"\"") > 0);
3453 public void WriteXmlSchema_ConstraintNameWithSpaces () {
3454 DataSet ds = new DataSet ();
3455 DataTable table1 = ds.Tables.Add ("table1");
3456 DataTable table2 = ds.Tables.Add ("table2");
3458 table1.Columns.Add ("col1", typeof (int));
3459 table2.Columns.Add ("col1", typeof (int));
3461 table1.Constraints.Add ("uc 1", table1.Columns[0], false);
3462 table2.Constraints.Add ("fc 1", table1.Columns[0], table2.Columns[0]);
3464 StringWriter sw1 = new StringWriter ();
3465 StringWriter sw2 = new StringWriter ();
3467 //should not throw an exception
3468 ds.Tables[0].WriteXmlSchema (sw1);
3469 ds.Tables[1].WriteXmlSchema (sw2);
3473 public void WriteXmlSchema_ForignKeyConstraint () {
3474 DataSet ds1 = new DataSet ();
3476 DataTable table1 = ds1.Tables.Add ();
3477 DataTable table2 = ds1.Tables.Add ();
3479 DataColumn col1_1 = table1.Columns.Add ("col1", typeof (int));
3480 DataColumn col2_1 = table2.Columns.Add ("col1", typeof (int));
3482 table2.Constraints.Add ("fk", col1_1, col2_1);
3484 StringWriter sw1 = new StringWriter ();
3485 ds1.Tables[0].WriteXmlSchema (sw1);
3486 String xml1 = sw1.ToString ();
3487 Assert.IsTrue (xml1.IndexOf (@"<xs:unique name=""Constraint1"">") != -1, "#1");
3489 StringWriter sw2 = new StringWriter ();
3490 ds1.Tables[1].WriteXmlSchema (sw2);
3491 String xml2 = sw2.ToString ();
3492 Assert.IsTrue (xml2.IndexOf (@"<xs:unique name=""Constraint1"">") == -1, "#2");
3496 public void WriteXmlSchema_Relations_ForeignKeys () {
3497 MemoryStream ms1 = null;
3498 MemoryStream ms2 = null;
3499 MemoryStream msA = null;
3500 MemoryStream msB = null;
3502 DataSet ds1 = new DataSet ();
3504 DataTable table1 = ds1.Tables.Add ("Table 1");
3505 DataTable table2 = ds1.Tables.Add ("Table 2");
3507 DataColumn col1_1 = table1.Columns.Add ("col 1", typeof (int));
3508 DataColumn col1_2 = table1.Columns.Add ("col 2", typeof (int));
3509 DataColumn col1_3 = table1.Columns.Add ("col 3", typeof (int));
3510 DataColumn col1_4 = table1.Columns.Add ("col 4", typeof (int));
3511 DataColumn col1_5 = table1.Columns.Add ("col 5", typeof (int));
3512 DataColumn col1_6 = table1.Columns.Add ("col 6", typeof (int));
3513 DataColumn col1_7 = table1.Columns.Add ("col 7", typeof (int));
3515 DataColumn col2_1 = table2.Columns.Add ("col 1", typeof (int));
3516 DataColumn col2_2 = table2.Columns.Add ("col 2", typeof (int));
3517 DataColumn col2_3 = table2.Columns.Add ("col 3", typeof (int));
3518 DataColumn col2_4 = table2.Columns.Add ("col 4", typeof (int));
3519 DataColumn col2_5 = table2.Columns.Add ("col 5", typeof (int));
3520 DataColumn col2_6 = table2.Columns.Add ("col 6", typeof (int));
3521 DataColumn col2_7 = table2.Columns.Add ("col 7", typeof (int));
3523 ds1.Relations.Add ("rel 1",
3524 new DataColumn[] { col1_1, col1_2 },
3525 new DataColumn[] { col2_1, col2_2 },
3527 ds1.Relations.Add ("rel 2",
3528 new DataColumn[] { col1_3, col1_4 },
3529 new DataColumn[] { col2_3, col2_4 },
3531 table2.Constraints.Add ("fk 1",
3532 new DataColumn[] { col1_5, col1_6 },
3533 new DataColumn[] { col2_5, col2_6 });
3534 table1.Constraints.Add ("fk 2",
3535 new DataColumn[] { col2_5, col2_6 },
3536 new DataColumn[] { col1_5, col1_6 });
3538 table1.Constraints.Add ("pk 1", col1_7, true);
3539 table2.Constraints.Add ("pk 2", col2_7, true);
3541 ms1 = new MemoryStream ();
3542 ds1.Tables[0].WriteXmlSchema (ms1);
3543 ms2 = new MemoryStream ();
3544 ds1.Tables[1].WriteXmlSchema (ms2);
3546 msA = new MemoryStream (ms1.GetBuffer ());
3547 DataTable dtA = new DataTable ();
3548 dtA.ReadXmlSchema (msA);
3550 msB = new MemoryStream (ms2.GetBuffer ());
3551 DataTable dtB = new DataTable ();
3552 dtB.ReadXmlSchema (msB);
3554 Assert.AreEqual (3, dtA.Constraints.Count, "#2");
3555 Assert.AreEqual (2, dtB.Constraints.Count, "#3");
3557 Assert.IsTrue (dtA.Constraints.Contains ("pk 1"), "#5");
3558 Assert.IsTrue (dtA.Constraints.Contains ("Constraint1"), "#6");
3559 Assert.IsTrue (dtA.Constraints.Contains ("Constraint2"), "#7");
3560 Assert.IsTrue (dtB.Constraints.Contains ("pk 2"), "#9");
3561 Assert.IsTrue (dtB.Constraints.Contains ("Constraint1"), "#10");
3565 [Category ("NotWorking")]
3566 public void WriteXmlSchema_DifferentNamespace () {
3567 string schema = @"<?xml version='1.0' encoding='utf-16'?>\n<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'>
3568 <xs:import namespace='urn:foo' />
3569 <xs:import namespace='urn:baz' />
3570 <xs:element name='NewDataSet' msdata:IsDataSet='true' msdata:MainDataTable='urn_x003A_foo_x003A_NS1Table' msdata:UseCurrentLocale='true'>
3572 <xs:choice minOccurs='0' maxOccurs='unbounded'>
3573 <xs:element ref='app2:NS1Table' />
3578 <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'>
3579 <xs:import namespace='urn:foo' />
3580 <xs:import namespace='urn:bar' />
3581 <xs:element name='column2' type='xs:string' />
3583 <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'>
3584 <xs:import namespace='urn:bar' />
3585 <xs:import namespace='urn:baz' />
3586 <xs:element name='NS1Table'>
3589 <xs:element name='column1' type='xs:string' minOccurs='0' />
3590 <xs:element ref='app1:column2' minOccurs='0' />
3595 DataSet ds = new DataSet ();
3596 DataTable dt = new DataTable ();
3597 dt.TableName = "NS1Table";
3598 dt.Namespace = "urn:foo";
3599 dt.Columns.Add ("column1");
3600 dt.Columns.Add ("column2");
3601 dt.Columns[1].Namespace = "urn:baz";
3603 DataTable dt2 = new DataTable ();
3604 dt2.TableName = "NS2Table";
3605 dt2.Namespace = "urn:bar";
3606 ds.Tables.Add (dt2);
3607 ds.Namespace = "urn:bar";
3609 StringWriter sw1 = new StringWriter ();
3610 XmlTextWriter xw1 = new XmlTextWriter (sw1);
3611 xw1.Formatting = Formatting.Indented;
3612 xw1.QuoteChar = '\'';
3613 ds.Tables[0].WriteXmlSchema (xw1);
3614 string result1 = sw1.ToString ();
3615 Assert.AreEqual (schema, result1, "#1");
3617 StringWriter sw2 = new StringWriter ();
3618 XmlTextWriter xw2 = new XmlTextWriter (sw2);
3619 xw2.Formatting = Formatting.Indented;
3620 xw2.QuoteChar = '\'';
3621 ds.Tables[0].WriteXmlSchema (xw2);
3622 string result2 = sw2.ToString ();
3623 Assert.AreEqual (schema, result2, "#2");
3628 [Category ("NotWorking")]
3630 public void WriteXmlSchema_Hierarchy () {
3631 DataSet ds = new DataSet ();
3632 DataTable table1 = new DataTable ();
3633 DataColumn idColumn = table1.Columns.Add ("ID", typeof (Int32));
3634 table1.Columns.Add ("Name", typeof (String));
3635 table1.PrimaryKey = new DataColumn[] { idColumn };
3636 DataTable table2 = new DataTable ();
3637 table2.Columns.Add (new DataColumn ("OrderID", typeof (Int32)));
3638 table2.Columns.Add (new DataColumn ("CustomerID", typeof (Int32)));
3639 table2.Columns.Add (new DataColumn ("OrderDate", typeof (DateTime)));
3640 table2.PrimaryKey = new DataColumn[] { table2.Columns[0] };
3641 ds.Tables.Add (table1);
3642 ds.Tables.Add (table2);
3643 ds.Relations.Add ("CustomerOrder",
3644 new DataColumn[] { table1.Columns[0] },
3645 new DataColumn[] { table2.Columns[1] }, true);
3647 StringWriter writer1 = new StringWriter ();
3648 table1.WriteXmlSchema (writer1, false);
3649 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>";
3650 Assert.AreEqual (expected1, writer1.ToString().Replace("\r\n", "\n"), "#1");
3652 StringWriter writer2 = new StringWriter ();
3653 table1.WriteXmlSchema (writer2, true);
3654 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>";
3655 Assert.AreEqual (expected2, writer2.ToString ().Replace("\r\n", "\n"), "#2");
3660 [Category ("NotWorking")]
3662 // WriteXmlSchema doesn't have overload wityh 2 parameters in System.Data
3663 // and is commented-out TWICE below
3664 public void ReadWriteXmlSchema()
3666 DataSet ds = new DataSet();
3667 ds.ReadXmlSchema("Test/System.Data/store.xsd");
3668 // check dataset properties before testing write
3669 AssertDataSet("ds", ds, "NewDataSet", 3, 2);
3670 AssertDataTable("tab1", ds.Tables[0], "bookstore", 1, 0, 0, 1, 1, 1);
3671 AssertDataTable("tab2", ds.Tables[1], "book", 5, 0, 1, 1, 2, 1);
3672 AssertDataTable("tab3", ds.Tables[2], "author", 3, 0, 1, 0, 1, 0);
3673 // FIXME: currently order is not compatible. Use name as index
3674 AssertDataRelation("rel1", ds.Relations["book_author"], "book_author", true, new string[] { "book_Id" }, new string[] { "book_Id" }, true, true);
3675 AssertDataRelation("rel2", ds.Relations["bookstore_book"], "bookstore_book", true, new string[] { "bookstore_Id" }, new string[] { "bookstore_Id" }, true, true);
3677 ds.ReadXml("Test/System.Data/region.xml", XmlReadMode.InferSchema);
3678 ds.Relations.Clear(); // because can not call WriteXmlSchema with nested relations.
3680 TextWriter writer1 = new StringWriter();
3681 ds.Tables[0].WriteXmlSchema(writer1);
3682 //string TextString1 = GetNormalizedSchema(writer1.ToString());
3683 string TextString1 = writer1.ToString();
3684 string expected1 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3685 @"<xs:schema id=""Root"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3686 @"<xs:complexType name=""bookstoreType"">" +
3687 @"</xs:complexType>" +
3688 @"<xs:element name=""bookstore"" type=""bookstoreType"" />" +
3689 @"<xs:element name=""Root"" msdata:IsDataSet=""true"" msdata:MainDataTable=""bookstore"" msdata:UseCurrentLocale=""true"">" +
3690 @"<xs:complexType>" +
3691 @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3692 @"<xs:element ref=""bookstore"" />" +
3694 @"</xs:complexType>" +
3697 Assert.AreEqual(expected1.Replace("\n", ""), TextString1.Replace("\r\n", "").Replace(" ", "").Replace("\n", ""), "#1");
3699 TextWriter writer2 = new StringWriter();
3700 ds.Tables[1].WriteXmlSchema(writer2, false);
3701 //string TextString2 = GetNormalizedSchema(writer2.ToString());
3702 string TextString2 = writer2.ToString();
3703 string expected2 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3704 @"<xs:schema id=""Root"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3705 @"<xs:complexType name=""bookType"">" +
3707 @"<xs:element name=""title"" type=""xs:string"" msdata:Ordinal=""1"" />" +
3708 @"<xs:element name=""price"" type=""xs:decimal"" msdata:Ordinal=""2"" />" +
3710 @"<xs:attribute name=""genre"" type=""xs:string"" />" +
3711 @"<xs:attribute name=""bookstore_Id"" type=""xs:int"" use=""prohibited"" />" +
3712 @"</xs:complexType>" +
3713 @"<xs:element name=""book"" type=""bookType"" />" +
3714 @"<xs:element name=""Root"" msdata:IsDataSet=""true"" msdata:MainDataTable=""book"" msdata:UseCurrentLocale=""true"">" +
3715 @"<xs:complexType>" +
3716 @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3717 @"<xs:element ref=""book"" />" +
3719 @"</xs:complexType>" +
3722 Assert.AreEqual(expected2, TextString2.Replace("\r\n", "").Replace(" ", ""), "#2");
3724 TextWriter writer3 = new StringWriter();
3725 ds.Tables[2].WriteXmlSchema(writer3);
3726 //string TextString3 = GetNormalizedSchema(writer3.ToString());
3727 string TextString3 = writer3.ToString();
3728 string expected3 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3729 @"<xs:schema id=""Root"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3730 @"<xs:complexType name=""authorName"">" +
3732 @"<xs:element name=""first-name"" type=""xs:string"" msdata:Ordinal=""0"" />" +
3733 @"<xs:element name=""last-name"" type=""xs:string"" msdata:Ordinal=""1"" />" +
3735 @"<xs:attribute name=""book_Id"" type=""xs:int"" use=""prohibited"" />" +
3736 @"</xs:complexType>" +
3737 @"<xs:element name=""author"" type=""authorName"" />" +
3738 @"<xs:element name=""Root"" msdata:IsDataSet=""true"" msdata:MainDataTable=""author"" msdata:UseCurrentLocale=""true"">" +
3739 @"<xs:complexType>" +
3740 @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3741 @"<xs:element ref=""author"" />" +
3743 @"</xs:complexType>" +
3746 Assert.AreEqual(expected3, TextString3.Replace("\r\n", "").Replace(" ", ""), "#3");
3748 TextWriter writer4 = new StringWriter();
3749 ds.Tables[3].WriteXmlSchema(writer4);
3750 //string TextString4 = GetNormalizedSchema(writer4.ToString());
3751 string TextString4 = writer4.ToString();
3752 string expected4 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3753 @"<xs:schema id=""Root"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3754 @"<xs:element name=""Root"" msdata:IsDataSet=""true"" msdata:MainDataTable=""Region"" msdata:UseCurrentLocale=""true"">" +
3755 @"<xs:complexType>" +
3756 @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3757 @"<xs:element name=""Region"">" +
3758 @"<xs:complexType>" +
3760 @"<xs:element name=""RegionID"" type=""xs:string"" minOccurs=""0"" />" +
3761 @"<xs:element name=""RegionDescription"" type=""xs:string"" minOccurs=""0"" />" +
3763 @"</xs:complexType>" +
3766 @"</xs:complexType>" +
3769 Assert.AreEqual(expected4, TextString4.Replace("\r\n", "").Replace(" ", ""), "#4");
3774 [Category ("NotWorking")]
3776 public void ReadWriteXmlSchema_IgnoreSchema () {
3777 DataSet ds = new DataSet ();
3778 ds.ReadXmlSchema ("Test/System.Data/store.xsd");
3779 // check dataset properties before testing write
3780 AssertDataSet ("ds", ds, "NewDataSet", 3, 2);
3781 AssertDataTable ("tab1", ds.Tables[0], "bookstore", 1, 0, 0, 1, 1, 1);
3782 AssertDataTable ("tab2", ds.Tables[1], "book", 5, 0, 1, 1, 2, 1);
3783 AssertDataTable ("tab3", ds.Tables[2], "author", 3, 0, 1, 0, 1, 0);
3784 // FIXME: currently order is not compatible. Use name as index
3785 AssertDataRelation ("rel1", ds.Relations["book_author"], "book_author", true, new string[] { "book_Id" }, new string[] { "book_Id" }, true, true);
3786 AssertDataRelation ("rel2", ds.Relations["bookstore_book"], "bookstore_book", true, new string[] { "bookstore_Id" }, new string[] { "bookstore_Id" }, true, true);
3788 ds.ReadXml ("Test/System.Data/region.xml", XmlReadMode.IgnoreSchema);
3789 ds.Relations.Clear (); // because can not call WriteXmlSchema with nested relations.
3791 TextWriter writer1 = new StringWriter ();
3792 ds.Tables[0].WriteXmlSchema (writer1);
3793 //string TextString1 = GetNormalizedSchema (writer1.ToString ());
3794 string TextString1 = writer1.ToString ();
3795 string expected1 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3796 @"<xs:schema id=""NewDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3797 @"<xs:complexType name=""bookstoreType"">" +
3798 @"</xs:complexType>" +
3799 @"<xs:element name=""bookstore"" type=""bookstoreType"" />" +
3800 @"<xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""bookstore"" msdata:UseCurrentLocale=""true"">" +
3801 @"<xs:complexType>" +
3802 @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3803 @"<xs:element ref=""bookstore"" />" +
3805 @"</xs:complexType>" +
3808 Console.WriteLine ("{0} - {1}", TextString1, expected1);
3809 Assert.AreEqual (expected1, TextString1.Replace ("\r\n", "").Replace (" ", "").Replace ("\n", ""), "#1");
3811 TextWriter writer2 = new StringWriter ();
3812 ds.Tables[1].WriteXmlSchema (writer2, false);
3813 string TextString2 = GetNormalizedSchema (writer2.ToString ());
3814 string expected2 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3815 @"<xs:schema id=""NewDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3816 @"<xs:complexType name=""bookType"">" +
3818 @"<xs:element name=""title"" type=""xs:string"" msdata:Ordinal=""1"" />" +
3819 @"<xs:element name=""price"" type=""xs:decimal"" msdata:Ordinal=""2"" />" +
3821 @"<xs:attribute name=""genre"" type=""xs:string"" />" +
3822 @"<xs:attribute name=""bookstore_Id"" type=""xs:int"" use=""prohibited"" />" +
3823 @"</xs:complexType>" +
3824 @"<xs:element name=""book"" type=""bookType"" />" +
3825 @"<xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""book"" msdata:UseCurrentLocale=""true"">" +
3826 @"<xs:complexType>" +
3827 @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3828 @"<xs:element ref=""book"" />" +
3830 @"</xs:complexType>" +
3833 Assert.AreEqual (expected2, TextString2.Replace ("\r\n", "").Replace (" ", ""), "#2");
3835 TextWriter writer3 = new StringWriter ();
3836 ds.Tables[2].WriteXmlSchema (writer3);
3837 string TextString3 = GetNormalizedSchema (writer3.ToString ());
3838 string expected3 = @"<?xml version=""1.0"" encoding=""utf-16""?>" +
3839 @"<xs:schema id=""NewDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">" +
3840 @"<xs:complexType name=""authorName"">" +
3842 @"<xs:element name=""first-name"" type=""xs:string"" msdata:Ordinal=""0"" />" +
3843 @"<xs:element name=""last-name"" type=""xs:string"" msdata:Ordinal=""1"" />" +
3845 @"<xs:attribute name=""book_Id"" type=""xs:int"" use=""prohibited"" />" +
3846 @"</xs:complexType>" +
3847 @"<xs:element name=""author"" type=""authorName"" />" +
3848 @"<xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:MainDataTable=""author"" msdata:UseCurrentLocale=""true"">" +
3849 @"<xs:complexType>" +
3850 @"<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">" +
3851 @"<xs:element ref=""author"" />" +
3853 @"</xs:complexType>" +
3856 Assert.AreEqual (expected3, TextString3.Replace ("\r\n", "").Replace (" ", ""), "#3");
3858 TextWriter writer4 = new StringWriter ();
3861 ds.Tables[3].WriteXmlSchema (writer4);
3863 catch (Exception ex) {
3864 expStr = ex.Message;
3866 Assert.AreEqual ("Cannot find table 3.", expStr, "#4");
3870 public void ReadWriteXmlSchema_2 () {
3871 DataSet ds = new DataSet ("dataset");
3872 ds.Tables.Add ("table1");
3873 ds.Tables.Add ("table2");
3874 ds.Tables[0].Columns.Add ("col");
3875 ds.Tables[1].Columns.Add ("col");
3876 ds.Relations.Add ("rel", ds.Tables[0].Columns[0], ds.Tables[1].Columns[0], true);
3878 MemoryStream ms1 = new MemoryStream ();
3879 ds.Tables[0].WriteXmlSchema (ms1);
3880 MemoryStream ms2 = new MemoryStream ();
3881 ds.Tables[1].WriteXmlSchema (ms2);
3883 DataSet ds1 = new DataSet ();
3886 ds1.Tables[0].ReadXmlSchema (new MemoryStream (ms1.GetBuffer ()));
3887 ds1.Tables[1].ReadXmlSchema (new MemoryStream (ms2.GetBuffer ()));
3889 Assert.AreEqual (0, ds1.Relations.Count, "#1");
3890 Assert.AreEqual (1, ds1.Tables[0].Columns.Count, "#2");
3891 Assert.AreEqual (1, ds1.Tables[1].Columns.Count, "#3");
3895 [ExpectedException (typeof (XmlException))]
3896 public void ReadWriteXmlSchemaExp_NoRootElmnt () {
3897 MemoryStream ms = new MemoryStream ();
3898 DataTable dtr = new DataTable ();
3899 dtr.ReadXmlSchema (ms);
3903 [ExpectedException (typeof (InvalidOperationException))]
3904 public void ReadWriteXmlSchemaExp_NoTableName () {
3905 DataTable dtw = new DataTable ();
3906 MemoryStream ms = new MemoryStream ();
3907 dtw.WriteXmlSchema (ms);
3911 [ExpectedException (typeof (ArgumentException))]
3912 public void ReadWriteXmlSchemaExp_NoFileName () {
3913 DataTable dtw = new DataTable ();
3914 dtw.WriteXmlSchema ("");
3918 [ExpectedException (typeof (ArgumentException))]
3919 public void ReadWriteXmlSchemaExp_TableNameConflict () {
3920 DataTable dtw = new DataTable ("Table1");
3921 StringWriter writer1 = new StringWriter ();
3922 dtw.WriteXmlSchema (writer1);
3923 DataTable dtr = new DataTable ("Table2");
3924 StringReader reader1 = new StringReader (writer1.ToString());
3925 dtr.ReadXmlSchema (reader1);
3928 #endregion // Read/Write XML Tests
3935 public class MyDataTable:DataTable {
3937 public static int count = 0;
3939 public MyDataTable() {
3948 public class AppDomainsAndFormatInfo
3950 public void Remote ()
3952 int n = (int) Convert.ChangeType ("5", typeof (int));
3953 Assert.AreEqual (5, n, "n");
3957 public void NFIFromBug55978 ()
3959 AppDomain domain = AppDomain.CreateDomain ("testdomain");
3960 AppDomainsAndFormatInfo test = new AppDomainsAndFormatInfo ();
3962 domain.DoCallBack (new CrossAppDomainDelegate (test.Remote));
3963 AppDomain.Unload (domain);
3968 public void Bug55978 ()
3970 DataTable dt = new DataTable ();
3971 dt.Columns.Add ("StartDate", typeof (DateTime));
3974 DateTime date = DateTime.Now;
3976 for (int i = 0; i < 10; i++) {
3978 dr ["StartDate"] = date.AddDays (i);
3982 DataView dv = dt.DefaultView;
3983 dv.RowFilter = String.Format (CultureInfo.InvariantCulture,
3984 "StartDate >= '{0}' and StartDate <= '{1}'",
3985 DateTime.Now.AddDays (2),
3986 DateTime.Now.AddDays (4));
3987 Assert.AreEqual (10, dt.Rows.Count, "Table");
3988 Assert.AreEqual (2, dv.Count, "View");
3992 public void Bug82109 ()
3994 DataTable tbl = new DataTable ();
3995 tbl.Columns.Add ("data", typeof (DateTime));
3996 DataRow row = tbl.NewRow ();
3997 row ["Data"] = new DateTime (2007, 7, 1);
4000 CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;
4001 Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
4004 Thread.CurrentThread.CurrentCulture = new CultureInfo ("it-IT");
4007 Thread.CurrentThread.CurrentCulture = new CultureInfo ("fr-FR");
4009 Thread.CurrentThread.CurrentCulture = currentCulture;
4011 private static void Select (DataTable tbl)
4013 tbl.Locale = CultureInfo.InvariantCulture;
4014 string filter = string.Format ("Data = '{0}'", new DateTime (2007, 7,
4015 1).ToString (CultureInfo.InvariantCulture));
4016 DataRow [] rows = tbl.Select (filter);
4017 Assert.AreEqual (1, rows.Length, "Incorrect number of rows found");