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

   1 //\r
   2 // DataSetReadXmlSchemaTest.cs\r
   3 //\r
   4 // Author:\r
   5 //      Atsushi Enomoto <atsushi@ximian.com>\r
   6 //\r
   7
   8 //
   9 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30 \r
  31 \r
  32 using System;\r
  33 using System.IO;\r
  34 using System.Data;\r
  35 using System.Globalization;\r
  36 using System.Text;\r
  37 using System.Threading;\r
  38 using System.Xml;\r
  39 using NUnit.Framework;\r
  40 \r
  41 namespace MonoTests.System.Data\r
  42 {\r
  43         [TestFixture]\r
  44         public class DataSetReadXmlSchemaTest : DataSetAssertion\r
  45         {\r
  46                 private DataSet CreateTestSet ()\r
  47                 {\r
  48                         DataSet ds = new DataSet ();\r
  49                         ds.Tables.Add ("Table1");\r
  50                         ds.Tables.Add ("Table2");\r
  51                         ds.Tables [0].Columns.Add ("Column1_1");\r
  52                         ds.Tables [0].Columns.Add ("Column1_2");\r
  53                         ds.Tables [0].Columns.Add ("Column1_3");\r
  54                         ds.Tables [1].Columns.Add ("Column2_1");\r
  55                         ds.Tables [1].Columns.Add ("Column2_2");\r
  56                         ds.Tables [1].Columns.Add ("Column2_3");\r
  57                         ds.Tables [0].Rows.Add (new object [] {"ppp", "www", "xxx"});\r
  58                         ds.Relations.Add ("Rel1", ds.Tables [0].Columns [2], ds.Tables [1].Columns [0]);\r
  59                         return ds;\r
  60                 }\r
  61 \r
  62                 CultureInfo currentCultureBackup;\r
  63 \r
  64                 [SetUp]\r
  65                 public void Setup ()\r
  66                 {\r
  67                         currentCultureBackup = Thread.CurrentThread.CurrentCulture;\r
  68                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("fi-FI");\r
  69                 }\r
  70 \r
  71                 [TearDown]\r
  72                 public void Teardown ()\r
  73                 {\r
  74                         Thread.CurrentThread.CurrentCulture = currentCultureBackup;\r
  75                 }\r
  76 \r
  77                 [Test]\r
  78                 public void SingleElementTreatmentDifference ()\r
  79                 {\r
  80                         // This is one of the most complicated case. When the content\r
  81                         // type particle of 'Root' element is a complex element, it\r
  82                         // is DataSet element. Otherwise, it is just a data table.\r
  83                         //\r
  84                         // But also note that there is another test named\r
  85                         // LocaleOnRootWithoutIsDataSet(), that tests if locale on\r
  86                         // the (mere) data table modifies *DataSet's* locale.\r
  87 \r
  88                         // Moreover, when the schema contains another element\r
  89                         // (regardless of its schema type), the elements will\r
  90                         // never be treated as a DataSet.\r
  91                         string xsbase = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' id='hoge'>\r
  92         <xs:element name='Root'> <!-- When simple, it becomes table. When complex, it becomes DataSet -->\r
  93                 <xs:complexType>\r
  94                         <xs:choice>\r
  95                                 {0}\r
  96                         </xs:choice>\r
  97                 </xs:complexType>\r
  98         </xs:element>\r
  99 </xs:schema>";\r
 100 \r
 101                         string xsbase2 = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' id='hoge'>\r
 102         <xs:element name='Root'> <!-- When simple, it becomes table. When complex, it becomes DataSet -->\r
 103                 <xs:complexType>\r
 104                         <xs:choice>\r
 105                                 {0}\r
 106                         </xs:choice>\r
 107                 </xs:complexType>\r
 108         </xs:element>\r
 109         <xs:element name='more' type='xs:string' />\r
 110 </xs:schema>";\r
 111 \r
 112                         string simple = "<xs:element name='Child' type='xs:string' />";\r
 113                         string complex = @"<xs:element name='Child'>\r
 114         <xs:complexType>\r
 115                 <xs:attribute name='a1' />\r
 116                 <xs:attribute name='a2' type='xs:integer' />\r
 117         </xs:complexType>\r
 118 </xs:element>";\r
 119                         string elref = "<xs:element ref='more' />";\r
 120 \r
 121                         string xs2 = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' id='hoge'>\r
 122         <xs:element name='Root' type='RootType' />\r
 123         <xs:complexType name='RootType'>\r
 124                 <xs:choice>\r
 125                         <xs:element name='Child'>\r
 126                                 <xs:complexType>\r
 127                                         <xs:attribute name='a1' />\r
 128                                         <xs:attribute name='a2' type='xs:integer' />\r
 129                                 </xs:complexType>\r
 130                         </xs:element>\r
 131                 </xs:choice>\r
 132         </xs:complexType>\r
 133 </xs:schema>";\r
 134 \r
 135                         DataSet ds = new DataSet ();\r
 136 \r
 137                         string xs = String.Format (xsbase, simple);\r
 138                         ds.ReadXmlSchema (new StringReader (xs));\r
 139                         AssertDataSet ("simple", ds, "hoge", 1, 0);\r
 140                         AssertDataTable ("simple", ds.Tables [0], "Root", 1, 0, 0, 0, 0, 0);\r
 141 \r
 142                         // reference to global complex type\r
 143                         ds = new DataSet ();\r
 144                         ds.ReadXmlSchema (new StringReader (xs2));\r
 145                         AssertDataSet ("external complexType", ds, "hoge", 2, 1);\r
 146                         AssertDataTable ("external Tab1", ds.Tables [0], "Root", 1, 0, 0, 1, 1, 1);\r
 147                         AssertDataTable ("external Tab2", ds.Tables [1], "Child", 3, 0, 1, 0, 1, 0);\r
 148 \r
 149                         // xsbase2 + complex -> datatable\r
 150                         ds = new DataSet ();\r
 151                         xs = String.Format (xsbase2, complex);\r
 152                         ds.ReadXmlSchema (new StringReader (xs));\r
 153                         AssertDataSet ("complex", ds, "hoge", 2, 1);\r
 154                         AssertDataTable ("complex", ds.Tables [0], "Root", 1, 0, 0, 1, 1, 1);\r
 155                         DataTable dt = ds.Tables [1];\r
 156                         AssertDataTable ("complex", dt, "Child", 3, 0, 1, 0, 1, 0);\r
 157                         AssertDataColumn ("a1", dt.Columns ["a1"], "a1", true, false, 0, 1, "a1", MappingType.Attribute, typeof (string), DBNull.Value, String.Empty, -1, String.Empty, /*0*/-1, String.Empty, false, false);\r
 158                         AssertDataColumn ("a2", dt.Columns ["a2"], "a2", true, false, 0, 1, "a2", MappingType.Attribute, typeof (long), DBNull.Value, String.Empty, -1, String.Empty, /*1*/-1, String.Empty, false, false);\r
 159                         AssertDataColumn ("Root_Id", dt.Columns [2], "Root_Id", true, false, 0, 1, "Root_Id", MappingType.Hidden, typeof (int), DBNull.Value, String.Empty, -1, String.Empty, 2, String.Empty, false, false);\r
 160 \r
 161                         // xsbase + complex -> dataset\r
 162                         ds = new DataSet ();\r
 163                         xs = String.Format (xsbase, complex);\r
 164                         ds.ReadXmlSchema (new StringReader (xs));\r
 165                         AssertDataSet ("complex", ds, "Root", 1, 0);\r
 166 \r
 167                         ds = new DataSet ();\r
 168                         xs = String.Format (xsbase2, elref);\r
 169                         ds.ReadXmlSchema (new StringReader (xs));\r
 170                         AssertDataSet ("complex", ds, "hoge", 1, 0);\r
 171                         AssertDataTable ("complex", ds.Tables [0], "Root", 1, 0, 0, 0, 0, 0);\r
 172                 }\r
 173 \r
 174                 [Test]\r
 175                 public void SuspiciousDataSetElement ()\r
 176                 {\r
 177                         string schema = @"<?xml version='1.0'?>\r
 178 <xsd:schema xmlns:xsd='http://www.w3.org/2001/XMLSchema'>\r
 179         <xsd:attribute name='foo' type='xsd:string'/>\r
 180         <xsd:attribute name='bar' type='xsd:string'/>\r
 181         <xsd:complexType name='attRef'>\r
 182                 <xsd:attribute name='att1' type='xsd:int'/>\r
 183                 <xsd:attribute name='att2' type='xsd:string'/>\r
 184         </xsd:complexType>\r
 185         <xsd:element name='doc'>\r
 186                 <xsd:complexType>\r
 187                         <xsd:choice>\r
 188                                 <xsd:element name='elem' type='attRef'/>\r
 189                         </xsd:choice>\r
 190                 </xsd:complexType>\r
 191         </xsd:element>\r
 192 </xsd:schema>";\r
 193                         DataSet ds = new DataSet ();\r
 194                         ds.ReadXmlSchema (new StringReader (schema));\r
 195                         AssertDataSet ("ds", ds, "doc", 1, 0);\r
 196                         AssertDataTable ("table", ds.Tables [0], "elem", 2, 0, 0, 0, 0, 0);\r
 197                 }\r
 198 \r
 199                 [Test]\r
 200                 public void UnusedComplexTypesIgnored ()\r
 201                 {\r
 202                         string xs = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' id='hoge'>\r
 203         <xs:element name='Root'>\r
 204                 <xs:complexType>\r
 205                         <xs:sequence>\r
 206                                 <xs:element name='Child' type='xs:string' />\r
 207                         </xs:sequence>\r
 208                 </xs:complexType>\r
 209         </xs:element>\r
 210         <xs:complexType name='unusedType'>\r
 211                 <xs:sequence>\r
 212                         <xs:element name='Orphan' type='xs:string' />\r
 213                 </xs:sequence>\r
 214         </xs:complexType>\r
 215 </xs:schema>";\r
 216 \r
 217                         DataSet ds = new DataSet ();\r
 218                         ds.ReadXmlSchema (new StringReader (xs));\r
 219                         // Here "unusedType" table is never imported.\r
 220                         AssertDataSet ("ds", ds, "hoge", 1, 0);\r
 221                         AssertDataTable ("dt", ds.Tables [0], "Root", 1, 0, 0, 0, 0, 0);\r
 222                 }\r
 223 \r
 224                 [Test]\r
 225                 public void SimpleTypeComponentsIgnored ()\r
 226                 {\r
 227                         string xs = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>\r
 228         <xs:element name='Root' type='xs:string'/>\r
 229         <xs:attribute name='Attr' type='xs:string'/>\r
 230 </xs:schema>";\r
 231 \r
 232                         DataSet ds = new DataSet ();\r
 233                         ds.ReadXmlSchema (new StringReader (xs));\r
 234                         // nothing is imported.\r
 235                         AssertDataSet ("ds", ds, "NewDataSet", 0, 0);\r
 236                 }\r
 237 \r
 238                 [Test]\r
 239                 public void IsDataSetAndTypeIgnored ()\r
 240                 {\r
 241                         string xsbase = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata'>\r
 242         <xs:element name='Root' type='unusedType' msdata:IsDataSet='{0}'>\r
 243         </xs:element>\r
 244         <xs:complexType name='unusedType'>\r
 245                 <xs:sequence>\r
 246                         <xs:element name='Child' type='xs:string' />\r
 247                 </xs:sequence>\r
 248         </xs:complexType>\r
 249 </xs:schema>";\r
 250 \r
 251                         // Even if a global element uses a complexType, it will be\r
 252                         // ignored if the element has msdata:IsDataSet='true'\r
 253                         string xs = String.Format (xsbase, "true");\r
 254 \r
 255                         DataSet ds = new DataSet ();\r
 256                         ds.ReadXmlSchema (new StringReader (xs));\r
 257                         AssertDataSet ("ds", ds, "Root", 0, 0); // name is "Root"\r
 258 \r
 259                         // But when explicit msdata:IsDataSet value is "false", then\r
 260                         // treat as usual.\r
 261                         xs = String.Format (xsbase, "false");\r
 262 \r
 263                         ds = new DataSet ();\r
 264                         ds.ReadXmlSchema (new StringReader (xs));\r
 265                         AssertDataSet ("ds", ds, "NewDataSet", 1, 0);\r
 266                 }\r
 267 \r
 268                 [Test]\r
 269                 [ExpectedException (typeof (ArgumentException))]\r
 270                 public void NestedReferenceNotAllowed ()\r
 271                 {\r
 272                         string xs = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata'>\r
 273         <xs:element name='Root' type='unusedType' msdata:IsDataSet='true'>\r
 274         </xs:element>\r
 275         <xs:complexType name='unusedType'>\r
 276                 <xs:sequence>\r
 277                         <xs:element name='Child' type='xs:string' />\r
 278                 </xs:sequence>\r
 279         </xs:complexType>\r
 280         <xs:element name='Foo'>\r
 281                 <xs:complexType>\r
 282                         <xs:sequence>\r
 283                                 <xs:element ref='Root' />\r
 284                         </xs:sequence>\r
 285                 </xs:complexType>\r
 286         </xs:element>\r
 287 </xs:schema>";\r
 288 \r
 289                         // DataSet element cannot be converted into a DataTable.\r
 290                         // (i.e. cannot be referenced in any other elements)\r
 291                         DataSet ds = new DataSet ();\r
 292                         ds.ReadXmlSchema (new StringReader (xs));\r
 293                 }\r
 294 \r
 295                 [Test]\r
 296                 public void IsDataSetOnLocalElementIgnored ()\r
 297                 {\r
 298                         string xsbase = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata'>\r
 299         <xs:element name='Root' type='unusedType'>\r
 300         </xs:element>\r
 301         <xs:complexType name='unusedType'>\r
 302                 <xs:sequence>\r
 303                         <xs:element name='Child' type='xs:string' msdata:IsDataSet='True' />\r
 304                 </xs:sequence>\r
 305         </xs:complexType>\r
 306 </xs:schema>";\r
 307 \r
 308                         // msdata:IsDataSet does not affect even if the value is invalid\r
 309                         string xs = String.Format (xsbase, "true");\r
 310 \r
 311                         DataSet ds = new DataSet ();\r
 312                         ds.ReadXmlSchema (new StringReader (xs));\r
 313                         // Child should not be regarded as DataSet element\r
 314                         AssertDataSet ("ds", ds, "NewDataSet", 1, 0);\r
 315                 }\r
 316 \r
 317                 [Test]\r
 318                 public void LocaleOnRootWithoutIsDataSet ()\r
 319                 {\r
 320                         string xs = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata'>\r
 321         <xs:element name='Root' msdata:Locale='ja-JP'>\r
 322                 <xs:complexType>\r
 323                         <xs:sequence>\r
 324                                 <xs:element name='Child' type='xs:string' />\r
 325                         </xs:sequence>\r
 326                         <xs:attribute name='Attr' type='xs:integer' />\r
 327                 </xs:complexType>\r
 328         </xs:element>\r
 329 </xs:schema>";\r
 330 \r
 331                         DataSet ds = new DataSet ();\r
 332                         ds.ReadXmlSchema (new StringReader (xs));\r
 333                         AssertDataSet ("ds", ds, "NewDataSet", 1, 0);\r
 334                         AssertEquals ("fi-FI", ds.Locale.Name); // DataSet's Locale comes from current thread\r
 335                         DataTable dt = ds.Tables [0];\r
 336                         AssertDataTable ("dt", dt, "Root", 2, 0, 0, 0, 0, 0);\r
 337                         AssertEquals ("ja-JP", dt.Locale.Name); // DataTable's Locale comes from msdata:Locale\r
 338                         AssertDataColumn ("col1", dt.Columns [0], "Attr", true, false, 0, 1, "Attr", MappingType.Attribute, typeof (Int64), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, false);\r
 339                         AssertDataColumn ("col2", dt.Columns [1], "Child", false, false, 0, 1, "Child", MappingType.Element, typeof (string), DBNull.Value, String.Empty, -1, String.Empty, 1, String.Empty, false, false);\r
 340                 }\r
 341 \r
 342 \r
 343                 [Test]\r
 344                 public void ElementHasIdentityConstraint ()\r
 345                 {\r
 346                         string constraints = @"\r
 347                 <xs:key name='key'>\r
 348                         <xs:selector xpath='./any/string_is_OK/R1'/>\r
 349                         <xs:field xpath='Child2'/>\r
 350                 </xs:key>\r
 351                 <xs:keyref name='kref' refer='key'>\r
 352                         <xs:selector xpath='.//R2'/>\r
 353                         <xs:field xpath='Child2'/>\r
 354                 </xs:keyref>";\r
 355                         string xsbase = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata'>\r
 356         <xs:element name='DS' msdata:IsDataSet='true'>\r
 357                 <xs:complexType>\r
 358                         <xs:choice>\r
 359                                 <xs:element ref='R1' />\r
 360                                 <xs:element ref='R2' />\r
 361                         </xs:choice>\r
 362                 </xs:complexType>\r
 363                 {0}\r
 364         </xs:element>\r
 365         <xs:element name='R1' type='RootType'>\r
 366               {1}\r
 367         </xs:element>\r
 368         <xs:element name='R2' type='RootType'>\r
 369         </xs:element>\r
 370         <xs:complexType name='RootType'>\r
 371                 <xs:choice>\r
 372                         <xs:element name='Child1' type='xs:string'>\r
 373                                 {2}\r
 374                         </xs:element>\r
 375                         <xs:element name='Child2' type='xs:string' />\r
 376                 </xs:choice>\r
 377                 <xs:attribute name='Attr' type='xs:integer' />\r
 378         </xs:complexType>\r
 379 </xs:schema>";\r
 380 \r
 381                         // Constraints on DataSet element.\r
 382                         // Note that in xs:key xpath is crazy except for the last step\r
 383                         string xs = String.Format (xsbase, constraints, String.Empty, String.Empty);\r
 384                         DataSet ds = new DataSet ();\r
 385                         ds.ReadXmlSchema (new StringReader (xs));\r
 386                         AssertEquals (1, ds.Relations.Count);\r
 387 \r
 388                         // Constraints on another global element - just ignored\r
 389                         xs = String.Format (xsbase, String.Empty, constraints, String.Empty);\r
 390                         ds = new DataSet ();\r
 391                         ds.ReadXmlSchema (new StringReader (xs));\r
 392                         AssertEquals (0, ds.Relations.Count);\r
 393 \r
 394                         // Constraints on local element - just ignored\r
 395                         xs = String.Format (xsbase, String.Empty, String.Empty, constraints);\r
 396                         ds = new DataSet ();\r
 397                         ds.ReadXmlSchema (new StringReader (xs));\r
 398                         AssertEquals (0, ds.Relations.Count);\r
 399                 }\r
 400 \r
 401                 [Test]\r
 402                 public void PrefixedTargetNS ()\r
 403                 {\r
 404                         string xs = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' xmlns:x='urn:foo' targetNamespace='urn:foo' elementFormDefault='qualified'>\r
 405         <xs:element name='DS' msdata:IsDataSet='true'>\r
 406                 <xs:complexType>\r
 407                         <xs:choice>\r
 408                                 <xs:element ref='x:R1' />\r
 409                                 <xs:element ref='x:R2' />\r
 410                         </xs:choice>\r
 411                 </xs:complexType>\r
 412                 <xs:key name='key'>\r
 413                         <xs:selector xpath='./any/string_is_OK/x:R1'/>\r
 414                         <xs:field xpath='x:Child2'/>\r
 415                 </xs:key>\r
 416                 <xs:keyref name='kref' refer='x:key'>\r
 417                         <xs:selector xpath='.//x:R2'/>\r
 418                         <xs:field xpath='x:Child2'/>\r
 419                 </xs:keyref>\r
 420         </xs:element>\r
 421         <xs:element name='R3' type='x:RootType' />\r
 422         <xs:complexType name='extracted'>\r
 423                 <xs:choice>\r
 424                         <xs:element ref='x:R1' />\r
 425                         <xs:element ref='x:R2' />\r
 426                 </xs:choice>\r
 427         </xs:complexType>\r
 428         <xs:element name='R1' type='x:RootType'>\r
 429                 <xs:unique name='Rkey'>\r
 430                         <xs:selector xpath='.//x:Child1'/>\r
 431                         <xs:field xpath='.'/>\r
 432                 </xs:unique>\r
 433                 <xs:keyref name='Rkref' refer='x:Rkey'>\r
 434                         <xs:selector xpath='.//x:Child2'/>\r
 435                         <xs:field xpath='.'/>\r
 436                 </xs:keyref>\r
 437         </xs:element>\r
 438         <xs:element name='R2' type='x:RootType'>\r
 439         </xs:element>\r
 440         <xs:complexType name='RootType'>\r
 441                 <xs:choice>\r
 442                         <xs:element name='Child1' type='xs:string'>\r
 443                         </xs:element>\r
 444                         <xs:element name='Child2' type='xs:string' />\r
 445                 </xs:choice>\r
 446                 <xs:attribute name='Attr' type='xs:integer' />\r
 447         </xs:complexType>\r
 448 </xs:schema>";\r
 449                         // No prefixes on tables and columns\r
 450                         DataSet ds = new DataSet ();\r
 451                         ds.ReadXmlSchema (new StringReader (xs));\r
 452                         AssertDataSet ("ds", ds, "DS", 3, 1);\r
 453                         DataTable dt = ds.Tables [0];\r
 454                         AssertDataTable ("R3", dt, "R3", 3, 0, 0, 0, 0, 0);\r
 455                         AssertDataColumn ("col1", dt.Columns [0], "Attr", true, false, 0, 1, "Attr", MappingType.Attribute, typeof (Int64), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, false);\r
 456                 }\r
 457 \r
 458                 [Test]\r
 459                 public void ReadTest1 ()\r
 460                 {\r
 461                         DataSet ds = CreateTestSet ();\r
 462 \r
 463                         StringWriter sw = new StringWriter ();\r
 464                         ds.WriteXmlSchema (sw);\r
 465 \r
 466                         string schema = sw.ToString ();\r
 467 \r
 468                         // ReadXmlSchema()\r
 469                         ds = new DataSet ();\r
 470                         ds.ReadXmlSchema (new XmlTextReader (schema, XmlNodeType.Document, null));\r
 471                         ReadTest1Check (ds);\r
 472 \r
 473                         // ReadXml() should also be the same\r
 474                         ds = new DataSet ();\r
 475                         ds.ReadXml (new XmlTextReader (schema, XmlNodeType.Document, null));\r
 476                         ReadTest1Check (ds);\r
 477                 }\r
 478 \r
 479                 private void ReadTest1Check (DataSet ds)\r
 480                 {\r
 481                         AssertDataSet ("dataset", ds, "NewDataSet", 2, 1);\r
 482                         AssertDataTable ("tbl1", ds.Tables [0], "Table1", 3, 0, 0, 1, 1, 0);\r
 483                         AssertDataTable ("tbl2", ds.Tables [1], "Table2", 3, 0, 1, 0, 1, 0);\r
 484 \r
 485                         DataRelation rel = ds.Relations [0];\r
 486                         AssertDataRelation ("rel", rel, "Rel1", false,\r
 487                                 new string [] {"Column1_3"},\r
 488                                 new string [] {"Column2_1"}, true, true);\r
 489                         AssertUniqueConstraint ("uc", rel.ParentKeyConstraint, \r
 490                                 "Constraint1", false, new string [] {"Column1_3"});\r
 491                         AssertForeignKeyConstraint ("fk", rel.ChildKeyConstraint, "Rel1",\r
 492                                 AcceptRejectRule.None, Rule.Cascade, Rule.Cascade,\r
 493                                 new string [] {"Column2_1"}, \r
 494                                 new string [] {"Column1_3"});\r
 495                 }\r
 496 \r
 497                 [Test]\r
 498                 // 001-004\r
 499                 public void TestSampleFileNoTables ()\r
 500                 {\r
 501                         DataSet ds = new DataSet ();\r
 502                         ds.ReadXmlSchema ("Test/System.Data/schemas/test001.xsd");\r
 503                         AssertDataSet ("001", ds, "NewDataSet", 0, 0);\r
 504 \r
 505                         ds = new DataSet ();\r
 506                         ds.ReadXmlSchema ("Test/System.Data/schemas/test002.xsd");\r
 507                         AssertDataSet ("002", ds, "NewDataSet", 0, 0);\r
 508 \r
 509                         ds = new DataSet ();\r
 510                         ds.ReadXmlSchema ("Test/System.Data/schemas/test003.xsd");\r
 511                         AssertDataSet ("003", ds, "NewDataSet", 0, 0);\r
 512 \r
 513                         ds = new DataSet ();\r
 514                         ds.ReadXmlSchema ("Test/System.Data/schemas/test004.xsd");\r
 515                         AssertDataSet ("004", ds, "NewDataSet", 0, 0);\r
 516                 }\r
 517 \r
 518                 [Test]\r
 519                 public void TestSampleFileSimpleTables ()\r
 520                 {\r
 521                         DataSet ds = new DataSet ();\r
 522                         ds.ReadXmlSchema ("Test/System.Data/schemas/test005.xsd");\r
 523                         AssertDataSet ("005", ds, "NewDataSet", 1, 0);\r
 524                         DataTable dt = ds.Tables [0];\r
 525                         AssertDataTable ("tab", dt, "foo", 2, 0, 0, 0, 0, 0);\r
 526                         AssertDataColumn ("attr", dt.Columns [0], "attr", true, false, 0, 1, "attr", MappingType.Attribute, typeof (string), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, false);\r
 527                         AssertDataColumn ("text", dt.Columns [1], "foo_text", false, false, 0, 1, "foo_text", MappingType.SimpleContent, typeof (long), DBNull.Value, String.Empty, -1, String.Empty, 1, String.Empty, false, false);\r
 528 \r
 529                         ds = new DataSet ();\r
 530                         ds.ReadXmlSchema ("Test/System.Data/schemas/test006.xsd");\r
 531                         AssertDataSet ("006", ds, "NewDataSet", 1, 0);\r
 532                         dt = ds.Tables [0];\r
 533                         AssertDataTable ("tab", dt, "foo", 2, 0, 0, 0, 0, 0);\r
 534                         AssertDataColumn ("att1", dt.Columns ["att1"], "att1", true, false, 0, 1, "att1", MappingType.Attribute, typeof (string), DBNull.Value, String.Empty, -1, String.Empty, /*0*/-1, String.Empty, false, false);\r
 535                         AssertDataColumn ("att2", dt.Columns ["att2"], "att2", true, false, 0, 1, "att2", MappingType.Attribute, typeof (int), 2, String.Empty, -1, String.Empty, /*1*/-1, String.Empty, false, false);\r
 536                 }\r
 537 \r
 538                 [Test]\r
 539                 public void TestSampleFileComplexTables ()\r
 540                 {\r
 541                         // Nested simple type element\r
 542                         DataSet ds = new DataSet ();\r
 543                         ds.ReadXmlSchema ("Test/System.Data/schemas/test007.xsd");\r
 544                         AssertDataSet ("007", ds, "NewDataSet", 2, 1);\r
 545                         DataTable dt = ds.Tables [0];\r
 546                         AssertDataTable ("tab1", dt, "uno", 1, 0, 0, 1, 1, 1);\r
 547                         AssertDataColumn ("id", dt.Columns [0], "uno_Id", false, true, 0, 1, "uno_Id", MappingType.Hidden, typeof (int), DBNull.Value, String.Empty, -1, "urn:foo", 0, String.Empty, false, true);\r
 548 \r
 549                         dt = ds.Tables [1];\r
 550                         AssertDataTable ("tab2", dt, "des", 2, 0, 1, 0, 1, 0);\r
 551                         AssertDataColumn ("child", dt.Columns [0], "tres", false, false, 0, 1, "tres", MappingType.Element, typeof (string), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, false);\r
 552                         AssertDataColumn ("id", dt.Columns [1], "uno_Id", true, false, 0, 1, "uno_Id", MappingType.Hidden, typeof (int), DBNull.Value, String.Empty, -1, String.Empty, 1, String.Empty, false, false);\r
 553 \r
 554                         // External simple type element\r
 555                         ds = new DataSet ();\r
 556                         ds.ReadXmlSchema ("Test/System.Data/schemas/test008.xsd");\r
 557                         AssertDataSet ("008", ds, "NewDataSet", 2, 1);\r
 558                         dt = ds.Tables [0];\r
 559                         AssertDataTable ("tab1", dt, "uno", 1, 0, 0, 1, 1, 1);\r
 560                         AssertDataColumn ("id", dt.Columns [0], "uno_Id", false, true, 0, 1, "uno_Id", MappingType.Hidden, typeof (int), DBNull.Value, String.Empty, -1, "urn:foo", 0, String.Empty, false, true);\r
 561 \r
 562                         dt = ds.Tables [1];\r
 563                         AssertDataTable ("tab2", dt, "des", 2, 0, 1, 0, 1, 0);\r
 564                         AssertDataColumn ("child", dt.Columns [0], "tres", false, false, 0, 1, "tres", MappingType.Element, typeof (string), DBNull.Value, String.Empty, -1, "urn:foo", 0, String.Empty, false, false);\r
 565                         AssertDataColumn ("id", dt.Columns [1], "uno_Id", true, false, 0, 1, "uno_Id", MappingType.Hidden, typeof (int), DBNull.Value, String.Empty, -1, String.Empty, 1, String.Empty, false, false);\r
 566 \r
 567                 }\r
 568 \r
 569                 [Test]\r
 570                 [Category ("NotDotNet")]\r
 571                 // MS.NET has a bug on handling default value of referenced\r
 572                 // attribute.\r
 573                 public void TestSampleFileValueConstraints ()\r
 574                 {\r
 575                         DataSet ds = new DataSet ();\r
 576                         ds.ReadXmlSchema ("Test/System.Data/schemas/test009.xsd");\r
 577                         AssertDataSet ("009", ds, "NewDataSet", 2, 1);\r
 578 \r
 579                         DataTable dt = ds.Tables [0];\r
 580                         AssertDataTable ("tab1", dt, "uno", 2, 0, 0, 1, 1, 1);\r
 581                         AssertDataColumn ("global", dt.Columns [0], "global", true, false, 0, 1, "global", MappingType.Attribute, typeof (string), "er", String.Empty, -1, "urn:foo", 0, String.Empty, false, false);\r
 582                         AssertDataColumn ("id", dt.Columns [1], "uno_Id", false, true, 0, 1, "uno_Id", MappingType.Hidden, typeof (int), DBNull.Value, String.Empty, -1, "urn:foo", 1, String.Empty, false, true);\r
 583 \r
 584                         // Here "XmlSchemaComplexType.AttributeUses" does not \r
 585                         // always return attribute uses in a certain order, thus\r
 586                         // here Columns indexer is accessed by name (actually\r
 587                         // MS.NET returns "global" in prior to "local" for\r
 588                         // Columns[0], even though "local" is defined in prior.\r
 589                         dt = ds.Tables [1];\r
 590                         AssertDataTable ("dos", dt, "des", 4, 0, 1, 0, 1, 0);\r
 591                         AssertDataColumn ("dos.child", dt.Columns ["local"], "local", true, false, 0, 1, "local", MappingType.Attribute, typeof (string), "san", String.Empty, -1, String.Empty, /*0*/-1, String.Empty, false, false);\r
 592                         // LAMESPEC: (MS BUG) default value is overwritten, but MS.NET is ignorant of that.\r
 593 #if BUGGY_MS_COMPATIBLE\r
 594                         AssertDataColumn ("dos.global", dt.Columns ["global"], "global", true, false, 0, 1, "global", MappingType.Attribute, typeof (string), "er", String.Empty, -1, "urn:foo", /*1*/-1, String.Empty, false, false);\r
 595 #else\r
 596                         AssertDataColumn ("dos.global", dt.Columns ["global"], "global", true, false, 0, 1, "global", MappingType.Attribute, typeof (string), "si", String.Empty, -1, "urn:foo", /*1*/-1, String.Empty, false, false);\r
 597 #endif\r
 598                         AssertDataColumn ("dos.tres", dt.Columns [2], "tres", false, false, 0, 1, "tres", MappingType.Element, typeof (string), "yi", String.Empty, -1, "urn:foo", 2, String.Empty, false, false);\r
 599                         AssertDataColumn ("uno.id", dt.Columns [3], "uno_Id", true, false, 0, 1, "uno_Id", MappingType.Hidden, typeof (int), DBNull.Value, String.Empty, -1, String.Empty, 3, String.Empty, false, false);\r
 600 \r
 601                         AssertDataRelation ("rel", ds.Relations [0], "uno_des", true, new string [] {"uno_Id"}, new string [] {"uno_Id"}, true, true);\r
 602                 }\r
 603 \r
 604                 [Test]\r
 605                 public void TestSampleFileImportSimple ()\r
 606                 {\r
 607                         DataSet ds = new DataSet ();\r
 608                         ds.ReadXmlSchema ("Test/System.Data/schemas/test010.xsd");\r
 609                         AssertDataSet ("010", ds, "NewDataSet", 1, 0);\r
 610 \r
 611                         DataTable dt = ds.Tables [0];\r
 612                         AssertDataTable ("root", dt, "foo", 1, 0, 0, 0, 0, 0);\r
 613                         AssertDataColumn ("simple", dt.Columns [0], "bar", false, false, 0, 1, "bar", MappingType.Element, typeof (string), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, false);\r
 614                 }\r
 615 \r
 616                 [Test]\r
 617                 public void TestSampleFileComplexTables2 ()\r
 618                 {\r
 619                         DataSet ds = new DataSet ();\r
 620                         ds.ReadXmlSchema ("Test/System.Data/schemas/test011.xsd");\r
 621                         AssertDataSet ("011", ds, "NewDataSet", 2, 1);\r
 622 \r
 623                         DataTable dt = ds.Tables [0];\r
 624                         AssertDataTable ("root", dt, "e", 3, 0, 1, 0, 1, 0);\r
 625                         AssertDataColumn ("attr", dt.Columns [0], "a", true, false, 0, 1, "a", MappingType.Attribute, typeof (string), DBNull.Value, String.Empty, -1, "http://xsdtesting", 0, String.Empty, false, false);\r
 626                         AssertDataColumn ("simple", dt.Columns [1], "e_text", false, false, 0, 1, "e_text", MappingType.SimpleContent, typeof (decimal), DBNull.Value, String.Empty, -1, "http://xsdtesting", 1, String.Empty, false, false);\r
 627                         AssertDataColumn ("hidden", dt.Columns [2], "root_Id", true, false, 0, 1, "root_Id", MappingType.Hidden, typeof (int), DBNull.Value, String.Empty, -1, "http://xsdtesting", 2, String.Empty, false, false);\r
 628 \r
 629                         dt = ds.Tables [1];\r
 630                         AssertDataTable ("root", dt, "root", 1, 0, 0, 1, 1, 1);\r
 631                         AssertDataColumn ("elem", dt.Columns [0], "root_Id", false, true, 0, 1, "root_Id", MappingType.Hidden, typeof (int), DBNull.Value, String.Empty, -1, "http://xsdtesting", 0, String.Empty, false, true);\r
 632 \r
 633                         AssertDataRelation ("rel", ds.Relations [0], "root_e", true, new string [] {"root_Id"}, new string [] {"root_Id"}, true, true);\r
 634                 }\r
 635 \r
 636                 [Test]\r
 637                 public void TestSampleFileComplexTables3 ()\r
 638                 {\r
 639                         DataSet ds = new DataSet ();\r
 640                         ds.ReadXmlSchema ("Test/System.Data/schemas/test013.xsd");\r
 641                         AssertDataSet ("013", ds, "root", 1, 0);\r
 642 \r
 643                         DataTable dt = ds.Tables [0];\r
 644                         AssertDataTable ("root", dt, "e", 2, 0, 0, 0, 0, 0);\r
 645                         AssertDataColumn ("attr", dt.Columns [0], "a", true, false, 0, 1, "a", MappingType.Attribute, typeof (string), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, false);\r
 646                         AssertDataColumn ("simple", dt.Columns [1], "e_text", false, false, 0, 1, "e_text", MappingType.SimpleContent, typeof (decimal), DBNull.Value, String.Empty, -1, String.Empty, 1, String.Empty, false, false);\r
 647                 }\r
 648 \r
 649                 // bug #58744\r
 650                 [Test]\r
 651                 public void TestSampleFileXPath ()\r
 652                 {\r
 653                         DataSet ds = new DataSet ();\r
 654                         ds.ReadXmlSchema ("Test/System.Data/schemas/test103.xsd");\r
 655                 }\r
 656 \r
 657                 [Test]\r
 658                 public void TestAnnotatedRelation1 ()\r
 659                 {\r
 660                         DataSet ds = new DataSet ();\r
 661                         ds.ReadXmlSchema ("Test/System.Data/schemas/test101.xsd");\r
 662                         AssertDataSet ("101", ds, "root", 2, 1);\r
 663                         DataTable dt = ds.Tables [0];\r
 664                         AssertDataTable ("parent_table", dt, "p", 2, 0, 0, 1, 0, 0);\r
 665                         AssertDataColumn ("pk", dt.Columns [0], "pk", false, false, 0, 1, "pk", MappingType.Element, typeof (string), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, false);\r
 666 \r
 667                         dt = ds.Tables [1];\r
 668                         AssertDataTable ("child_table", dt, "c", 2, 0, 1, 0, 0, 0);\r
 669                         AssertDataColumn ("fk", dt.Columns [0], "fk", false, false, 0, 1, "fk", MappingType.Element, typeof (string), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, false);\r
 670 \r
 671                         AssertDataRelation ("rel", ds.Relations [0], "rel", false, new string [] {"pk"}, new string [] {"fk"}, false, false);\r
 672                 }\r
 673 \r
 674                 [Test]\r
 675                 public void TestAnnotatedRelation2 ()\r
 676                 {\r
 677                         DataSet ds = new DataSet ();\r
 678                         ds.ReadXmlSchema ("Test/System.Data/schemas/test102.xsd");\r
 679                         AssertDataSet ("102", ds, "ds", 2, 1);\r
 680                         DataTable dt = ds.Tables [0];\r
 681                         AssertDataTable ("parent_table", dt, "p", 2, 0, 0, 1, 0, 0);\r
 682                         AssertDataColumn ("pk", dt.Columns [0], "pk", false, false, 0, 1, "pk", MappingType.Element, typeof (string), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, false);\r
 683 \r
 684                         dt = ds.Tables [1];\r
 685                         AssertDataTable ("child_table", dt, "c", 2, 0, 1, 0, 0, 0);\r
 686                         AssertDataColumn ("fk", dt.Columns [0], "fk", false, false, 0, 1, "fk", MappingType.Element, typeof (string), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, false);\r
 687 \r
 688                         AssertDataRelation ("rel", ds.Relations [0], "rel", true, new string [] {"pk"}, new string [] {"fk"}, false, false);\r
 689                 }\r
 690 \r
 691                 [Test]\r
 692                 public void RepeatableSimpleElement ()\r
 693                 {\r
 694                         DataSet ds = new DataSet ();\r
 695                         ds.ReadXmlSchema ("Test/System.Data/schemas/test012.xsd");\r
 696                         AssertDataSet ("012", ds, "NewDataSet", 2, 1);\r
 697                         DataTable dt = ds.Tables [0];\r
 698                         AssertDataTable ("parent", dt, "Foo", 1, 0, 0, 1, 1, 1);\r
 699                         AssertDataColumn ("key", dt.Columns [0], "Foo_Id", false, true, 0, 1, "Foo_Id", MappingType.Hidden, typeof (int), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, true);\r
 700 \r
 701                         dt = ds.Tables [1];\r
 702                         AssertDataTable ("repeated", dt, "Bar", 2, 0, 1, 0, 1, 0);\r
 703                         AssertDataColumn ("data", dt.Columns [0], "Bar_Column", false, false, 0, 1, "Bar_Column", MappingType.SimpleContent, typeof (string), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, false);\r
 704                         AssertDataColumn ("refkey", dt.Columns [1], "Foo_Id", true, false, 0, 1, "Foo_Id", MappingType.Hidden, typeof (int), DBNull.Value, String.Empty, -1, String.Empty, 1, String.Empty, false, false);\r
 705 \r
 706                         AssertDataRelation ("rel", ds.Relations [0], "Foo_Bar", true, new string [] {"Foo_Id"}, new string [] {"Foo_Id"}, true, true);\r
 707                 }\r
 708 \r
 709                 [Test]\r
 710                 public void TestMoreThanOneRepeatableColumns ()\r
 711                 {\r
 712                         DataSet ds = new DataSet ();\r
 713                         ds.ReadXmlSchema ("Test/System.Data/schemas/test014.xsd");\r
 714                         AssertDataSet ("014", ds, "NewDataSet", 3, 2);\r
 715 \r
 716                         DataTable dt = ds.Tables [0];\r
 717                         AssertDataTable ("parent", dt, "root", 1, 0, 0, 2, 1, 1);\r
 718                         AssertDataColumn ("key", dt.Columns [0], "root_Id", false, true, 0, 1, "root_Id", MappingType.Hidden, typeof (int), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, true);\r
 719 \r
 720                         dt = ds.Tables [1];\r
 721                         AssertDataTable ("repeated", dt, "x", 2, 0, 1, 0, 1, 0);\r
 722                         AssertDataColumn ("data_1", dt.Columns [0], "x_Column", false, false, 0, 1, "x_Column", MappingType.SimpleContent, typeof (string), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, false);\r
 723                         AssertDataColumn ("refkey_1", dt.Columns [1], "root_Id", true, false, 0, 1, "root_Id", MappingType.Hidden, typeof (int), DBNull.Value, String.Empty, -1, String.Empty, 1, String.Empty, false, false);\r
 724 \r
 725                         dt = ds.Tables [2];\r
 726                         AssertDataTable ("repeated", dt, "y", 2, 0, 1, 0, 1, 0);\r
 727                         AssertDataColumn ("data", dt.Columns [0], "y_Column", false, false, 0, 1, "y_Column", MappingType.SimpleContent, typeof (string), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, false);\r
 728                         AssertDataColumn ("refkey", dt.Columns [1], "root_Id", true, false, 0, 1, "root_Id", MappingType.Hidden, typeof (int), DBNull.Value, String.Empty, -1, String.Empty, 1, String.Empty, false, false);\r
 729 \r
 730                         AssertDataRelation ("rel", ds.Relations [0], "root_x", true, new string [] {"root_Id"}, new string [] {"root_Id"}, true, true);\r
 731 \r
 732                         AssertDataRelation ("rel", ds.Relations [1], "root_y", true, new string [] {"root_Id"}, new string [] {"root_Id"}, true, true);\r
 733                 }\r
 734 \r
 735                 [Test]\r
 736                 public void AutoIncrementStep ()\r
 737                 {\r
 738                         DataSet ds = new DataSet("testds");\r
 739                         DataTable tbl = ds.Tables.Add("testtbl");\r
 740                         DataColumn col = tbl.Columns.Add("id", typeof(int));\r
 741                         col.AutoIncrement = true;\r
 742                         col.AutoIncrementSeed = -1;\r
 743                         col.AutoIncrementStep = -1;\r
 744                         tbl.Columns.Add("data", typeof(string));\r
 745                         Assert (ds.GetXmlSchema ().IndexOf ("AutoIncrementStep") > 0);\r
 746                 }\r
 747         }\r
 748 }\r