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
   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.Text;\r
  36 using System.Xml;\r
  37 using NUnit.Framework;\r
  38 \r
  39 namespace MonoTests.System.Data\r
  40 {\r
  41         [TestFixture]\r
  42         public class DataSetReadXmlTest : DataSetAssertion\r
  43         {\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                                 "root", 1); // not NewDataSet unlike standalone load\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                                 "root", 1); // dataset name will not be overwritten\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", 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                         AssertEquals ("wrapper element", 1, dt.Rows.Count);\r
 642                         dt.Clear ();\r
 643 \r
 644                         ds.ReadXml (new StringReader (xml2), XmlReadMode.IgnoreSchema);\r
 645                         AssertEquals ("no wrapper element", 1, dt.Rows.Count);\r
 646                         dt.Clear ();\r
 647 \r
 648                         ds.ReadXml (new StringReader (xml3), XmlReadMode.IgnoreSchema);\r
 649                         AssertEquals ("no such table", 0, dt.Rows.Count);\r
 650                 }\r
 651 \r
 652                 /* To be added\r
 653                 [Test]\r
 654                 public void SaveDiffLoadAutoSaveSchema ()\r
 655                 {\r
 656                         DataSet ds = new DataSet ();\r
 657                         ds.Tables.Add ("Table1");\r
 658                         ds.Tables.Add ("Table2");\r
 659                         ds.Tables [0].Columns.Add ("Column1_1");\r
 660                         ds.Tables [0].Columns.Add ("Column1_2");\r
 661                         ds.Tables [0].Columns.Add ("Column1_3");\r
 662                         ds.Tables [1].Columns.Add ("Column2_1");\r
 663                         ds.Tables [1].Columns.Add ("Column2_2");\r
 664                         ds.Tables [1].Columns.Add ("Column2_3");\r
 665                         ds.Tables [0].Rows.Add (new object [] {"ppp", "www", "xxx"});\r
 666 \r
 667                         // save as diffgram\r
 668                         StringWriter sw = new StringWriter ();\r
 669                         ds.WriteXml (sw, XmlWriteMode.DiffGram);\r
 670                         string xml = sw.ToString ();\r
 671                         string result = new StreamReader ("Test/System.Data/DataSetReadXmlTest1.xml", Encoding.ASCII).ReadToEnd ();\r
 672                         AssertEquals ("#01", result, xml);\r
 673 \r
 674                         // load diffgram above\r
 675                         ds.ReadXml (new StringReader (sw.ToString ()));\r
 676                         sw = new StringWriter ();\r
 677                         ds.WriteXml (sw, XmlWriteMode.WriteSchema);\r
 678                         xml = sw.ToString ();\r
 679                         result = new StreamReader ("Test/System.Data/DataSetReadXmlTest2.xml", Encoding.ASCII).ReadToEnd ();\r
 680                         AssertEquals ("#02", result, xml);\r
 681                 }\r
 682                 */\r
 683         }\r
 684 }\r