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