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 System.Xml.Serialization;\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 \r
  46                 const string xml1 = "";\r
  47                 const string xml2 = "<root/>";\r
  48                 const string xml3 = "<root></root>";\r
  49                 const string xml4 = "<root>   </root>";\r
  50                 const string xml5 = "<root>test</root>";\r
  51                 const string xml6 = "<root><test>1</test></root>";\r
  52                 const string xml7 = "<root><test>1</test><test2>a</test2></root>";\r
  53                 const string xml8 = "<dataset><table><col1>foo</col1><col2>bar</col2></table></dataset>";\r
  54                 const string xml29 = @"<PersonalSite><License Name='Sum Wang' Email='sumwang@somewhere.net' Mode='Trial' StartDate='01/01/2004' Serial='aaa' /></PersonalSite>";\r
  55 \r
  56                 const string diff1 = @"<diffgr:diffgram xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' xmlns:diffgr='urn:schemas-microsoft-com:xml-diffgram-v1'>\r
  57   <NewDataSet>\r
  58     <Table1 diffgr:id='Table11' msdata:rowOrder='0' diffgr:hasChanges='inserted'>\r
  59       <Column1_1>ppp</Column1_1>\r
  60       <Column1_2>www</Column1_2>\r
  61       <Column1_3>xxx</Column1_3>\r
  62     </Table1>\r
  63   </NewDataSet>\r
  64 </diffgr:diffgram>";\r
  65                 const string diff2 = diff1 + xml8;\r
  66 \r
  67                 const string schema1 = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>\r
  68         <xs:element name='Root'>\r
  69                 <xs:complexType>\r
  70                         <xs:sequence>\r
  71                                 <xs:element name='Child' type='xs:string' />\r
  72                         </xs:sequence>\r
  73                 </xs:complexType>\r
  74         </xs:element>\r
  75 </xs:schema>";\r
  76                 const string schema2 = schema1 + xml8;\r
  77 \r
  78                 [Test]\r
  79                 public void ReadSimpleAuto ()\r
  80                 {\r
  81                         DataSet ds;\r
  82 \r
  83                         // empty XML\r
  84                         ds = new DataSet ();\r
  85                         AssertReadXml (ds, "EmptyString", xml1,\r
  86                                 XmlReadMode.Auto, XmlReadMode.Auto,\r
  87                                 "NewDataSet", 0);\r
  88 \r
  89                         // simple element\r
  90                         ds = new DataSet ();\r
  91                         AssertReadXml (ds, "EmptyElement", xml2,\r
  92                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
  93                                 "root", 0);\r
  94 \r
  95                         // simple element2\r
  96                         ds = new DataSet ();\r
  97                         AssertReadXml (ds, "StartEndTag", xml3,\r
  98                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
  99                                 "root", 0);\r
 100 \r
 101                         // whitespace in simple element\r
 102                         ds = new DataSet ();\r
 103                         AssertReadXml (ds, "Whitespace", xml4,\r
 104                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 105                                 "root", 0);\r
 106 \r
 107                         // text in simple element\r
 108                         ds = new DataSet ();\r
 109                         AssertReadXml (ds, "SingleText", xml5,\r
 110                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 111                                 "root", 0);\r
 112 \r
 113                         // simple table pattern:\r
 114                         // root becomes a table and test becomes a column.\r
 115                         ds = new DataSet ();\r
 116                         AssertReadXml (ds, "SimpleTable", xml6,\r
 117                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 118                                 "NewDataSet", 1);\r
 119                         AssertDataTable ("xml6", ds.Tables [0], "root", 1, 1, 0, 0, 0, 0);\r
 120 \r
 121                         // simple table with 2 columns:\r
 122                         ds = new DataSet ();\r
 123                         AssertReadXml (ds, "SimpleTable2", xml7,\r
 124                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 125                                 "NewDataSet", 1);\r
 126                         AssertDataTable ("xml7", ds.Tables [0], "root", 2, 1, 0, 0, 0, 0);\r
 127 \r
 128                         // simple dataset with 1 table:\r
 129                         ds = new DataSet ();\r
 130                         AssertReadXml (ds, "SimpleDataSet", xml8,\r
 131                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 132                                 "dataset", 1);\r
 133                         AssertDataTable ("xml8", ds.Tables [0], "table", 2, 1, 0, 0, 0, 0);\r
 134                 }\r
 135 \r
 136                 [Test]\r
 137                 public void ReadSimpleDiffgram ()\r
 138                 {\r
 139                         DataSet ds;\r
 140 \r
 141                         // empty XML\r
 142                         ds = new DataSet ();\r
 143                         AssertReadXml (ds, "EmptyString", xml1,\r
 144                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 145                                 "NewDataSet", 0);\r
 146 \r
 147                         // simple element\r
 148                         ds = new DataSet ();\r
 149                         AssertReadXml (ds, "EmptyElement", xml2,\r
 150                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 151                                 "NewDataSet", 0);\r
 152 \r
 153                         // simple element2\r
 154                         ds = new DataSet ();\r
 155                         AssertReadXml (ds, "StartEndTag", xml3,\r
 156                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 157                                 "NewDataSet", 0);\r
 158 \r
 159                         // whitespace in simple element\r
 160                         ds = new DataSet ();\r
 161                         AssertReadXml (ds, "Whitespace", xml4,\r
 162                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 163                                 "NewDataSet", 0);\r
 164 \r
 165                         // text in simple element\r
 166                         ds = new DataSet ();\r
 167                         AssertReadXml (ds, "SingleText", xml5,\r
 168                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 169                                 "NewDataSet", 0);\r
 170 \r
 171                         // simple table pattern:\r
 172                         ds = new DataSet ();\r
 173                         AssertReadXml (ds, "SimpleTable", xml6,\r
 174                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 175                                 "NewDataSet", 0);\r
 176 \r
 177                         // simple table with 2 columns:\r
 178                         ds = new DataSet ();\r
 179                         AssertReadXml (ds, "SimpleTable2", xml7,\r
 180                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 181                                 "NewDataSet", 0);\r
 182 \r
 183                         // simple dataset with 1 table:\r
 184                         ds = new DataSet ();\r
 185                         AssertReadXml (ds, "SimpleDataSet", xml8,\r
 186                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 187                                 "NewDataSet", 0);\r
 188                 }\r
 189 \r
 190                 [Test]\r
 191                 public void ReadSimpleFragment ()\r
 192                 {\r
 193                         DataSet ds;\r
 194 \r
 195                         // empty XML\r
 196                         ds = new DataSet ();\r
 197                         AssertReadXml (ds, "EmptyString", xml1,\r
 198                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 199                                 "NewDataSet", 0);\r
 200 \r
 201                         // simple element\r
 202                         ds = new DataSet ();\r
 203                         AssertReadXml (ds, "EmptyElement", xml2,\r
 204                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 205                                 "NewDataSet", 0);\r
 206 \r
 207                         // simple element2\r
 208                         ds = new DataSet ();\r
 209                         AssertReadXml (ds, "StartEndTag", xml3,\r
 210                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 211                                 "NewDataSet", 0);\r
 212 \r
 213                         // whitespace in simple element\r
 214                         ds = new DataSet ();\r
 215                         AssertReadXml (ds, "Whitespace", xml4,\r
 216                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 217                                 "NewDataSet", 0);\r
 218 \r
 219                         // text in simple element\r
 220                         ds = new DataSet ();\r
 221                         AssertReadXml (ds, "SingleText", xml5,\r
 222                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 223                                 "NewDataSet", 0);\r
 224 \r
 225                         // simple table pattern:\r
 226                         ds = new DataSet ();\r
 227                         AssertReadXml (ds, "SimpleTable", xml6,\r
 228                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 229                                 "NewDataSet", 0);\r
 230 \r
 231                         // simple table with 2 columns:\r
 232                         ds = new DataSet ();\r
 233                         AssertReadXml (ds, "SimpleTable2", xml7,\r
 234                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 235                                 "NewDataSet", 0);\r
 236 \r
 237                         // simple dataset with 1 table:\r
 238                         ds = new DataSet ();\r
 239                         AssertReadXml (ds, "SimpleDataSet", xml8,\r
 240                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 241                                 "NewDataSet", 0);\r
 242                 }\r
 243 \r
 244                 [Test]\r
 245                 public void ReadSimpleIgnoreSchema ()\r
 246                 {\r
 247                         DataSet ds;\r
 248 \r
 249                         // empty XML\r
 250                         ds = new DataSet ();\r
 251                         AssertReadXml (ds, "EmptyString", xml1,\r
 252                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 253                                 "NewDataSet", 0);\r
 254 \r
 255                         // simple element\r
 256                         ds = new DataSet ();\r
 257                         AssertReadXml (ds, "EmptyElement", xml2,\r
 258                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 259                                 "NewDataSet", 0);\r
 260 \r
 261                         // simple element2\r
 262                         ds = new DataSet ();\r
 263                         AssertReadXml (ds, "StartEndTag", xml3,\r
 264                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 265                                 "NewDataSet", 0);\r
 266 \r
 267                         // whitespace in simple element\r
 268                         ds = new DataSet ();\r
 269                         AssertReadXml (ds, "Whitespace", xml4,\r
 270                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 271                                 "NewDataSet", 0);\r
 272 \r
 273                         // text in simple element\r
 274                         ds = new DataSet ();\r
 275                         AssertReadXml (ds, "SingleText", xml5,\r
 276                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 277                                 "NewDataSet", 0);\r
 278 \r
 279                         // simple table pattern:\r
 280                         ds = new DataSet ();\r
 281                         AssertReadXml (ds, "SimpleTable", xml6,\r
 282                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 283                                 "NewDataSet", 0);\r
 284 \r
 285                         // simple table with 2 columns:\r
 286                         ds = new DataSet ();\r
 287                         AssertReadXml (ds, "SimpleTable2", xml7,\r
 288                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 289                                 "NewDataSet", 0);\r
 290 \r
 291                         // simple dataset with 1 table:\r
 292                         ds = new DataSet ();\r
 293                         AssertReadXml (ds, "SimpleDataSet", xml8,\r
 294                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 295                                 "NewDataSet", 0);\r
 296                 }\r
 297 \r
 298                 [Test]\r
 299                 public void ReadSimpleInferSchema ()\r
 300                 {\r
 301                         DataSet ds;\r
 302 \r
 303                         // empty XML\r
 304                         ds = new DataSet ();\r
 305                         AssertReadXml (ds, "EmptyString", xml1,\r
 306                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 307                                 "NewDataSet", 0);\r
 308 \r
 309                         // simple element\r
 310                         ds = new DataSet ();\r
 311                         AssertReadXml (ds, "EmptyElement", xml2,\r
 312                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 313                                 "root", 0);\r
 314 \r
 315                         // simple element2\r
 316                         ds = new DataSet ();\r
 317                         AssertReadXml (ds, "StartEndTag", xml3,\r
 318                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 319                                 "root", 0);\r
 320 \r
 321                         // whitespace in simple element\r
 322                         ds = new DataSet ();\r
 323                         AssertReadXml (ds, "Whitespace", xml4,\r
 324                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 325                                 "root", 0);\r
 326 \r
 327                         // text in simple element\r
 328                         ds = new DataSet ();\r
 329                         AssertReadXml (ds, "SingleText", xml5,\r
 330                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 331                                 "root", 0);\r
 332 \r
 333                         // simple table pattern:\r
 334                         // root becomes a table and test becomes a column.\r
 335                         ds = new DataSet ();\r
 336                         AssertReadXml (ds, "SimpleTable", xml6,\r
 337                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 338                                 "NewDataSet", 1);\r
 339                         AssertDataTable ("xml6", ds.Tables [0], "root", 1, 1, 0, 0, 0, 0);\r
 340 \r
 341                         // simple table with 2 columns:\r
 342                         ds = new DataSet ();\r
 343                         AssertReadXml (ds, "SimpleTable2", xml7,\r
 344                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 345                                 "NewDataSet", 1);\r
 346                         AssertDataTable ("xml7", ds.Tables [0], "root", 2, 1, 0, 0, 0, 0);\r
 347 \r
 348                         // simple dataset with 1 table:\r
 349                         ds = new DataSet ();\r
 350                         AssertReadXml (ds, "SimpleDataSet", xml8,\r
 351                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 352                                 "dataset", 1);\r
 353                         AssertDataTable ("xml8", ds.Tables [0], "table", 2, 1, 0, 0, 0, 0);\r
 354                 }\r
 355 \r
 356                 [Test]\r
 357                 public void ReadSimpleReadSchema ()\r
 358                 {\r
 359                         DataSet ds;\r
 360 \r
 361                         // empty XML\r
 362                         ds = new DataSet ();\r
 363                         AssertReadXml (ds, "EmptyString", xml1,\r
 364                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 365                                 "NewDataSet", 0);\r
 366 \r
 367                         // simple element\r
 368                         ds = new DataSet ();\r
 369                         AssertReadXml (ds, "EmptyElement", xml2,\r
 370                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 371                                 "NewDataSet", 0);\r
 372 \r
 373                         // simple element2\r
 374                         ds = new DataSet ();\r
 375                         AssertReadXml (ds, "StartEndTag", xml3,\r
 376                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 377                                 "NewDataSet", 0);\r
 378 \r
 379                         // whitespace in simple element\r
 380                         ds = new DataSet ();\r
 381                         AssertReadXml (ds, "Whitespace", xml4,\r
 382                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 383                                 "NewDataSet", 0);\r
 384 \r
 385                         // text in simple element\r
 386                         ds = new DataSet ();\r
 387                         AssertReadXml (ds, "SingleText", xml5,\r
 388                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 389                                 "NewDataSet", 0);\r
 390 \r
 391                         // simple table pattern:\r
 392                         ds = new DataSet ();\r
 393                         AssertReadXml (ds, "SimpleTable", xml6,\r
 394                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 395                                 "NewDataSet", 0);\r
 396 \r
 397                         // simple table with 2 columns:\r
 398                         ds = new DataSet ();\r
 399                         AssertReadXml (ds, "SimpleTable2", xml7,\r
 400                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 401                                 "NewDataSet", 0);\r
 402 \r
 403                         // simple dataset with 1 table:\r
 404                         ds = new DataSet ();\r
 405                         AssertReadXml (ds, "SimpleDataSet", xml8,\r
 406                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 407                                 "NewDataSet", 0);\r
 408                 }\r
 409 \r
 410                 [Test]\r
 411                 public void TestSimpleDiffXmlAll ()\r
 412                 {\r
 413                         DataSet ds;\r
 414 \r
 415                         // ignored\r
 416                         ds = new DataSet ();\r
 417                         AssertReadXml (ds, "Fragment", diff1,\r
 418                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 419                                 "NewDataSet", 0);\r
 420 \r
 421                         ds = new DataSet ();\r
 422                         AssertReadXml (ds, "IgnoreSchema", diff1,\r
 423                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 424                                 "NewDataSet", 0);\r
 425 \r
 426                         ds = new DataSet ();\r
 427                         AssertReadXml (ds, "InferSchema", diff1,\r
 428                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 429                                 "NewDataSet", 0);\r
 430 \r
 431                         ds = new DataSet ();\r
 432                         AssertReadXml (ds, "ReadSchema", diff1,\r
 433                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 434                                 "NewDataSet", 0);\r
 435 \r
 436                         // Auto, DiffGram ... treated as DiffGram\r
 437                         ds = new DataSet ();\r
 438                         AssertReadXml (ds, "Auto", diff1,\r
 439                                 XmlReadMode.Auto, XmlReadMode.DiffGram,\r
 440                                 "NewDataSet", 0);\r
 441 \r
 442                         ds = new DataSet ();\r
 443                         AssertReadXml (ds, "DiffGram", diff1,\r
 444                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 445                                 "NewDataSet", 0);\r
 446                 }\r
 447 \r
 448                 [Test]\r
 449                 public void TestSimpleDiffPlusContentAll ()\r
 450                 {\r
 451                         DataSet ds;\r
 452 \r
 453                         // Fragment ... skipped\r
 454                         ds = new DataSet ();\r
 455                         AssertReadXml (ds, "Fragment", diff2,\r
 456                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 457                                 "NewDataSet", 0);\r
 458 \r
 459                         // others ... kept \r
 460                         ds = new DataSet ();\r
 461                         AssertReadXml (ds, "IgnoreSchema", diff2,\r
 462                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 463                                 "NewDataSet", 0, ReadState.Interactive);\r
 464 \r
 465                         ds = new DataSet ();\r
 466                         AssertReadXml (ds, "InferSchema", diff2,\r
 467                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 468                                 "NewDataSet", 0, ReadState.Interactive);\r
 469 \r
 470                         ds = new DataSet ();\r
 471                         AssertReadXml (ds, "ReadSchema", diff2,\r
 472                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 473                                 "NewDataSet", 0, ReadState.Interactive);\r
 474 \r
 475                         // Auto, DiffGram ... treated as DiffGram\r
 476                         ds = new DataSet ();\r
 477                         AssertReadXml (ds, "Auto", diff2,\r
 478                                 XmlReadMode.Auto, XmlReadMode.DiffGram,\r
 479                                 "NewDataSet", 0, ReadState.Interactive);\r
 480 \r
 481                         ds = new DataSet ();\r
 482                         AssertReadXml (ds, "DiffGram", diff2,\r
 483                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 484                                 "NewDataSet", 0, ReadState.Interactive);\r
 485                 }\r
 486 \r
 487                 [Test]\r
 488                 public void TestSimpleSchemaXmlAll ()\r
 489                 {\r
 490                         DataSet ds;\r
 491 \r
 492                         // ignored\r
 493                         ds = new DataSet ();\r
 494                         AssertReadXml (ds, "IgnoreSchema", schema1,\r
 495                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 496                                 "NewDataSet", 0);\r
 497 \r
 498                         ds = new DataSet ();\r
 499                         AssertReadXml (ds, "InferSchema", schema1,\r
 500                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 501                                 "NewDataSet", 0);\r
 502 \r
 503                         // misc ... consume schema\r
 504                         ds = new DataSet ();\r
 505                         AssertReadXml (ds, "Fragment", schema1,\r
 506                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 507                                 "NewDataSet", 1);\r
 508                         AssertDataTable ("fragment", ds.Tables [0], "Root", 1, 0, 0, 0, 0, 0);\r
 509 \r
 510                         ds = new DataSet ();\r
 511                         AssertReadXml (ds, "ReadSchema", schema1,\r
 512                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 513                                 "NewDataSet", 1);\r
 514                         AssertDataTable ("readschema", ds.Tables [0], "Root", 1, 0, 0, 0, 0, 0);\r
 515 \r
 516                         ds = new DataSet ();\r
 517                         AssertReadXml (ds, "Auto", schema1,\r
 518                                 XmlReadMode.Auto, XmlReadMode.ReadSchema,\r
 519                                 "NewDataSet", 1);\r
 520                         AssertDataTable ("auto", ds.Tables [0], "Root", 1, 0, 0, 0, 0, 0);\r
 521 \r
 522                         ds = new DataSet ();\r
 523                         AssertReadXml (ds, "DiffGram", schema1,\r
 524                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 525                                 "NewDataSet", 1);\r
 526                 }\r
 527 \r
 528                 [Test]\r
 529                 public void TestSimpleSchemaPlusContentAll ()\r
 530                 {\r
 531                         DataSet ds;\r
 532 \r
 533                         // ignored\r
 534                         ds = new DataSet ();\r
 535                         AssertReadXml (ds, "IgnoreSchema", schema2,\r
 536                                 XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,\r
 537                                 "NewDataSet", 0, ReadState.Interactive);\r
 538 \r
 539                         ds = new DataSet ();\r
 540                         AssertReadXml (ds, "InferSchema", schema2,\r
 541                                 XmlReadMode.InferSchema, XmlReadMode.InferSchema,\r
 542                                 "NewDataSet", 0, ReadState.Interactive);\r
 543 \r
 544                         // Fragment ... consumed both\r
 545                         ds = new DataSet ();\r
 546                         AssertReadXml (ds, "Fragment", schema2,\r
 547                                 XmlReadMode.Fragment, XmlReadMode.Fragment,\r
 548                                 "NewDataSet", 1);\r
 549                         AssertDataTable ("fragment", ds.Tables [0], "Root", 1, 0, 0, 0, 0, 0);\r
 550 \r
 551                         // rest ... treated as schema\r
 552                         ds = new DataSet ();\r
 553                         AssertReadXml (ds, "Auto", schema2,\r
 554                                 XmlReadMode.Auto, XmlReadMode.ReadSchema,\r
 555                                 "NewDataSet", 1, ReadState.Interactive);\r
 556                         AssertDataTable ("auto", ds.Tables [0], "Root", 1, 0, 0, 0, 0, 0);\r
 557 \r
 558                         ds = new DataSet ();\r
 559                         AssertReadXml (ds, "DiffGram", schema2,\r
 560                                 XmlReadMode.DiffGram, XmlReadMode.DiffGram,\r
 561                                 "NewDataSet", 1, ReadState.Interactive);\r
 562                         AssertDataTable ("diffgram", ds.Tables [0], "Root", 1, 0, 0, 0, 0, 0);\r
 563 \r
 564                         ds = new DataSet ();\r
 565                         AssertReadXml (ds, "ReadSchema", schema2,\r
 566                                 XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,\r
 567                                 "NewDataSet", 1, ReadState.Interactive);\r
 568                 }\r
 569 \r
 570                 [Test]\r
 571                 public void SequentialRead1 ()\r
 572                 {\r
 573                         // simple element -> simple table\r
 574                         DataSet ds = new DataSet ();\r
 575 \r
 576                         AssertReadXml (ds, "SingleText", xml5,\r
 577                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 578                                 "root", 0);\r
 579 \r
 580                         AssertReadXml (ds, "SimpleTable", xml6,\r
 581                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 582                                 "root", 1); // not NewDataSet unlike standalone load\r
 583                         AssertDataTable ("seq1", ds.Tables [0], "root", 1, 1, 0, 0, 0, 0);\r
 584                 }\r
 585 \r
 586                 [Test]\r
 587                 public void SequentialRead2 ()\r
 588                 {\r
 589                         // simple element -> simple dataset\r
 590                         DataSet ds = new DataSet ();\r
 591 \r
 592                         AssertReadXml (ds, "SingleText", xml5,\r
 593                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 594                                 "root", 0);\r
 595 \r
 596                         AssertReadXml (ds, "SimpleTable2", xml7,\r
 597                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 598                                 "root", 1); // dataset name will not be overwritten\r
 599                         AssertDataTable ("#1", ds.Tables [0], "root", 2, 1, 0, 0, 0, 0);\r
 600 \r
 601                         // simple table -> simple dataset\r
 602                         ds = new DataSet ();\r
 603 \r
 604                         AssertReadXml (ds, "SimpleTable", xml6,\r
 605                                 XmlReadMode.Auto, XmlReadMode.InferSchema,\r
 606                                 "NewDataSet", 1);\r
 607                         AssertDataTable ("#2", ds.Tables [0], "root", 1, 1, 0, 0, 0, 0);\r
 608 \r
 609                         // Return value became IgnoreSchema, since there is\r
 610                         // already schema information in the dataset.\r
 611                         // Columns are kept 1 as old table holds.\r
 612                         // Rows are up to 2 because of accumulative read.\r
 613                         AssertReadXml (ds, "SimpleTable2-2", xml7,\r
 614                                 XmlReadMode.Auto, XmlReadMode.IgnoreSchema,\r
 615                                 "NewDataSet", 1);\r
 616                         AssertDataTable ("#3", ds.Tables [0], "root", 1, 2, 0, 0, 0, 0);\r
 617 \r
 618                 }\r
 619 \r
 620                 [Test] // based on bug case\r
 621                 public void ReadComplexElementDocument ()\r
 622                 {\r
 623                         DataSet ds = new DataSet ();\r
 624                         ds.ReadXml (new StringReader (xml29));\r
 625                 }\r
 626 \r
 627                 [Test]\r
 628                 public void IgnoreSchemaShouldFillData ()\r
 629                 {\r
 630                         // no such dataset\r
 631                         string xml1 = "<set><tab><col>test</col></tab></set>";\r
 632                         // no wrapper element\r
 633                         string xml2 = "<tab><col>test</col></tab>";\r
 634                         // no such table\r
 635                         string xml3 = "<tar><col>test</col></tar>";\r
 636                         DataSet ds = new DataSet ();\r
 637                         DataTable dt = new DataTable ("tab");\r
 638                         ds.Tables.Add (dt);\r
 639                         dt.Columns.Add ("col");\r
 640                         ds.ReadXml (new StringReader (xml1), XmlReadMode.IgnoreSchema);\r
 641                         AssertDataSet ("ds", ds, "NewDataSet", 1, 0);\r
 642                         AssertEquals ("wrapper element", 1, dt.Rows.Count);\r
 643                         dt.Clear ();\r
 644 \r
 645                         ds.ReadXml (new StringReader (xml2), XmlReadMode.IgnoreSchema);\r
 646                         AssertEquals ("no wrapper element", 1, dt.Rows.Count);\r
 647                         dt.Clear ();\r
 648 \r
 649                         ds.ReadXml (new StringReader (xml3), XmlReadMode.IgnoreSchema);\r
 650                         AssertEquals ("no such table", 0, dt.Rows.Count);\r
 651                 }\r
 652 \r
 653                 // bug #60118\r
 654                 [Test]\r
 655                 public void NameConflictDSAndTable ()\r
 656                 {\r
 657                         string xml = @"<PriceListDetails> \r
 658         <PriceListList>    \r
 659                 <Id>1</Id>\r
 660         </PriceListList>\r
 661         <PriceListDetails> \r
 662                 <Id>1</Id>\r
 663                 <Status>0</Status>\r
 664         </PriceListDetails>\r
 665 </PriceListDetails>";\r
 666 \r
 667                         DataSet ds = new DataSet ();\r
 668                         ds.ReadXml (new StringReader (xml));\r
 669                         AssertNotNull (ds.Tables ["PriceListDetails"]);\r
 670                 }\r
 671         }\r
 672 }\r