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

   1 //\r
   2 // DataSetReadXmlTest.cs\r
   3 //\r
   4 // Author:\r
   5 //      Atsushi Enomoto <atsushi@ximian.com>\r
   6 //\r
   7 \r
   8 //\r
   9 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)\r
  10 //\r
  11 // Permission is hereby granted, free of charge, to any person obtaining\r
  12 // a copy of this software and associated documentation files (the\r
  13 // "Software"), to deal in the Software without restriction, including\r
  14 // without limitation the rights to use, copy, modify, merge, publish,\r
  15 // distribute, sublicense, and/or sell copies of the Software, and to\r
  16 // permit persons to whom the Software is furnished to do so, subject to\r
  17 // the following conditions:\r
  18 // \r
  19 // The above copyright notice and this permission notice shall be\r
  20 // included in all copies or substantial portions of the Software.\r
  21 // \r
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\r
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\r
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\r
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  29 //\r
  30 \r
  31 using System;\r
  32 using System.Data;\r
  33 using System.IO;\r
  34 using System.Text;\r
  35 using System.Xml;\r
  36 using System.Xml.Serialization;\r
  37 \r
  38 using NUnit.Framework;\r
  39 \r
  40 namespace MonoTests.System.Data\r
  41 {\r
  42         [TestFixture]\r
  43         public class DataSetReadXmlTest : DataSetAssertion\r
  44         {\r
  45                 const string xml1 = "";\r
  46                 const string xml2 = "<root/>";\r
  47                 const string xml3 = "<root></root>";\r
  48                 const string xml4 = "<root>   </root>";\r
  49                 const string xml5 = "<root>test</root>";\r
  50                 const string xml6 = "<root><test>1</test></root>";\r
  51                 const string xml7 = "<root><test>1</test><test2>a</test2></root>";\r
  52                 const string xml8 = "<dataset><table><col1>foo</col1><col2>bar</col2></table></dataset>";\r
  53                 const string xml29 = @"<PersonalSite><License Name='Sum Wang' Email='sumwang@somewhere.net' Mode='Trial' StartDate='01/01/2004' Serial='aaa' /></PersonalSite>";\r
  54 \r
  55                 const string diff1 = @"<diffgr:diffgram xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' xmlns:diffgr='urn:schemas-microsoft-com:xml-diffgram-v1'>\r
  56   <NewDataSet>\r
  57     <Table1 diffgr:id='Table11' msdata:rowOrder='0' diffgr:hasChanges='inserted'>\r
  58       <Column1_1>ppp</Column1_1>\r
  59       <Column1_2>www</Column1_2>\r
  60       <Column1_3>xxx</Column1_3>\r
  61     </Table1>\r
  62   </NewDataSet>\r
  63 </diffgr:diffgram>";\r
  64                 const string diff2 = diff1 + xml8;\r
  65 \r
  66                 const string schema1 = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>\r
  67         <xs:element name='Root'>\r
  68                 <xs:complexType>\r
  69                         <xs:sequence>\r
  70                                 <xs:element name='Child' type='xs:string' />\r
  71                         </xs:sequence>\r
  72                 </xs:complexType>\r
  73         </xs:element>\r
  74 </xs:schema>";\r
  75                 const string schema2 = schema1 + xml8;\r
  76 \r
  77                 [Test]\r
  78                 public void ReadSimpleAuto ()\r
  79                 {\r
  80                         DataSet ds;\r
  81 \r
  82                         // empty XML\r
  83                         ds = new DataSet ();\r
  84                         AssertReadXml (ds, "EmptyString", xml1,\r
  85                                 XmlReadMode.Auto, XmlReadMode.Auto,\r
  86                                 "NewDataSet", 0);\r
  87 \r
  88                         // simple element\r
  89                         ds = new DataSet ();\r
  90                         AssertReadXml (ds, "EmptyElement", xml2,\r
  91                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
  92                                 "root", 0);\r
  93 \r
  94                         // simple element2\r
  95                         ds = new DataSet ();\r
  96                         AssertReadXml (ds, "StartEndTag", xml3,\r
  97                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
  98                                 "root", 0);\r
  99 \r
 100                         // whitespace in simple element\r
 101                         ds = new DataSet ();\r
 102                         AssertReadXml (ds, "Whitespace", xml4,\r
 103                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 104                                 "root", 0);\r
 105 \r
 106                         // text in simple element\r
 107                         ds = new DataSet ();\r
 108                         AssertReadXml (ds, "SingleText", xml5,\r
 109                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 110                                 "root", 0);\r
 111 \r
 112                         // simple table pattern:\r
 113                         // root becomes a table and test becomes a column.\r
 114                         ds = new DataSet ();\r
 115                         AssertReadXml (ds, "SimpleTable", xml6,\r
 116                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 117                                 "NewDataSet", 1);\r
 118                         AssertDataTable ("xml6", ds.Tables [0], "root", 1, 1, 0, 0, 0, 0);\r
 119 \r
 120                         // simple table with 2 columns:\r
 121                         ds = new DataSet ();\r
 122                         AssertReadXml (ds, "SimpleTable2", xml7,\r
 123                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 124                                 "NewDataSet", 1);\r
 125                         AssertDataTable ("xml7", ds.Tables [0], "root", 2, 1, 0, 0, 0, 0);\r
 126 \r
 127                         // simple dataset with 1 table:\r
 128                         ds = new DataSet ();\r
 129                         AssertReadXml (ds, "SimpleDataSet", xml8,\r
 130                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 131                                 "dataset", 1);\r
 132                         AssertDataTable ("xml8", ds.Tables [0], "table", 2, 1, 0, 0, 0, 0);\r
 133                 }\r
 134 \r
 135                 [Test]\r
 136                 public void ReadSimpleDiffgram ()\r
 137                 {\r
 138                         DataSet ds;\r
 139 \r
 140                         // empty XML\r
 141                         ds = new DataSet ();\r
 142                         AssertReadXml (ds, "EmptyString", xml1,\r
 143                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 144                                 "NewDataSet", 0);\r
 145 \r
 146                         // simple element\r
 147                         ds = new DataSet ();\r
 148                         AssertReadXml (ds, "EmptyElement", xml2,\r
 149                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 150                                 "NewDataSet", 0);\r
 151 \r
 152                         // simple element2\r
 153                         ds = new DataSet ();\r
 154                         AssertReadXml (ds, "StartEndTag", xml3,\r
 155                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 156                                 "NewDataSet", 0);\r
 157 \r
 158                         // whitespace in simple element\r
 159                         ds = new DataSet ();\r
 160                         AssertReadXml (ds, "Whitespace", xml4,\r
 161                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 162                                 "NewDataSet", 0);\r
 163 \r
 164                         // text in simple element\r
 165                         ds = new DataSet ();\r
 166                         AssertReadXml (ds, "SingleText", xml5,\r
 167                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 168                                 "NewDataSet", 0);\r
 169 \r
 170                         // simple table pattern:\r
 171                         ds = new DataSet ();\r
 172                         AssertReadXml (ds, "SimpleTable", xml6,\r
 173                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 174                                 "NewDataSet", 0);\r
 175 \r
 176                         // simple table with 2 columns:\r
 177                         ds = new DataSet ();\r
 178                         AssertReadXml (ds, "SimpleTable2", xml7,\r
 179                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 180                                 "NewDataSet", 0);\r
 181 \r
 182                         // simple dataset with 1 table:\r
 183                         ds = new DataSet ();\r
 184                         AssertReadXml (ds, "SimpleDataSet", xml8,\r
 185                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 186                                 "NewDataSet", 0);\r
 187                 }\r
 188 \r
 189                 [Test]\r
 190                 public void ReadSimpleFragment ()\r
 191                 {\r
 192                         DataSet ds;\r
 193 \r
 194                         // empty XML\r
 195                         ds = new DataSet ();\r
 196                         AssertReadXml (ds, "EmptyString", xml1,\r
 197                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 198                                 "NewDataSet", 0);\r
 199 \r
 200                         // simple element\r
 201                         ds = new DataSet ();\r
 202                         AssertReadXml (ds, "EmptyElement", xml2,\r
 203                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 204                                 "NewDataSet", 0);\r
 205 \r
 206                         // simple element2\r
 207                         ds = new DataSet ();\r
 208                         AssertReadXml (ds, "StartEndTag", xml3,\r
 209                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 210                                 "NewDataSet", 0);\r
 211 \r
 212                         // whitespace in simple element\r
 213                         ds = new DataSet ();\r
 214                         AssertReadXml (ds, "Whitespace", xml4,\r
 215                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 216                                 "NewDataSet", 0);\r
 217 \r
 218                         // text in simple element\r
 219                         ds = new DataSet ();\r
 220                         AssertReadXml (ds, "SingleText", xml5,\r
 221                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 222                                 "NewDataSet", 0);\r
 223 \r
 224                         // simple table pattern:\r
 225                         ds = new DataSet ();\r
 226                         AssertReadXml (ds, "SimpleTable", xml6,\r
 227                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 228                                 "NewDataSet", 0);\r
 229 \r
 230                         // simple table with 2 columns:\r
 231                         ds = new DataSet ();\r
 232                         AssertReadXml (ds, "SimpleTable2", xml7,\r
 233                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 234                                 "NewDataSet", 0);\r
 235 \r
 236                         // simple dataset with 1 table:\r
 237                         ds = new DataSet ();\r
 238                         AssertReadXml (ds, "SimpleDataSet", xml8,\r
 239                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 240                                 "NewDataSet", 0);\r
 241                 }\r
 242 \r
 243                 [Test]\r
 244                 public void ReadSimpleIgnoreSchema ()\r
 245                 {\r
 246                         DataSet ds;\r
 247 \r
 248                         // empty XML\r
 249                         ds = new DataSet ();\r
 250                         AssertReadXml (ds, "EmptyString", xml1,\r
 251                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 252                                 "NewDataSet", 0);\r
 253 \r
 254                         // simple element\r
 255                         ds = new DataSet ();\r
 256                         AssertReadXml (ds, "EmptyElement", xml2,\r
 257                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 258                                 "NewDataSet", 0);\r
 259 \r
 260                         // simple element2\r
 261                         ds = new DataSet ();\r
 262                         AssertReadXml (ds, "StartEndTag", xml3,\r
 263                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 264                                 "NewDataSet", 0);\r
 265 \r
 266                         // whitespace in simple element\r
 267                         ds = new DataSet ();\r
 268                         AssertReadXml (ds, "Whitespace", xml4,\r
 269                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 270                                 "NewDataSet", 0);\r
 271 \r
 272                         // text in simple element\r
 273                         ds = new DataSet ();\r
 274                         AssertReadXml (ds, "SingleText", xml5,\r
 275                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 276                                 "NewDataSet", 0);\r
 277 \r
 278                         // simple table pattern:\r
 279                         ds = new DataSet ();\r
 280                         AssertReadXml (ds, "SimpleTable", xml6,\r
 281                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 282                                 "NewDataSet", 0);\r
 283 \r
 284                         // simple table with 2 columns:\r
 285                         ds = new DataSet ();\r
 286                         AssertReadXml (ds, "SimpleTable2", xml7,\r
 287                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 288                                 "NewDataSet", 0);\r
 289 \r
 290                         // simple dataset with 1 table:\r
 291                         ds = new DataSet ();\r
 292                         AssertReadXml (ds, "SimpleDataSet", xml8,\r
 293                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 294                                 "NewDataSet", 0);\r
 295                 }\r
 296 \r
 297                 [Test]\r
 298                 public void ReadSimpleInferSchema ()\r
 299                 {\r
 300                         DataSet ds;\r
 301 \r
 302                         // empty XML\r
 303                         ds = new DataSet ();\r
 304                         AssertReadXml (ds, "EmptyString", xml1,\r
 305                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 306                                 "NewDataSet", 0);\r
 307 \r
 308                         // simple element\r
 309                         ds = new DataSet ();\r
 310                         AssertReadXml (ds, "EmptyElement", xml2,\r
 311                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 312                                 "root", 0);\r
 313 \r
 314                         // simple element2\r
 315                         ds = new DataSet ();\r
 316                         AssertReadXml (ds, "StartEndTag", xml3,\r
 317                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 318                                 "root", 0);\r
 319 \r
 320                         // whitespace in simple element\r
 321                         ds = new DataSet ();\r
 322                         AssertReadXml (ds, "Whitespace", xml4,\r
 323                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 324                                 "root", 0);\r
 325 \r
 326                         // text in simple element\r
 327                         ds = new DataSet ();\r
 328                         AssertReadXml (ds, "SingleText", xml5,\r
 329                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 330                                 "root", 0);\r
 331 \r
 332                         // simple table pattern:\r
 333                         // root becomes a table and test becomes a column.\r
 334                         ds = new DataSet ();\r
 335                         AssertReadXml (ds, "SimpleTable", xml6,\r
 336                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 337                                 "NewDataSet", 1);\r
 338                         AssertDataTable ("xml6", ds.Tables [0], "root", 1, 1, 0, 0, 0, 0);\r
 339 \r
 340                         // simple table with 2 columns:\r
 341                         ds = new DataSet ();\r
 342                         AssertReadXml (ds, "SimpleTable2", xml7,\r
 343                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 344                                 "NewDataSet", 1);\r
 345                         AssertDataTable ("xml7", ds.Tables [0], "root", 2, 1, 0, 0, 0, 0);\r
 346 \r
 347                         // simple dataset with 1 table:\r
 348                         ds = new DataSet ();\r
 349                         AssertReadXml (ds, "SimpleDataSet", xml8,\r
 350                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 351                                 "dataset", 1);\r
 352                         AssertDataTable ("xml8", ds.Tables [0], "table", 2, 1, 0, 0, 0, 0);\r
 353                 }\r
 354 \r
 355                 [Test]\r
 356                 public void ReadSimpleReadSchema ()\r
 357                 {\r
 358                         DataSet ds;\r
 359 \r
 360                         // empty XML\r
 361                         ds = new DataSet ();\r
 362                         AssertReadXml (ds, "EmptyString", xml1,\r
 363                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 364                                 "NewDataSet", 0);\r
 365 \r
 366                         // simple element\r
 367                         ds = new DataSet ();\r
 368                         AssertReadXml (ds, "EmptyElement", xml2,\r
 369                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 370                                 "NewDataSet", 0);\r
 371 \r
 372                         // simple element2\r
 373                         ds = new DataSet ();\r
 374                         AssertReadXml (ds, "StartEndTag", xml3,\r
 375                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 376                                 "NewDataSet", 0);\r
 377 \r
 378                         // whitespace in simple element\r
 379                         ds = new DataSet ();\r
 380                         AssertReadXml (ds, "Whitespace", xml4,\r
 381                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 382                                 "NewDataSet", 0);\r
 383 \r
 384                         // text in simple element\r
 385                         ds = new DataSet ();\r
 386                         AssertReadXml (ds, "SingleText", xml5,\r
 387                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 388                                 "NewDataSet", 0);\r
 389 \r
 390                         // simple table pattern:\r
 391                         ds = new DataSet ();\r
 392                         AssertReadXml (ds, "SimpleTable", xml6,\r
 393                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 394                                 "NewDataSet", 0);\r
 395 \r
 396                         // simple table with 2 columns:\r
 397                         ds = new DataSet ();\r
 398                         AssertReadXml (ds, "SimpleTable2", xml7,\r
 399                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 400                                 "NewDataSet", 0);\r
 401 \r
 402                         // simple dataset with 1 table:\r
 403                         ds = new DataSet ();\r
 404                         AssertReadXml (ds, "SimpleDataSet", xml8,\r
 405                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 406                                 "NewDataSet", 0);\r
 407                 }\r
 408 \r
 409                 [Test]\r
 410                 public void TestSimpleDiffXmlAll ()\r
 411                 {\r
 412                         DataSet ds;\r
 413 \r
 414                         // ignored\r
 415                         ds = new DataSet ();\r
 416                         AssertReadXml (ds, "Fragment", diff1,\r
 417                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 418                                 "NewDataSet", 0);\r
 419 \r
 420                         ds = new DataSet ();\r
 421                         AssertReadXml (ds, "IgnoreSchema", diff1,\r
 422                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 423                                 "NewDataSet", 0);\r
 424 \r
 425                         ds = new DataSet ();\r
 426                         AssertReadXml (ds, "InferSchema", diff1,\r
 427                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 428                                 "NewDataSet", 0);\r
 429 \r
 430                         ds = new DataSet ();\r
 431                         AssertReadXml (ds, "ReadSchema", diff1,\r
 432                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 433                                 "NewDataSet", 0);\r
 434 \r
 435                         // Auto, DiffGram ... treated as DiffGram\r
 436                         ds = new DataSet ();\r
 437                         AssertReadXml (ds, "Auto", diff1,\r
 438                                 XmlReadMode.Auto, XmlReadMode.DiffGram,\r
 439                                 "NewDataSet", 0);\r
 440 \r
 441                         ds = new DataSet ();\r
 442                         AssertReadXml (ds, "DiffGram", diff1,\r
 443                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 444                                 "NewDataSet", 0);\r
 445                 }\r
 446 \r
 447                 [Test]\r
 448                 public void TestSimpleDiffPlusContentAll ()\r
 449                 {\r
 450                         DataSet ds;\r
 451 \r
 452                         // Fragment ... skipped\r
 453                         ds = new DataSet ();\r
 454                         AssertReadXml (ds, "Fragment", diff2,\r
 455                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 456                                 "NewDataSet", 0);\r
 457 \r
 458                         // others ... kept \r
 459                         ds = new DataSet ();\r
 460                         AssertReadXml (ds, "IgnoreSchema", diff2,\r
 461                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 462                                 "NewDataSet", 0, ReadState.Interactive);\r
 463 \r
 464                         ds = new DataSet ();\r
 465                         AssertReadXml (ds, "InferSchema", diff2,\r
 466                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 467                                 "NewDataSet", 0, ReadState.Interactive);\r
 468 \r
 469                         ds = new DataSet ();\r
 470                         AssertReadXml (ds, "ReadSchema", diff2,\r
 471                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 472                                 "NewDataSet", 0, ReadState.Interactive);\r
 473 \r
 474                         // Auto, DiffGram ... treated as DiffGram\r
 475                         ds = new DataSet ();\r
 476                         AssertReadXml (ds, "Auto", diff2,\r
 477                                 XmlReadMode.Auto, XmlReadMode.DiffGram,\r
 478                                 "NewDataSet", 0, ReadState.Interactive);\r
 479 \r
 480                         ds = new DataSet ();\r
 481                         AssertReadXml (ds, "DiffGram", diff2,\r
 482                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 483                                 "NewDataSet", 0, ReadState.Interactive);\r
 484                 }\r
 485 \r
 486                 [Test]\r
 487                 public void TestSimpleSchemaXmlAll ()\r
 488                 {\r
 489                         DataSet ds;\r
 490 \r
 491                         // ignored\r
 492                         ds = new DataSet ();\r
 493                         AssertReadXml (ds, "IgnoreSchema", schema1,\r
 494                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 495                                 "NewDataSet", 0);\r
 496 \r
 497                         ds = new DataSet ();\r
 498                         AssertReadXml (ds, "InferSchema", schema1,\r
 499                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 500                                 "NewDataSet", 0);\r
 501 \r
 502                         // misc ... consume schema\r
 503                         ds = new DataSet ();\r
 504                         AssertReadXml (ds, "Fragment", schema1,\r
 505                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 506                                 "NewDataSet", 1);\r
 507                         AssertDataTable ("fragment", ds.Tables [0], "Root", 1, 0, 0, 0, 0, 0);\r
 508 \r
 509                         ds = new DataSet ();\r
 510                         AssertReadXml (ds, "ReadSchema", schema1,\r
 511                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 512                                 "NewDataSet", 1);\r
 513                         AssertDataTable ("readschema", ds.Tables [0], "Root", 1, 0, 0, 0, 0, 0);\r
 514 \r
 515                         ds = new DataSet ();\r
 516                         AssertReadXml (ds, "Auto", schema1,\r
 517                                 XmlReadMode.Auto, XmlReadMode.ReadSchema,\r
 518                                 "NewDataSet", 1);\r
 519                         AssertDataTable ("auto", ds.Tables [0], "Root", 1, 0, 0, 0, 0, 0);\r
 520 \r
 521                         ds = new DataSet ();\r
 522                         AssertReadXml (ds, "DiffGram", schema1,\r
 523                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 524                                 "NewDataSet", 1);\r
 525                 }\r
 526 \r
 527                 [Test]\r
 528                 public void TestSimpleSchemaPlusContentAll ()\r
 529                 {\r
 530                         DataSet ds;\r
 531 \r
 532                         // ignored\r
 533                         ds = new DataSet ();\r
 534                         AssertReadXml (ds, "IgnoreSchema", schema2,\r
 535                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 536                                 "NewDataSet", 0, ReadState.Interactive);\r
 537 \r
 538                         ds = new DataSet ();\r
 539                         AssertReadXml (ds, "InferSchema", schema2,\r
 540                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 541                                 "NewDataSet", 0, ReadState.Interactive);\r
 542 \r
 543                         // Fragment ... consumed both\r
 544                         ds = new DataSet ();\r
 545                         AssertReadXml (ds, "Fragment", schema2,\r
 546                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 547                                 "NewDataSet", 1);\r
 548                         AssertDataTable ("fragment", ds.Tables [0], "Root", 1, 0, 0, 0, 0, 0);\r
 549 \r
 550                         // rest ... treated as schema\r
 551                         ds = new DataSet ();\r
 552                         AssertReadXml (ds, "Auto", schema2,\r
 553                                 XmlReadMode.Auto, XmlReadMode.ReadSchema,\r
 554                                 "NewDataSet", 1, ReadState.Interactive);\r
 555                         AssertDataTable ("auto", ds.Tables [0], "Root", 1, 0, 0, 0, 0, 0);\r
 556 \r
 557                         ds = new DataSet ();\r
 558                         AssertReadXml (ds, "DiffGram", schema2,\r
 559                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 560                                 "NewDataSet", 1, ReadState.Interactive);\r
 561                         AssertDataTable ("diffgram", ds.Tables [0], "Root", 1, 0, 0, 0, 0, 0);\r
 562 \r
 563                         ds = new DataSet ();\r
 564                         AssertReadXml (ds, "ReadSchema", schema2,\r
 565                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 566                                 "NewDataSet", 1, ReadState.Interactive);\r
 567                 }\r
 568 \r
 569                 [Test]\r
 570                 public void SequentialRead1 ()\r
 571                 {\r
 572                         // simple element -> simple table\r
 573                         DataSet ds = new DataSet ();\r
 574 \r
 575                         AssertReadXml (ds, "SingleText", xml5,\r
 576                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 577                                 "root", 0);\r
 578 \r
 579                         AssertReadXml (ds, "SimpleTable", xml6,\r
 580                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 581                                 "NewDataSet", 1);\r
 582                         AssertDataTable ("seq1", ds.Tables [0], "root", 1, 1, 0, 0, 0, 0);\r
 583                 }\r
 584 \r
 585                 [Test]\r
 586                 public void SequentialRead2 ()\r
 587                 {\r
 588                         // simple element -> simple dataset\r
 589                         DataSet ds = new DataSet ();\r
 590 \r
 591                         AssertReadXml (ds, "SingleText", xml5,\r
 592                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 593                                 "root", 0);\r
 594 \r
 595                         AssertReadXml (ds, "SimpleTable2", xml7,\r
 596                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 597                                 "NewDataSet", 1);\r
 598                         AssertDataTable ("#1", ds.Tables [0], "root", 2, 1, 0, 0, 0, 0);\r
 599 \r
 600                         // simple table -> simple dataset\r
 601                         ds = new DataSet ();\r
 602 \r
 603                         AssertReadXml (ds, "SimpleTable", xml6,\r
 604                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 605                                 "NewDataSet", 1);\r
 606                         AssertDataTable ("#2", ds.Tables [0], "root", 1, 1, 0, 0, 0, 0);\r
 607 \r
 608                         // Return value became IgnoreSchema, since there is\r
 609                         // already schema information in the dataset.\r
 610                         // Columns are kept 1 as old table holds.\r
 611                         // Rows are up to 2 because of accumulative read.\r
 612                         AssertReadXml (ds, "SimpleTable2-2", xml7,\r
 613                                 XmlReadMode.Auto, XmlReadMode.IgnoreSchema,\r
 614                                 "NewDataSet", 1);\r
 615                         AssertDataTable ("#3", ds.Tables [0], "root", 1, 2, 0, 0, 0, 0);\r
 616 \r
 617                 }\r
 618 \r
 619                 [Test] // based on bug case\r
 620                 public void ReadComplexElementDocument ()\r
 621                 {\r
 622                         DataSet ds = new DataSet ();\r
 623                         ds.ReadXml (new StringReader (xml29));\r
 624                 }\r
 625 \r
 626                 [Test]\r
 627                 public void IgnoreSchemaShouldFillData ()\r
 628                 {\r
 629                         // no such dataset\r
 630                         string xml1 = "<set><tab><col>test</col></tab></set>";\r
 631                         // no wrapper element\r
 632                         string xml2 = "<tab><col>test</col></tab>";\r
 633                         // no such table\r
 634                         string xml3 = "<tar><col>test</col></tar>";\r
 635                         DataSet ds = new DataSet ();\r
 636                         DataTable dt = new DataTable ("tab");\r
 637                         ds.Tables.Add (dt);\r
 638                         dt.Columns.Add ("col");\r
 639                         ds.ReadXml (new StringReader (xml1), XmlReadMode.IgnoreSchema);\r
 640                         AssertDataSet ("ds", ds, "NewDataSet", 1, 0);\r
 641                         Assert.AreEqual (1, dt.Rows.Count, "wrapper element");\r
 642                         dt.Clear ();\r
 643 \r
 644                         ds.ReadXml (new StringReader (xml2), XmlReadMode.IgnoreSchema);\r
 645                         Assert.AreEqual (1, dt.Rows.Count, "no wrapper element");\r
 646                         dt.Clear ();\r
 647 \r
 648                         ds.ReadXml (new StringReader (xml3), XmlReadMode.IgnoreSchema);\r
 649                         Assert.AreEqual (0, dt.Rows.Count, "no such table");\r
 650                 }\r
 651 \r
 652                 // bug #60118\r
 653                 [Test]\r
 654                 public void NameConflictDSAndTable ()\r
 655                 {\r
 656                         string xml = @"<PriceListDetails> \r
 657         <PriceListList>    \r
 658                 <Id>1</Id>\r
 659         </PriceListList>\r
 660         <PriceListDetails> \r
 661                 <Id>1</Id>\r
 662                 <Status>0</Status>\r
 663         </PriceListDetails>\r
 664 </PriceListDetails>";\r
 665 \r
 666                         DataSet ds = new DataSet ();\r
 667                         ds.ReadXml (new StringReader (xml));\r
 668                         Assert.IsNotNull (ds.Tables ["PriceListDetails"]);\r
 669                 }\r
 670 \r
 671                 [Test] // bug #80045\r
 672                 public void ColumnOrder ()\r
 673                 {\r
 674                         string xml = "<?xml version=\"1.0\" standalone=\"yes\"?>" +\r
 675                                 "<NewDataSet>" +\r
 676                                 "  <Table>" +\r
 677                                 "    <Name>Miguel</Name>" +\r
 678                                 "    <FirstName>de Icaza</FirstName>" +\r
 679                                 "    <Income>4000</Income>" +\r
 680                                 "  </Table>" +\r
 681                                 "  <Table>" +\r
 682                                 "    <Name>25</Name>" +\r
 683                                 "    <FirstName>250</FirstName>" +\r
 684                                 "    <Address>Belgium</Address>" +\r
 685                                 "    <Income>5000</Income>" +\r
 686                                 "</Table>" +\r
 687                                 "</NewDataSet>";\r
 688 \r
 689                         DataSet ds = new DataSet ();\r
 690                         ds.ReadXml (new StringReader (xml));\r
 691                         Assert.AreEqual (1, ds.Tables.Count, "#1");\r
 692                         Assert.AreEqual ("Table", ds.Tables [0].TableName, "#2");\r
 693                         Assert.AreEqual (4, ds.Tables [0].Columns.Count, "#3");\r
 694                         Assert.AreEqual ("Name", ds.Tables [0].Columns [0].ColumnName, "#4a");\r
 695                         Assert.AreEqual (0, ds.Tables [0].Columns [0].Ordinal, "#4b");\r
 696                         Assert.AreEqual ("FirstName", ds.Tables [0].Columns [1].ColumnName, "#5a");\r
 697                         Assert.AreEqual (1, ds.Tables [0].Columns [1].Ordinal, "#5b");\r
 698                         Assert.AreEqual ("Address", ds.Tables [0].Columns [2].ColumnName, "#6a");\r
 699                         Assert.AreEqual (2, ds.Tables [0].Columns [2].Ordinal, "#6b");\r
 700                         Assert.AreEqual ("Income", ds.Tables [0].Columns [3].ColumnName, "#7a");\r
 701                         Assert.AreEqual (3, ds.Tables [0].Columns [3].Ordinal, "#7b");\r
 702                 }\r
 703 \r
 704                 [Test] // bug #80048\r
 705                 public void XmlSpace ()\r
 706                 {\r
 707                         string xml = "<?xml version=\"1.0\" standalone=\"yes\"?>" +\r
 708                                 "<NewDataSet>" +\r
 709                                 "  <Table>" +\r
 710                                 "    <Name>Miguel</Name>" +\r
 711                                 "    <FirstName xml:space=\"preserve\"> de Icaza</FirstName>" +\r
 712                                 "    <Income>4000</Income>" +\r
 713                                 "  </Table>" +\r
 714                                 "  <Table>" +\r
 715                                 "    <Name>Chris</Name>" +\r
 716                                 "    <FirstName xml:space=\"preserve\">Toshok </FirstName>" +\r
 717                                 "    <Income>3000</Income>" +\r
 718                                 "  </Table>" +\r
 719                                 "</NewDataSet>";\r
 720 \r
 721                         DataSet ds = new DataSet ();\r
 722                         ds.ReadXml (new StringReader (xml));\r
 723                         Assert.AreEqual (1, ds.Tables.Count, "#1");\r
 724                         Assert.AreEqual ("Table", ds.Tables [0].TableName, "#2");\r
 725                         Assert.AreEqual (3, ds.Tables [0].Columns.Count, "#3");\r
 726                         Assert.AreEqual ("Name", ds.Tables [0].Columns [0].ColumnName, "#4a");\r
 727                         Assert.AreEqual (0, ds.Tables [0].Columns [0].Ordinal, "#4b");\r
 728                         Assert.AreEqual ("FirstName", ds.Tables [0].Columns [1].ColumnName, "#5a");\r
 729                         Assert.AreEqual (1, ds.Tables [0].Columns [1].Ordinal, "#5b");\r
 730                         Assert.AreEqual ("Income", ds.Tables [0].Columns [2].ColumnName, "#6a");\r
 731                         Assert.AreEqual (2, ds.Tables [0].Columns [2].Ordinal, "#6b");\r
 732                 }\r
 733 \r
 734                 public void TestSameParentChildName ()\r
 735                 {\r
 736                         string xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?><resource type=\"parent\">" +\r
 737                                      "<resource type=\"child\" /></resource>";\r
 738                         DataSet ds = new DataSet ();\r
 739                         ds.ReadXml (new StringReader (xml));\r
 740 \r
 741                         AssertReadXml (ds, "SameNameParentChild", xml,\r
 742                                 XmlReadMode.Auto, XmlReadMode.IgnoreSchema,\r
 743                                 "NewDataSet", 1);\r
 744                 }\r
 745 \r
 746                 public void TestSameColumnName ()\r
 747                 {\r
 748                         string xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?><resource resource_Id_0=\"parent\">" +\r
 749                                      "<resource resource_Id_0=\"child\" /></resource>";\r
 750                         DataSet ds = new DataSet ();\r
 751                         ds.ReadXml (new StringReader (xml));\r
 752 \r
 753                         AssertReadXml (ds, "SameColumnName", xml,\r
 754                                 XmlReadMode.Auto, XmlReadMode.IgnoreSchema,\r
 755                                 "NewDataSet", 1);\r
 756                 }\r
 757                 \r
 758                 [Test]\r
 759                 public void DataSetExtendedPropertiesTest()\r
 760                 {\r
 761                         DataSet dataSet1 = new DataSet();\r
 762                         dataSet1.ExtendedProperties.Add("DS1", "extended0");\r
 763                         DataTable table = new DataTable("TABLE1");\r
 764                         table.ExtendedProperties.Add("T1", "extended1");\r
 765                         table.Columns.Add("C1", typeof(int));\r
 766                         table.Columns.Add("C2", typeof(string));\r
 767                         table.Columns[1].MaxLength = 20;\r
 768                         table.Columns[0].ExtendedProperties.Add("C1Ext1", "extended2");\r
 769                         table.Columns[1].ExtendedProperties.Add("C2Ext1", "extended3");\r
 770                         dataSet1.Tables.Add(table);\r
 771                         table.LoadDataRow(new object[]{1, "One"}, false);\r
 772                         table.LoadDataRow(new object[]{2, "Two"}, false);\r
 773                         string file = Path.Combine (Path.GetTempPath (), "schemas-test.xml");\r
 774                         try {\r
 775                                 dataSet1.WriteXml (file, XmlWriteMode.WriteSchema);\r
 776                         }\r
 777                         catch (Exception ex) {\r
 778                                 Assert.Fail ("DSExtPropTest failed: WriteXml failed with : "+ex.Message);\r
 779                         } finally {\r
 780                                 File.Delete (file);\r
 781                         }\r
 782                         \r
 783                         DataSet dataSet2 = new DataSet();\r
 784                         dataSet2.ReadXml("Test/System.Data/schemas/b582732.xml", XmlReadMode.ReadSchema);\r
 785                         Assert.AreEqual (dataSet1.ExtendedProperties["DS1"], dataSet2.ExtendedProperties["DS1"],\r
 786                                          "DSExtProp#1: DS extended properties mismatch");\r
 787                                                 \r
 788                         Assert.AreEqual (dataSet1.Tables[0].ExtendedProperties["T1"], dataSet2.Tables[0].ExtendedProperties["T1"],\r
 789                                          "DSExtProp#2: DS Table extended properties mismatch");\r
 790                         Assert.AreEqual (dataSet1.Tables[0].Columns[0].ExtendedProperties["C1Ext1"], \r
 791                                          dataSet2.Tables[0].Columns[0].ExtendedProperties["C1Ext1"],\r
 792                                          "DSExtProp#3: DS Table Column 1 extended properties mismatch");\r
 793                         Assert.AreEqual (dataSet1.Tables[0].Columns[1].ExtendedProperties["C2Ext1"], \r
 794                                          dataSet2.Tables[0].Columns[1].ExtendedProperties["C2Ext1"],\r
 795                                          "DSExtProp#4: DS Table Column 2 extended properties mismatch");\r
 796                 }\r
 797         }\r
 798 }\r