Files
mono/mcs/class/System.Data/Test/System.Data/DataSetTest.cs
T

2628 lines
117 KiB
C#

// MonoTests.System.Data.DataSetTest.cs
//
// Authors:
// Ville Palo <[email protected]>
// Martin Willemoes Hansen <[email protected]>
// Atsushi Enomoto <[email protected]>
// Hagit Yidov <[email protected]>
//
// (C) Copyright 2002 Ville Palo
// (C) Copyright 2003 Martin Willemoes Hansen
// (C) 2005 Mainsoft Corporation (http://www.mainsoft.com)
//
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using NUnit.Framework;
using System;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
using System.IO;
using System.Data;
using System.Data.SqlTypes;
using System.Globalization;
using System.Threading;
using System.Text;
namespace MonoTests.System.Data
{
[TestFixture]
public class DataSetTest : DataSetAssertion
{
string EOL = Environment.NewLine;
CultureInfo currentCultureBackup;
[SetUp]
public void Setup () {
currentCultureBackup = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo ("fi-FI");
}
//[SetUp]
//public void GetReady()
//{
// currentCultureBackup = Thread.CurrentThread.CurrentCulture;
// Thread.CurrentThread.CurrentCulture = new CultureInfo ("fi-FI");
//}
[TearDown]
public void Teardown ()
{
Thread.CurrentThread.CurrentCulture = currentCultureBackup;
}
[Test]
public void Properties ()
{
DataSet ds = new DataSet ();
Assert.AreEqual (String.Empty, ds.Namespace, "default namespace");
ds.Namespace = null; // setting null == setting ""
Assert.AreEqual (String.Empty, ds.Namespace, "after setting null to namespace");
Assert.AreEqual (String.Empty, ds.Prefix, "default prefix");
ds.Prefix = null; // setting null == setting ""
Assert.AreEqual (String.Empty, ds.Prefix, "after setting null to prefix");
}
[Test]
public void ReadXmlSchema ()
{
DataSet ds = new DataSet ();
ds.ReadXmlSchema ("Test/System.Data/own_schema.xsd");
Assert.AreEqual (2, ds.Tables.Count, "test#01");
DataTable Table = ds.Tables [0];
Assert.AreEqual ("test_table", Table.TableName, "test#02");
Assert.AreEqual ("", Table.Namespace, "test#03");
Assert.AreEqual (2, Table.Columns.Count, "test#04");
Assert.AreEqual (0, Table.Rows.Count, "test#05");
Assert.IsFalse (Table.CaseSensitive, "test#06");
Assert.AreEqual (1, Table.Constraints.Count, "test#07");
Assert.AreEqual ("", Table.Prefix, "test#08");
Constraint cons = Table.Constraints [0];
Assert.AreEqual ("Constraint1", cons.ConstraintName.ToString (), "test#09");
Assert.AreEqual ("Constraint1", cons.ToString (), "test#10");
DataColumn column = Table.Columns [0];
Assert.IsTrue (column.AllowDBNull, "test#11");
Assert.IsFalse (column.AutoIncrement, "test#12");
Assert.AreEqual (0L, column.AutoIncrementSeed, "test#13");
Assert.AreEqual (1L, column.AutoIncrementStep, "test#14");
Assert.AreEqual ("test", column.Caption, "test#15");
Assert.AreEqual ("Element", column.ColumnMapping.ToString (), "test#16");
Assert.AreEqual ("first", column.ColumnName, "test#17");
Assert.AreEqual ("System.String", column.DataType.ToString (), "test#18");
Assert.AreEqual ("test_default_value", column.DefaultValue.ToString (), "test#19");
Assert.IsFalse (column.DesignMode, "test#20");
Assert.AreEqual ("", column.Expression, "test#21");
Assert.AreEqual (100, column.MaxLength, "test#22");
Assert.AreEqual ("", column.Namespace, "test#23");
Assert.AreEqual (0, column.Ordinal, "test#24");
Assert.AreEqual ("", column.Prefix, "test#25");
Assert.IsFalse (column.ReadOnly, "test#26");
Assert.IsTrue (column.Unique, "test#27");
DataColumn column2 = Table.Columns [1];
Assert.IsTrue (column2.AllowDBNull, "test#28");
Assert.IsFalse (column2.AutoIncrement, "test#29");
Assert.AreEqual (0L, column2.AutoIncrementSeed, "test#30");
Assert.AreEqual (1L, column2.AutoIncrementStep, "test#31");
Assert.AreEqual ("second", column2.Caption, "test#32");
Assert.AreEqual ("Element", column2.ColumnMapping.ToString (), "test#33");
Assert.AreEqual ("second", column2.ColumnName, "test#34");
Assert.AreEqual ("System.Data.SqlTypes.SqlGuid", column2.DataType.ToString (), "test#35");
#if NET_2_0
Assert.AreEqual (SqlGuid.Null, column2.DefaultValue, "test#36");
#else
Assert.AreEqual (DBNull.Value, column2.DefaultValue, "test#36");
#endif
Assert.IsFalse (column2.DesignMode, "test#37");
Assert.AreEqual ("", column2.Expression, "test#38");
Assert.AreEqual (-1, column2.MaxLength, "test#39");
Assert.AreEqual ("", column2.Namespace, "test#40");
Assert.AreEqual (1, column2.Ordinal, "test#41");
Assert.AreEqual ("", column2.Prefix, "test#42");
Assert.IsFalse (column2.ReadOnly, "test#43");
Assert.IsFalse (column2.Unique, "test#44");
DataTable Table2 = ds.Tables [1];
Assert.AreEqual ("second_test_table", Table2.TableName, "test#45");
Assert.AreEqual ("", Table2.Namespace, "test#46");
Assert.AreEqual (1, Table2.Columns.Count, "test#47");
Assert.AreEqual (0, Table2.Rows.Count, "test#48");
Assert.IsFalse (Table2.CaseSensitive, "test#49");
Assert.AreEqual (1, Table2.Constraints.Count, "test#50");
Assert.AreEqual ("", Table2.Prefix, "test#51");
DataColumn column3 = Table2.Columns [0];
Assert.IsTrue (column3.AllowDBNull, "test#52");
Assert.IsFalse (column3.AutoIncrement, "test#53");
Assert.AreEqual (0L, column3.AutoIncrementSeed, "test#54");
Assert.AreEqual (1L, column3.AutoIncrementStep, "test#55");
Assert.AreEqual ("second_first", column3.Caption, "test#56");
Assert.AreEqual ("Element", column3.ColumnMapping.ToString (), "test#57");
Assert.AreEqual ("second_first", column3.ColumnName, "test#58");
Assert.AreEqual ("System.String", column3.DataType.ToString (), "test#59");
Assert.AreEqual ("default_value", column3.DefaultValue.ToString (), "test#60");
Assert.IsFalse (column3.DesignMode, "test#61");
Assert.AreEqual ("", column3.Expression, "test#62");
Assert.AreEqual (100, column3.MaxLength, "test#63");
Assert.AreEqual ("", column3.Namespace, "test#64");
Assert.AreEqual (0, column3.Ordinal, "test#65");
Assert.AreEqual ("", column3.Prefix, "test#66");
Assert.IsFalse (column3.ReadOnly, "test#67");
Assert.IsTrue (column3.Unique, "test#68");
}
[Test]
public void OwnWriteXmlSchema ()
{
DataSet ds = new DataSet ("test_dataset");
DataTable table = new DataTable ("test_table");
DataColumn column = new DataColumn ("first", typeof (string));
column.AllowDBNull = true;
column.DefaultValue = "test_default_value";
column.MaxLength = 100;
column.Caption = "test";
column.Unique = true;
table.Columns.Add (column);
DataColumn column2 = new DataColumn ("second", typeof (SqlGuid));
column2.ColumnMapping = MappingType.Element;
table.Columns.Add (column2);
ds.Tables.Add (table);
DataTable table2 = new DataTable ("second_test_table");
DataColumn column3 = new DataColumn ("second_first", typeof (string));
column3.AllowDBNull = true;
column3.DefaultValue = "default_value";
column3.MaxLength = 100;
column3.Unique = true;
table2.Columns.Add (column3);
ds.Tables.Add (table2);
TextWriter writer = new StringWriter ();
ds.WriteXmlSchema (writer);
string TextString = GetNormalizedSchema (writer.ToString ());
// string TextString = writer.ToString ();
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual ("<xs:schema id=\"test_dataset\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring, "test#02");
Assert.AreEqual ("<xs:schema id=\"test_dataset\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring, "test#02");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"test_dataset\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\">", substring, "test#03");
#if !NET_2_0
Assert.AreEqual (" <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\" name=\"test_dataset\">", substring, "test#03");
#else
Assert.AreEqual (" <xs:element msdata:IsDataSet=\"true\" msdata:UseCurrentLocale=\"true\" name=\"test_dataset\">", substring, "test#03");
#endif
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:complexType>", substring, "test#04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring, "test#05");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:element name=\"test_table\">", substring, "test#06");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:complexType>", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:sequence>", substring, "test#08");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"first\" msdata:Caption=\"test\" default=\"test_default_value\" minOccurs=\"0\">", substring, "test#09");
Assert.AreEqual (" <xs:element default=\"test_default_value\" minOccurs=\"0\" msdata:Caption=\"test\" name=\"first\">", substring, "test#09");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:simpleType>", substring, "test#10");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:restriction base=\"xs:string\">", substring, "test#11");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:maxLength value=\"100\" />", substring, "test#12");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:restriction>", substring, "test#13");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:simpleType>", substring, "test#14");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:element>", substring, "test#15");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"second\" msdata:DataType=\"System.Data.SqlTypes.SqlGuid, System.Data, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089\" type=\"xs:string\" minOccurs=\"0\" />", substring, "test#16");
#if NET_2_0
Assert.AreEqual (" <xs:element minOccurs=\"0\" msdata:DataType=\"System.Data.SqlTypes.SqlGuid, System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089\" name=\"second\" type=\"xs:string\" />", substring, "test#16");
#else
Assert.AreEqual (" <xs:element minOccurs=\"0\" msdata:DataType=\"System.Data.SqlTypes.SqlGuid, System.Data, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089\" name=\"second\" type=\"xs:string\" />", substring, "test#16");
#endif
if (substring.IndexOf ("<xs:element") < 0)
Assert.Fail ("test#16: " + substring);
if (substring.IndexOf ("name=\"second\"") < 0)
Assert.Fail ("test#16: " + substring);
if (substring.IndexOf ("msdata:DataType=\"System.Data.SqlTypes.SqlGuid, System.Data, Version=") < 0)
Assert.Fail ("test#16: " + substring);
if (substring.IndexOf ("type=\"xs:string\"") < 0)
Assert.Fail ("test#16: " + substring);
if (substring.IndexOf ("minOccurs=\"0\"") < 0)
Assert.Fail ("test#16: " + substring);
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:sequence>", substring, "test#17");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:complexType>", substring, "test#18");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:element>", substring, "test#19");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:element name=\"second_test_table\">", substring, "test#20");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:complexType>", substring, "test#21");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:sequence>", substring, "test#22");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"second_first\" default=\"default_value\" minOccurs=\"0\">", substring, "test#23");
Assert.AreEqual (" <xs:element default=\"default_value\" minOccurs=\"0\" name=\"second_first\">", substring, "test#23");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:simpleType>", substring, "test#24");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:restriction base=\"xs:string\">", substring, "test#25");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:maxLength value=\"100\" />", substring, "test#26");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:restriction>", substring, "test#27");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:simpleType>", substring, "test#28");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:element>", substring, "test#29");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:sequence>", substring, "test#30");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:complexType>", substring, "test#31");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:element>", substring, "test#32");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:choice>", substring, "test#33");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:complexType>", substring, "test#34");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:unique name=\"Constraint1\">", substring, "test#36");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:selector xpath=\".//test_table\" />", substring, "test#37");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:field xpath=\"first\" />", substring, "test#38");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:unique>", substring, "test#39");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:unique name=\"second_test_table_Constraint1\" msdata:ConstraintName=\"Constraint1\">", substring, "test#40");
Assert.AreEqual (" <xs:unique msdata:ConstraintName=\"Constraint1\" name=\"second_test_table_Constraint1\">", substring, "test#40");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:selector xpath=\".//second_test_table\" />", substring, "test#41");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:field xpath=\"second_first\" />", substring, "test#42");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:unique>", substring, "test#43");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:element>", substring, "test#44");
Assert.AreEqual ("</xs:schema>", TextString, "test#45");
}
[Test]
public void ReadWriteXml ()
{
DataSet ds = new DataSet ();
ds.ReadXml ("Test/System.Data/region.xml");
TextWriter writer = new StringWriter ();
ds.WriteXml (writer);
string TextString = writer.ToString ();
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual ("<Root>", substring, "test#01");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <Region>", substring, "test#02");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <RegionID>1</RegionID>", substring, "test#03");
// Here the end of line is text markup "\n"
substring = TextString.Substring (0, TextString.IndexOf('\n'));
TextString = TextString.Substring (TextString.IndexOf('\n') + 1);
Assert.AreEqual (" <RegionDescription>Eastern", substring, "test#04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </RegionDescription>", substring, "test#05");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </Region>", substring, "test#06");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <Region>", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <RegionID>2</RegionID>", substring, "test#08");
// Here the end of line is text markup "\n"
substring = TextString.Substring (0, TextString.IndexOf('\n'));
TextString = TextString.Substring (TextString.IndexOf('\n') + 1);
Assert.AreEqual (" <RegionDescription>Western", substring, "test#09");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </RegionDescription>", substring, "test#10");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </Region>", substring, "test#11");
Assert.AreEqual ("</Root>", TextString, "test#11");
}
[Test]
public void ReadWriteXmlDiffGram ()
{
DataSet ds = new DataSet ();
// It is not a diffgram, so no data loading should be done.
ds.ReadXml ("Test/System.Data/region.xml", XmlReadMode.DiffGram);
TextWriter writer = new StringWriter ();
ds.WriteXml (writer);
string TextString = writer.ToString ();
Assert.AreEqual ("<NewDataSet />", TextString, "test#01");
ds.WriteXml (writer, XmlWriteMode.DiffGram);
TextString = writer.ToString ();
Assert.AreEqual ("<NewDataSet /><diffgr:diffgram xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:diffgr=\"urn:schemas-microsoft-com:xml-diffgram-v1\" />", TextString, "test#02");
ds = new DataSet ();
ds.ReadXml ("Test/System.Data/region.xml");
DataTable table = ds.Tables ["Region"];
table.Rows [0] [0] = "64";
ds.ReadXml ("Test/System.Data/region.xml", XmlReadMode.DiffGram);
ds.WriteXml (writer, XmlWriteMode.DiffGram);
TextString = writer.ToString ();
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual ("<NewDataSet /><diffgr:diffgram xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:diffgr=\"urn:schemas-microsoft-com:xml-diffgram-v1\" /><diffgr:diffgram xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:diffgr=\"urn:schemas-microsoft-com:xml-diffgram-v1\">", substring, "test#03");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <Root>", substring, "test#04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <Region diffgr:id=\"Region1\" msdata:rowOrder=\"0\" diffgr:hasChanges=\"inserted\">", substring, "test#05");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <RegionID>64</RegionID>", substring, "test#06");
// not EOL but literal '\n'
substring = TextString.Substring (0, TextString.IndexOf('\n'));
TextString = TextString.Substring (TextString.IndexOf('\n') + 1);
Assert.AreEqual (" <RegionDescription>Eastern", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </RegionDescription>", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </Region>", substring, "test#08");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <Region diffgr:id=\"Region2\" msdata:rowOrder=\"1\" diffgr:hasChanges=\"inserted\">", substring, "test#09");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <RegionID>2</RegionID>", substring, "test#10");
// not EOL but literal '\n'
substring = TextString.Substring (0, TextString.IndexOf('\n'));
TextString = TextString.Substring (TextString.IndexOf('\n') + 1);
Assert.AreEqual (" <RegionDescription>Western", substring, "test#11");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </RegionDescription>", substring, "test#12");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </Region>", substring, "test#13");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </Root>", substring, "test#14");
Assert.AreEqual ("</diffgr:diffgram>", TextString, "test#15");
}
[Test]
public void WriteXmlSchema ()
{
DataSet ds = new DataSet ();
ds.ReadXml ("Test/System.Data/region.xml");
TextWriter writer = new StringWriter ();
ds.WriteXmlSchema (writer);
string TextString = GetNormalizedSchema (writer.ToString ());
// string TextString = writer.ToString ();
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual ("<xs:schema id=\"Root\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring, "test#02");
Assert.AreEqual ("<xs:schema id=\"Root\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring, "test#02");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"en-US\" name=\"Root\">", substring, "test#03");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:complexType>", substring, "test#04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring, "test#05");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:element name=\"Region\">", substring, "test#06");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:complexType>", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:sequence>", substring, "test#08");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"RegionID\" type=\"xs:string\" minOccurs=\"0\" />", substring, "test#09");
Assert.AreEqual (" <xs:element minOccurs=\"0\" name=\"RegionID\" type=\"xs:string\" />", substring, "test#09");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"RegionDescription\" type=\"xs:string\" minOccurs=\"0\" />", substring, "test#10");
Assert.AreEqual (" <xs:element minOccurs=\"0\" name=\"RegionDescription\" type=\"xs:string\" />", substring, "test#10");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:sequence>", substring, "test#11");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:complexType>", substring, "test#12");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:element>", substring, "test#13");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:choice>", substring, "test#14");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:complexType>", substring, "test#15");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:element>", substring, "test#16");
Assert.AreEqual ("</xs:schema>", TextString, "test#17");
}
[Test]
[Ignore ("MS behavior is far from consistent to be regarded as a reference implementation.")]
// MS ReadXmlSchema() is too inconsistent to regard as a
// reference implementation. To find the reason why, try to
// read store2.xsd and store4.xsd, write and compare for each
// DataSet property.
public void ReadWriteXmlSchemaIgnoreSchema ()
{
DataSet ds = new DataSet ();
ds.ReadXmlSchema ("Test/System.Data/store.xsd");
AssertDataSet ("read DataSet", ds, "NewDataSet", 3, 2);
AssertDataTable ("read bookstore table", ds.Tables [0], "bookstore", 1, 0, 0, 1, 1, 1);
AssertDataTable ("read book table", ds.Tables [1], "book", 5, 0, 1, 1, 2, 1);
ds.ReadXml ("Test/System.Data/region.xml", XmlReadMode.IgnoreSchema);
TextWriter writer = new StringWriter ();
ds.WriteXmlSchema (writer);
string TextString = GetNormalizedSchema (writer.ToString ());
// string TextString = writer.ToString ();
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual ("<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring, "test#02");
Assert.AreEqual ("<xs:schema id=\"NewDataSet\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring, "test#02");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:complexType name=\"bookstoreType\">", substring, "test#03");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:sequence>", substring, "test#04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"book\" type=\"bookType\" minOccurs=\"0\" maxOccurs=\"unbounded\" />", substring, "test#05");
Assert.AreEqual (" <xs:element maxOccurs=\"unbounded\" minOccurs=\"0\" name=\"book\" type=\"bookType\" />", substring, "test#05");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:sequence>", substring, "test#06");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:complexType>", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:complexType name=\"bookType\">", substring, "test#08");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:sequence>", substring, "test#09");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"title\" type=\"xs:string\" msdata:Ordinal=\"1\" />", substring, "test#10");
Assert.AreEqual (" <xs:element msdata:Ordinal=\"1\" name=\"title\" type=\"xs:string\" />", substring, "test#10");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"price\" type=\"xs:decimal\" msdata:Ordinal=\"2\" />", substring, "test#11");
Assert.AreEqual (" <xs:element msdata:Ordinal=\"2\" name=\"price\" type=\"xs:decimal\" />", substring, "test#11");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"author\" type=\"authorName\" minOccurs=\"0\" maxOccurs=\"unbounded\" />", substring, "test#12");
Assert.AreEqual (" <xs:element maxOccurs=\"unbounded\" minOccurs=\"0\" name=\"author\" type=\"authorName\" />", substring, "test#12");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:sequence>", substring, "test#13");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:attribute name=\"genre\" type=\"xs:string\" />", substring, "test#14");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:complexType>", substring, "test#15");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:complexType name=\"authorName\">", substring, "test#16");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:sequence>", substring, "test#17");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:element name=\"first-name\" type=\"xs:string\" />", substring, "test#18");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:element name=\"last-name\" type=\"xs:string\" />", substring, "test#19");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:sequence>", substring, "test#20");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:complexType>", substring, "test#21");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:element name=\"bookstore\" type=\"bookstoreType\" />", substring, "test#22");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\">", substring, "test#23");
Assert.AreEqual (" <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\" name=\"NewDataSet\">", substring, "test#23");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:complexType>", substring, "test#24");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring, "test#25");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:element ref=\"bookstore\" />", substring, "test#26");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:choice>", substring, "test#27");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:complexType>", substring, "test#28");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:element>", substring, "test#29");
Assert.AreEqual ("</xs:schema>", TextString, "test#30");
}
[Test]
[Ignore ("MS behavior is far from consistent to be regarded as a reference implementation.")]
// See comments on ReadWriteXmlSchemaIgnoreSchema().
public void ReadWriteXmlSchema ()
{
DataSet ds = new DataSet ();
ds.ReadXmlSchema ("Test/System.Data/store.xsd");
// check dataset properties before testing write
AssertDataSet ("ds", ds, "NewDataSet", 3, 2);
AssertDataTable ("tab1", ds.Tables [0], "bookstore", 1, 0, 0, 1, 1, 1);
AssertDataTable ("tab2", ds.Tables [1], "book", 5, 0, 1, 1, 2, 1);
AssertDataTable ("tab3", ds.Tables [2], "author", 3, 0, 1, 0, 1, 0);
// FIXME: currently order is not compatible. Use name as index
AssertDataRelation ("rel1", ds.Relations ["book_author"], "book_author", true, new string [] {"book_Id"}, new string [] {"book_Id"}, true, true);
AssertDataRelation ("rel2", ds.Relations ["bookstore_book"], "bookstore_book", true, new string [] {"bookstore_Id"}, new string [] {"bookstore_Id"}, true, true);
ds.ReadXml ("Test/System.Data/region.xml", XmlReadMode.InferSchema);
TextWriter writer = new StringWriter ();
ds.WriteXmlSchema (writer);
string TextString = GetNormalizedSchema (writer.ToString ());
// string TextString = writer.ToString ();
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring, "test#01");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual ("<xs:schema id=\"Root\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring, "test#02");
Assert.AreEqual ("<xs:schema id=\"Root\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring, "test#02");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:complexType name=\"bookstoreType\">", substring, "test#03");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:sequence>", substring, "test#04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"book\" type=\"bookType\" minOccurs=\"0\" maxOccurs=\"unbounded\" />", substring, "test#05");
Assert.AreEqual (" <xs:element maxOccurs=\"unbounded\" minOccurs=\"0\" name=\"book\" type=\"bookType\" />", substring, "test#05");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:sequence>", substring, "test#06");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:complexType>", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:complexType name=\"bookType\">", substring, "test#08");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:sequence>", substring, "test#09");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"title\" type=\"xs:string\" msdata:Ordinal=\"1\" />", substring, "test#10");
Assert.AreEqual (" <xs:element msdata:Ordinal=\"1\" name=\"title\" type=\"xs:string\" />", substring, "test#10");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"price\" type=\"xs:decimal\" msdata:Ordinal=\"2\" />", substring, "test#11");
Assert.AreEqual (" <xs:element msdata:Ordinal=\"2\" name=\"price\" type=\"xs:decimal\" />", substring, "test#11");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"author\" type=\"authorName\" minOccurs=\"0\" maxOccurs=\"unbounded\" />", substring, "test#12");
Assert.AreEqual (" <xs:element maxOccurs=\"unbounded\" minOccurs=\"0\" name=\"author\" type=\"authorName\" />", substring, "test#12");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:sequence>", substring, "test#13");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:attribute name=\"genre\" type=\"xs:string\" />", substring, "test#14");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:complexType>", substring, "test#15");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:complexType name=\"authorName\">", substring, "test#16");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:sequence>", substring, "test#17");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:element name=\"first-name\" type=\"xs:string\" />", substring, "test#18");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:element name=\"last-name\" type=\"xs:string\" />", substring, "test#19");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:sequence>", substring, "test#20");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:complexType>", substring, "test#21");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:element name=\"bookstore\" type=\"bookstoreType\" />", substring, "test#22");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"Root\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\">", substring, "test#23");
Assert.AreEqual (" <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\" name=\"Root\">", substring, "test#23");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:complexType>", substring, "test#24");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring, "test#25");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:element ref=\"bookstore\" />", substring, "test#26");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:element name=\"Region\">", substring, "test#27");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:complexType>", substring, "test#28");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" <xs:sequence>", substring, "test#29");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"RegionID\" type=\"xs:string\" minOccurs=\"0\" />", substring, "test#30");
Assert.AreEqual (" <xs:element minOccurs=\"0\" name=\"RegionID\" type=\"xs:string\" />", substring, "test#30");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// This is original DataSet.WriteXmlSchema() output
// Assert.AreEqual (" <xs:element name=\"RegionDescription\" type=\"xs:string\" minOccurs=\"0\" />", substring, "test#31");
Assert.AreEqual (" <xs:element minOccurs=\"0\" name=\"RegionDescription\" type=\"xs:string\" />", substring, "test#31");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:sequence>", substring, "test#32");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:complexType>", substring, "test#33");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:element>", substring, "test#34");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:choice>", substring, "test#35");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:complexType>", substring, "test#36");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
Assert.AreEqual (" </xs:element>", substring, "test#37");
Assert.AreEqual ("</xs:schema>", TextString, "test#38");
}
[Test]
[Category ("NotWorking")]
public void WriteDifferentNamespaceSchema ()
{
string schema = @"<?xml version='1.0' encoding='utf-16'?>
<xs:schema id='NewDataSet' targetNamespace='urn:bar' xmlns:mstns='urn:bar' xmlns='urn:bar' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' attributeFormDefault='qualified' elementFormDefault='qualified' xmlns:app1='urn:baz' xmlns:app2='urn:foo'>
<!--ATTENTION: This schema contains references to other imported schemas-->
<xs:import namespace='urn:baz' schemaLocation='_app1.xsd' />
<xs:import namespace='urn:foo' schemaLocation='_app2.xsd' />
<xs:element name='NewDataSet' msdata:IsDataSet='true' msdata:Locale='fi-FI'>
<xs:complexType>
<xs:choice minOccurs='0' maxOccurs='unbounded'>
<xs:element ref='app2:NS1Table' />
<xs:element name='NS2Table'>
<xs:complexType>
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>";
DataSet ds = new DataSet();
DataTable dt = new DataTable ();
dt.TableName = "NS1Table";
dt.Namespace = "urn:foo";
dt.Columns.Add ("column1");
dt.Columns.Add ("column2");
dt.Columns [1].Namespace = "urn:baz";
ds.Tables.Add (dt);
DataTable dt2 = new DataTable ();
dt2.TableName = "NS2Table";
dt2.Namespace = "urn:bar";
ds.Tables.Add (dt2);
ds.Namespace = "urn:bar";
StringWriter sw = new StringWriter ();
XmlTextWriter xw = new XmlTextWriter (sw);
xw.Formatting = Formatting.Indented;
xw.QuoteChar = '\'';
ds.WriteXmlSchema (xw);
string result = sw.ToString ();
Assert.AreEqual (result.Replace ("\r\n", "\n"), schema.Replace ("\r\n", "\n"));
}
[Test]
public void IgnoreColumnEmptyNamespace ()
{
DataColumn col = new DataColumn ("TEST");
col.Namespace = "urn:foo";
DataSet ds = new DataSet ("DS");
ds.Namespace = "urn:foo";
DataTable dt = new DataTable ("tab");
ds.Tables.Add (dt);
dt.Columns.Add (col);
dt.Rows.Add (new object [] {"test"});
StringWriter sw = new StringWriter ();
ds.WriteXml (new XmlTextWriter (sw));
string xml = @"<DS xmlns=""urn:foo""><tab><TEST>test</TEST></tab></DS>";
Assert.AreEqual (xml, sw.ToString ());
}
[Test]
public void SerializeDataSet ()
{
// see GetReady() for current culture
string xml = "<?xml version='1.0' encoding='utf-16'?><DataSet><xs:schema id='DS' xmlns='' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata'><xs:element name='DS' msdata:IsDataSet='true' " +
#if !NET_2_0
"msdata:Locale='fi-FI'"
#else
"msdata:UseCurrentLocale='true'"
#endif
+ "><xs:complexType><xs:choice minOccurs='0' maxOccurs='unbounded' /></xs:complexType></xs:element></xs:schema><diffgr:diffgram xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' xmlns:diffgr='urn:schemas-microsoft-com:xml-diffgram-v1' /></DataSet>";
DataSet ds = new DataSet ();
ds.DataSetName = "DS";
XmlSerializer ser = new XmlSerializer (typeof (DataSet));
StringWriter sw = new StringWriter ();
XmlTextWriter xw = new XmlTextWriter (sw);
xw.QuoteChar = '\'';
ser.Serialize (xw, ds);
string result = sw.ToString ();
Assert.AreEqual (result.Replace ("\r\n", "\n"), xml.Replace ("\r\n", "\n"));
}
// bug #70961
[Test]
public void SerializeDataSet2 ()
{
DataSet quota = new DataSet ("Quota");
// Dimension
DataTable dt = new DataTable ("Dimension");
quota.Tables.Add (dt);
dt.Columns.Add ("Number", typeof(int));
dt.Columns ["Number"].AllowDBNull = false;
dt.Columns ["Number"].ColumnMapping = MappingType.Attribute;
dt.Columns.Add ("Title", typeof(string));
dt.Columns ["Title"].AllowDBNull = false;
dt.Columns ["Title"].ColumnMapping =
MappingType.Attribute;
dt.Rows.Add (new object [] {0, "Hospitals"});
dt.Rows.Add (new object [] {1, "Doctors"});
dt.Constraints.Add ("PK_Dimension", dt.Columns ["Number"], true);
quota.AcceptChanges ();
XmlSerializer ser = new XmlSerializer (quota.GetType ());
StringWriter sw = new StringWriter ();
ser.Serialize (sw, quota);
DataSet ds = (DataSet) ser.Deserialize (new StringReader (sw.ToString ()));
}
// bug #68007
public void SerializeDataSet3 ()
{
string xml = @"<?xml version=""1.0"" encoding=""utf-8""?><DataSet><xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata""><xs:element name=""Example"" msdata:IsDataSet=""true""><xs:complexType><xs:choice maxOccurs=""unbounded"" minOccurs=""0""><xs:element name=""Packages""><xs:complexType><xs:attribute name=""ID"" type=""xs:int"" use=""required"" /><xs:attribute name=""ShipDate"" type=""xs:dateTime"" /><xs:attribute name=""Message"" type=""xs:string"" /><xs:attribute name=""Handlers"" type=""xs:int"" /></xs:complexType></xs:element></xs:choice></xs:complexType></xs:element></xs:schema><diffgr:diffgram xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"" xmlns:diffgr=""urn:schemas-microsoft-com:xml-diffgram-v1""><Example><Packages diffgr:id=""Packages1"" msdata:rowOrder=""0"" ID=""0"" ShipDate=""2004-10-11T17:46:18.6962302-05:00"" Message=""Received with no breakage!"" Handlers=""3"" /><Packages diffgr:id=""Packages2"" msdata:rowOrder=""1"" ID=""1"" /></Example></diffgr:diffgram></DataSet>";
DataSet ds = new DataSet ("Example");
// Add a DataTable
DataTable dt = new DataTable ("Packages");
ds.Tables.Add (dt);
// Add an ID DataColumn w/ ColumnMapping = MappingType.Attribute
dt.Columns.Add (new DataColumn ("ID", typeof(int), "",
MappingType.Attribute));
dt.Columns ["ID"].AllowDBNull = false;
// Add a nullable DataColumn w/ ColumnMapping = MappingType.Attribute
dt.Columns.Add (new DataColumn ("ShipDate",
typeof (DateTime), "", MappingType.Attribute));
dt.Columns ["ShipDate"].AllowDBNull = true;
// Add a nullable DataColumn w/ ColumnMapping = MappingType.Attribute
dt.Columns.Add (new DataColumn ("Message",
typeof (string), "", MappingType.Attribute));
dt.Columns ["Message"].AllowDBNull = true;
// Add a nullable DataColumn w/ ColumnMapping = MappingType.Attribute
dt.Columns.Add (new DataColumn ("Handlers",
typeof (int), "", MappingType.Attribute));
dt.Columns ["Handlers"].AllowDBNull = true;
// Add a non-null value row
DataRow newRow = dt.NewRow();
newRow ["ID"] = 0;
newRow ["ShipDate"] = DateTime.Now;
newRow ["Message"] = "Received with no breakage!";
newRow ["Handlers"] = 3;
dt.Rows.Add (newRow);
// Add a null value row
newRow = dt.NewRow ();
newRow ["ID"] = 1;
newRow ["ShipDate"] = DBNull.Value;
newRow ["Message"] = DBNull.Value;
newRow ["Handlers"] = DBNull.Value;
dt.Rows.Add (newRow);
ds.AcceptChanges ();
XmlSerializer ser = new XmlSerializer (ds.GetType());
StringWriter sw = new StringWriter ();
ser.Serialize (sw, ds);
string result = sw.ToString ();
Assert.AreEqual (xml, result);
}
[Test]
public void DeserializeDataSet ()
{
string xml = @"<DataSet>
<diffgr:diffgram xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' xmlns:diffgr='urn:schemas-microsoft-com:xml-diffgram-v1'>
<Quota>
<Dimension diffgr:id='Dimension1' msdata:rowOrder='0' Number='0' Title='Hospitals' />
<Dimension diffgr:id='Dimension2' msdata:rowOrder='1' Number='1' Title='Doctors' />
</Quota>
</diffgr:diffgram>
</DataSet>";
XmlSerializer ser = new XmlSerializer (typeof (DataSet));
ser.Deserialize (new XmlTextReader (
xml, XmlNodeType.Document, null));
}
/* To be added
[Test]
public void WriteDiffReadAutoWriteSchema ()
{
DataSet ds = new DataSet ();
ds.Tables.Add ("Table1");
ds.Tables.Add ("Table2");
ds.Tables [0].Columns.Add ("Column1_1");
ds.Tables [0].Columns.Add ("Column1_2");
ds.Tables [0].Columns.Add ("Column1_3");
ds.Tables [1].Columns.Add ("Column2_1");
ds.Tables [1].Columns.Add ("Column2_2");
ds.Tables [1].Columns.Add ("Column2_3");
ds.Tables [0].Rows.Add (new object [] {"ppp", "www", "xxx"});
// save as diffgram
StringWriter sw = new StringWriter ();
ds.WriteXml (sw, XmlWriteMode.DiffGram);
string xml = sw.ToString ();
string result = new StreamReader ("Test/System.Data/DataSetReadXmlTest1.xml", Encoding.ASCII).ReadToEnd ();
Assert.AreEqual (result, xml, "#01");
// load diffgram above
ds.ReadXml (new StringReader (sw.ToString ()));
sw = new StringWriter ();
ds.WriteXml (sw, XmlWriteMode.WriteSchema);
xml = sw.ToString ();
result = new StreamReader ("Test/System.Data/DataSetReadXmlTest2.xml", Encoding.ASCII).ReadToEnd ();
Assert.AreEqual (result, xml, "#02");
}
*/
[Test]
public void CloneCopy ()
{
DataTable table = new DataTable ("pTable"); DataTable table1 = new DataTable ("cTable"); DataSet set = new DataSet ();
set.Tables.Add (table);
set.Tables.Add (table1); DataColumn col = new DataColumn ();
col.ColumnName = "Id";
col.DataType = Type.GetType ("System.Int32");
table.Columns.Add (col);
UniqueConstraint uc = new UniqueConstraint ("UK1", table.Columns[0] );
table.Constraints.Add (uc);
col = new DataColumn ();
col.ColumnName = "Name";
col.DataType = Type.GetType ("System.String");
table.Columns.Add (col);
col = new DataColumn ();
col.ColumnName = "Id";
col.DataType = Type.GetType ("System.Int32");
table1.Columns.Add (col);
col = new DataColumn ();
col.ColumnName = "Name";
col.DataType = Type.GetType ("System.String");
table1.Columns.Add (col);
ForeignKeyConstraint fc = new ForeignKeyConstraint ("FK1", table.Columns[0], table1.Columns[0] );
table1.Constraints.Add (fc);
DataRow row = table.NewRow ();
row ["Id"] = 147;
row ["name"] = "Row1";
row.RowError = "Error#1";
table.Rows.Add (row);
row = table1.NewRow ();
row ["Id"] = 147;
row ["Name"] = "Row1";
table1.Rows.Add (row);
//Setting properties of DataSet
set.CaseSensitive = true;
set.DataSetName = "My DataSet";
set.EnforceConstraints = false;
set.Namespace = "Namespace#1";
set.Prefix = "Prefix:1";
DataRelation dr = new DataRelation ("DR", table.Columns [0],table1.Columns [0]);
set.Relations.Add (dr);
set.ExtendedProperties.Add ("TimeStamp", DateTime.Now);
CultureInfo cultureInfo = new CultureInfo( "ar-SA" );
set.Locale = cultureInfo;
//Testing Copy ()
DataSet copySet = set.Copy ();
Assert.AreEqual (set.CaseSensitive, copySet.CaseSensitive, "#A01");
Assert.AreEqual (set.DataSetName, copySet.DataSetName, "#A02");
Assert.AreEqual (set.EnforceConstraints, copySet.EnforceConstraints, "#A03");
Assert.AreEqual (set.HasErrors, copySet.HasErrors, "#A04");
Assert.AreEqual (set.Namespace, copySet.Namespace, "#A05");
Assert.AreEqual (set.Prefix, copySet.Prefix, "#A06");
Assert.AreEqual (set.Relations.Count, copySet.Relations.Count, "#A07");
Assert.AreEqual (set.Tables.Count, copySet.Tables.Count, "#A08");
Assert.AreEqual (set.ExtendedProperties ["TimeStamp"], copySet.ExtendedProperties ["TimeStamp"], "#A09");
for (int i = 0;i < copySet.Tables.Count; i++) {
Assert.AreEqual (set.Tables [i].Rows.Count, copySet.Tables [i].Rows.Count, "#A10");
Assert.AreEqual (set.Tables [i].Columns.Count, copySet.Tables [i].Columns.Count, "#A11");
}
//Testing Clone ()
copySet = set.Clone ();
Assert.AreEqual (set.CaseSensitive, copySet.CaseSensitive, "#A12");
Assert.AreEqual (set.DataSetName, copySet.DataSetName, "#A13");
Assert.AreEqual (set.EnforceConstraints, copySet.EnforceConstraints, "#A14");
Assert.IsFalse (copySet.HasErrors, "#A15");
Assert.AreEqual (set.Namespace, copySet.Namespace, "#A16");
Assert.AreEqual (set.Prefix, copySet.Prefix, "#A17");
Assert.AreEqual (set.Relations.Count, copySet.Relations.Count, "#A18");
Assert.AreEqual (set.Tables.Count, copySet.Tables.Count, "#A19");
Assert.AreEqual (set.ExtendedProperties ["TimeStamp"], copySet.ExtendedProperties ["TimeStamp"], "#A20");
for (int i = 0;i < copySet.Tables.Count; i++) {
Assert.AreEqual (0, copySet.Tables [i].Rows.Count, "#A21");
Assert.AreEqual (set.Tables [i].Columns.Count, copySet.Tables [i].Columns.Count, "#A22");
}
}
[Test]
public void CloneCopy2 ()
{
DataSet ds = new DataSet ();
ds.ReadXmlSchema ("Test/System.Data/store.xsd");
ds.Clone ();
}
[Test]
public void CloneCopy_TestForeignKeyConstraints ()
{
DataTable dirTable = new DataTable("Directories");
DataColumn dir_UID = new DataColumn("UID", typeof(int));
dir_UID.Unique = true;
dir_UID.AllowDBNull = false;
dirTable.Columns.Add(dir_UID);
// Build a simple Files table
DataTable fileTable = new DataTable("Files");
DataColumn file_DirID = new DataColumn("DirectoryID", typeof(int));
file_DirID.Unique = false;
file_DirID.AllowDBNull = false;
fileTable.Columns.Add(file_DirID);
// Build the DataSet
DataSet ds = new DataSet("TestDataset");
ds.Tables.Add(dirTable);
ds.Tables.Add(fileTable);
// Add a foreign key constraint
DataColumn[] parentColumns = new DataColumn[1];
parentColumns[0] = ds.Tables["Directories"].Columns["UID"];
DataColumn[] childColumns = new DataColumn[1];
childColumns[0] = ds.Tables["Files"].Columns["DirectoryID"];
ForeignKeyConstraint fk = new ForeignKeyConstraint("FK_Test", parentColumns, childColumns);
ds.Tables["Files"].Constraints.Add(fk);
ds.EnforceConstraints = true;
Assert.AreEqual (1, ds.Tables["Directories"].Constraints.Count, "#1");
Assert.AreEqual (1, ds.Tables["Files"].Constraints.Count, "#2");
// check clone works fine
DataSet cloned_ds = ds.Clone ();
Assert.AreEqual (1, cloned_ds.Tables["Directories"].Constraints.Count, "#3");
Assert.AreEqual (1, cloned_ds.Tables["Files"].Constraints.Count, "#4");
ForeignKeyConstraint clonedFk = (ForeignKeyConstraint)cloned_ds.Tables["Files"].Constraints[0];
Assert.AreEqual ("FK_Test", clonedFk.ConstraintName, "#5");
Assert.AreEqual (1, clonedFk.Columns.Length, "#6");
Assert.AreEqual ("DirectoryID", clonedFk.Columns[0].ColumnName, "#7");
UniqueConstraint clonedUc = (UniqueConstraint)cloned_ds.Tables ["Directories"].Constraints[0];
UniqueConstraint origUc = (UniqueConstraint)ds.Tables ["Directories"].Constraints[0];
Assert.AreEqual (origUc.ConstraintName, clonedUc.ConstraintName, "#8");
Assert.AreEqual (1, clonedUc.Columns.Length, "#9");
Assert.AreEqual ("UID", clonedUc.Columns[0].ColumnName, "#10");
// check copy works fine
DataSet copy_ds = ds.Copy ();
Assert.AreEqual (1, copy_ds.Tables["Directories"].Constraints.Count, "#11");
Assert.AreEqual (1, copy_ds.Tables["Files"].Constraints.Count, "#12");
ForeignKeyConstraint copyFk = (ForeignKeyConstraint)copy_ds.Tables["Files"].Constraints[0];
Assert.AreEqual ("FK_Test", copyFk.ConstraintName, "#13");
Assert.AreEqual (1, copyFk.Columns.Length, "#14");
Assert.AreEqual ("DirectoryID", copyFk.Columns[0].ColumnName, "#15");
UniqueConstraint copyUc = (UniqueConstraint)copy_ds.Tables ["Directories"].Constraints[0];
origUc = (UniqueConstraint)ds.Tables ["Directories"].Constraints[0];
Assert.AreEqual (origUc.ConstraintName, copyUc.ConstraintName, "#16");
Assert.AreEqual (1, copyUc.Columns.Length, "#17");
Assert.AreEqual ("UID", copyUc.Columns[0].ColumnName, "#18");
}
[Test]
public void WriteNestedTableXml ()
{
string xml = @"<NewDataSet>
<tab1>
<ident>1</ident>
<name>hoge</name>
<tab2>
<timestamp>2004-05-05</timestamp>
</tab2>
</tab1>
<tab1>
<ident>2</ident>
<name>fuga</name>
<tab2>
<timestamp>2004-05-06</timestamp>
</tab2>
</tab1>
</NewDataSet>";
DataSet ds = new DataSet ();
DataTable dt = new DataTable ("tab1");
dt.Columns.Add ("ident");
dt.Columns.Add ("name");
dt.Rows.Add (new object [] {"1", "hoge"});
dt.Rows.Add (new object [] {"2", "fuga"});
DataTable dt2 = new DataTable ("tab2");
dt2.Columns.Add ("idref");
dt2.Columns [0].ColumnMapping = MappingType.Hidden;
dt2.Columns.Add ("timestamp");
dt2.Rows.Add (new object [] {"1", "2004-05-05"});
dt2.Rows.Add (new object [] {"2", "2004-05-06"});
ds.Tables.Add (dt);
ds.Tables.Add (dt2);
DataRelation rel = new DataRelation ("rel", dt.Columns [0], dt2.Columns [0]);
rel.Nested = true;
ds.Relations.Add (rel);
StringWriter sw = new StringWriter ();
ds.WriteXml (sw);
Assert.AreEqual (sw.ToString ().Replace ("\r\n", "\n"), xml.Replace ("\r\n", "\n"));
}
[Test]
public void WriteXmlToStream ()
{
string xml = "<set><table1><col1>sample text</col1><col2/></table1><table2 attr='value'><col3>sample text 2</col3></table2></set>";
DataSet ds = new DataSet ();
ds.ReadXml (new StringReader (xml));
MemoryStream ms = new MemoryStream ();
ds.WriteXml (ms);
MemoryStream ms2 = new MemoryStream (ms.ToArray ());
StreamReader sr = new StreamReader (ms2, Encoding.UTF8);
string result = @"<set>
<table1>
<col1>sample text</col1>
<col2 />
</table1>
<table2 attr=""value"">
<col3>sample text 2</col3>
</table2>
</set>";
Assert.AreEqual (sr.ReadToEnd ().Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
}
[Test]
public void WtiteXmlEncodedXml ()
{
string xml = @"<an_x0020_example_x0020_dataset.>
<WOW_x0021__x0020_that_x0027_s_x0020_nasty...>
<URL_x0020_is_x0020_http_x003A__x002F__x002F_www.go-mono.com>content string.</URL_x0020_is_x0020_http_x003A__x002F__x002F_www.go-mono.com>
</WOW_x0021__x0020_that_x0027_s_x0020_nasty...>
</an_x0020_example_x0020_dataset.>";
DataSet ds = new DataSet ("an example dataset.");
ds.Tables.Add (new DataTable ("WOW! that's nasty..."));
ds.Tables [0].Columns.Add ("URL is http://www.go-mono.com");
ds.Tables [0].Rows.Add (new object [] {"content string."});
StringWriter sw = new StringWriter ();
ds.WriteXml (sw);
Assert.AreEqual (sw.ToString ().Replace ("\r\n", "\n"), xml.Replace ("\r\n", "\n"));
}
[Test]
public void ReadWriteXml2 ()
{
string xml = "<FullTextResponse><Domains><AvailResponse info='y' name='novell-ximian-group' /><AvailResponse info='n' name='ximian' /></Domains></FullTextResponse>";
DataSet ds = new DataSet ();
ds.ReadXml (new StringReader (xml));
AssertDataSet ("ds", ds, "FullTextResponse", 2, 1);
DataTable dt = ds.Tables [0];
AssertDataTable ("dt1", dt, "Domains", 1, 1, 0, 1, 1, 1);
dt = ds.Tables [1];
AssertDataTable ("dt2", dt, "AvailResponse", 3, 2, 1, 0, 1, 0);
StringWriter sw = new StringWriter ();
XmlTextWriter xtw = new XmlTextWriter (sw);
xtw.QuoteChar = '\'';
ds.WriteXml (xtw);
Assert.AreEqual (xml, sw.ToString ());
}
// bug #53959.
[Test]
public void ReadWriteXml3 ()
{
string input = @"<FullTextResponse>
<Domains>
<AvailResponse info='y' name='novell-ximian-group' />
<AvailResponse info='n' name='ximian' />
</Domains>
</FullTextResponse>";
DataSet ds = new DataSet ();
ds.ReadXml (new StringReader (input));
StringWriter sw = new StringWriter ();
XmlTextWriter xtw = new XmlTextWriter (sw);
xtw.Formatting = Formatting.Indented;
xtw.QuoteChar = '\'';
ds.WriteXml (xtw);
xtw.Flush ();
Assert.AreEqual (input.Replace ("\r\n", "\n"), sw.ToString ().Replace ("\r\n", "\n"));
}
[Test] // bug #60469
public void WriteXmlSchema2 ()
{
string xml = @"<myDataSet xmlns='NetFrameWork'><myTable><id>0</id><item>item 0</item></myTable><myTable><id>1</id><item>item 1</item></myTable><myTable><id>2</id><item>item 2</item></myTable><myTable><id>3</id><item>item 3</item></myTable><myTable><id>4</id><item>item 4</item></myTable><myTable><id>5</id><item>item 5</item></myTable><myTable><id>6</id><item>item 6</item></myTable><myTable><id>7</id><item>item 7</item></myTable><myTable><id>8</id><item>item 8</item></myTable><myTable><id>9</id><item>item 9</item></myTable></myDataSet>";
string schema = @"<?xml version='1.0' encoding='utf-16'?>
<xs:schema id='myDataSet' targetNamespace='NetFrameWork' xmlns:mstns='NetFrameWork' xmlns='NetFrameWork' xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata' attributeFormDefault='qualified' elementFormDefault='qualified'>
<xs:element name='myDataSet' msdata:IsDataSet='true' " +
#if NET_2_0
"msdata:UseCurrentLocale='true'"
#else
"msdata:Locale='fi-FI'"
#endif
+ @">
<xs:complexType>
<xs:choice minOccurs='0' maxOccurs='unbounded'>
<xs:element name='myTable'>
<xs:complexType>
<xs:sequence>
<xs:element name='id' msdata:AutoIncrement='true' type='xs:int' minOccurs='0' />
<xs:element name='item' type='xs:string' minOccurs='0' />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>";
DataSet OriginalDataSet = new DataSet ("myDataSet");
OriginalDataSet.Namespace= "NetFrameWork";
DataTable myTable = new DataTable ("myTable");
DataColumn c1 = new DataColumn ("id", typeof (int));
c1.AutoIncrement = true;
DataColumn c2 = new DataColumn ("item");
myTable.Columns.Add (c1);
myTable.Columns.Add (c2);
OriginalDataSet.Tables.Add (myTable);
// Add ten rows.
DataRow newRow;
for(int i = 0; i < 10; i++) {
newRow = myTable.NewRow ();
newRow ["item"] = "item " + i;
myTable.Rows.Add (newRow);
}
OriginalDataSet.AcceptChanges ();
StringWriter sw = new StringWriter ();
XmlTextWriter xtw = new XmlTextWriter (sw);
xtw.QuoteChar = '\'';
OriginalDataSet.WriteXml (xtw);
string result = sw.ToString ();
Assert.AreEqual (xml, result);
sw = new StringWriter ();
xtw = new XmlTextWriter (sw);
xtw.Formatting = Formatting.Indented;
OriginalDataSet.WriteXmlSchema (xtw);
result = sw.ToString ();
result = result.Replace ("\r\n", "\n").Replace ('"', '\'');
Assert.AreEqual (schema.Replace ("\r\n", "\n"), result);
}
// bug #66366
[Test]
public void WriteXmlSchema3 ()
{
string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
<xs:schema id=""ExampleDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
<xs:element name=""ExampleDataSet"" msdata:IsDataSet=""true"" ";
#if NET_2_0
xmlschema = xmlschema + "msdata:UseCurrentLocale=\"true\"";
#else
xmlschema = xmlschema + "msdata:Locale=\"fi-FI\"";
#endif
xmlschema = xmlschema + @">
<xs:complexType>
<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
<xs:element name=""ExampleDataTable"">
<xs:complexType>
<xs:attribute name=""PrimaryKeyColumn"" type=""xs:int"" use=""required"" />
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
<xs:unique name=""PK_ExampleDataTable"" msdata:PrimaryKey=""true"">
<xs:selector xpath="".//ExampleDataTable"" />
<xs:field xpath=""@PrimaryKeyColumn"" />
</xs:unique>
</xs:element>
</xs:schema>";
DataSet ds = new DataSet ("ExampleDataSet");
ds.Tables.Add (new DataTable ("ExampleDataTable"));
ds.Tables ["ExampleDataTable"].Columns.Add (
new DataColumn ("PrimaryKeyColumn", typeof(int), "", MappingType.Attribute));
ds.Tables ["ExampleDataTable"].Columns ["PrimaryKeyColumn"].AllowDBNull = false;
ds.Tables ["ExampleDataTable"].Constraints.Add (
"PK_ExampleDataTable",
ds.Tables ["ExampleDataTable"].Columns ["PrimaryKeyColumn"],
true);
ds.AcceptChanges ();
StringWriter sw = new StringWriter ();
ds.WriteXmlSchema (sw);
string result = sw.ToString ();
Assert.AreEqual (result.Replace ("\r\n", "\n"), xmlschema.Replace ("\r\n", "\n"));
}
// bug #67792.
[Test]
public void WriteXmlSchema4 ()
{
string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
<xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
";
#if NET_2_0
xmlschema = xmlschema + " <xs:element name=\"Example\" msdata:IsDataSet=\"true\" msdata:UseCurrentLocale=\"true\"";
#else
xmlschema = xmlschema + " <xs:element name=\"Example\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\"";
#endif
xmlschema = xmlschema + @">
<xs:complexType>
<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
<xs:element name=""MyType"">
<xs:complexType>
<xs:attribute name=""ID"" type=""xs:int"" use=""required"" />
<xs:attribute name=""Desc"" type=""xs:string"" />
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>";
DataSet ds = new DataSet ("Example");
// Add MyType DataTable
DataTable dt = new DataTable ("MyType");
ds.Tables.Add (dt);
dt.Columns.Add (new DataColumn ("ID", typeof(int), "",
MappingType.Attribute));
dt.Columns ["ID"].AllowDBNull = false;
dt.Columns.Add (new DataColumn ("Desc", typeof
(string), "", MappingType.Attribute));
ds.AcceptChanges ();
StringWriter sw = new StringWriter ();
ds.WriteXmlSchema (sw);
string result = sw.ToString ();
Assert.AreEqual (result.Replace ("\r\n", "\n"), xmlschema.Replace ("\r\n", "\n"));
}
// bug # 68432
[Test]
public void WriteXmlSchema5 ()
{
string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
<xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
"+
#if NET_2_0
" <xs:element name=\"Example\" msdata:IsDataSet=\"true\" msdata:UseCurrentLocale=\"true\""
#else
" <xs:element name=\"Example\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\""
#endif
+ @">
<xs:complexType>
<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
<xs:element name=""StandAlone"">
<xs:complexType>
<xs:attribute name=""ID"" type=""xs:int"" use=""required"" />
<xs:attribute name=""Desc"" type=""xs:string"" use=""required"" />
</xs:complexType>
</xs:element>
<xs:element name=""Dimension"">
<xs:complexType>
<xs:attribute name=""Number"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
<xs:attribute name=""Title"" type=""xs:string"" use=""required"" />
</xs:complexType>
</xs:element>
<xs:element name=""Element"">
<xs:complexType>
<xs:attribute name=""Dimension"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
<xs:attribute name=""Number"" msdata:ReadOnly=""true"" type=""xs:int"" use=""required"" />
<xs:attribute name=""Title"" type=""xs:string"" use=""required"" />
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
<xs:unique name=""PK_Dimension"" msdata:PrimaryKey=""true"">
<xs:selector xpath="".//Dimension"" />
<xs:field xpath=""@Number"" />
</xs:unique>
<xs:unique name=""PK_Element"" msdata:PrimaryKey=""true"">
<xs:selector xpath="".//Element"" />
<xs:field xpath=""@Dimension"" />
<xs:field xpath=""@Number"" />
</xs:unique>
<xs:keyref name=""FK_Element_To_Dimension"" refer=""PK_Dimension"">
<xs:selector xpath="".//Element"" />
<xs:field xpath=""@Dimension"" />
</xs:keyref>
</xs:element>
</xs:schema>";
DataSet ds = new DataSet("Example");
// Add a DataTable with no ReadOnly columns
DataTable dt1 = new DataTable ("StandAlone");
ds.Tables.Add (dt1);
// Add a ReadOnly column
dt1.Columns.Add (new DataColumn ("ID", typeof(int), "",
MappingType.Attribute));
dt1.Columns ["ID"].AllowDBNull = false;
dt1.Columns.Add (new DataColumn ("Desc", typeof
(string), "", MappingType.Attribute));
dt1.Columns ["Desc"].AllowDBNull = false;
// Add related DataTables with ReadOnly columns
DataTable dt2 = new DataTable ("Dimension");
ds.Tables.Add (dt2);
dt2.Columns.Add (new DataColumn ("Number", typeof
(int), "", MappingType.Attribute));
dt2.Columns ["Number"].AllowDBNull = false;
dt2.Columns ["Number"].ReadOnly = true;
dt2.Columns.Add (new DataColumn ("Title", typeof
(string), "", MappingType.Attribute));
dt2.Columns ["Title"].AllowDBNull = false;
dt2.Constraints.Add ("PK_Dimension", dt2.Columns ["Number"], true);
DataTable dt3 = new DataTable ("Element");
ds.Tables.Add(dt3);
dt3.Columns.Add (new DataColumn ("Dimension", typeof
(int), "", MappingType.Attribute));
dt3.Columns ["Dimension"].AllowDBNull = false;
dt3.Columns ["Dimension"].ReadOnly = true;
dt3.Columns.Add (new DataColumn ("Number", typeof
(int), "", MappingType.Attribute));
dt3.Columns ["Number"].AllowDBNull = false;
dt3.Columns ["Number"].ReadOnly = true;
dt3.Columns.Add (new DataColumn ("Title", typeof
(string), "", MappingType.Attribute));
dt3.Columns ["Title"].AllowDBNull = false;
dt3.Constraints.Add ("PK_Element", new DataColumn[] {
dt3.Columns ["Dimension"],
dt3.Columns ["Number"] }, true);
ds.Relations.Add ("FK_Element_To_Dimension",
dt2.Columns ["Number"], dt3.Columns["Dimension"]);
ds.AcceptChanges ();
StringWriter sw = new StringWriter ();
ds.WriteXmlSchema (sw);
string result = sw.ToString ();
Assert.AreEqual (result.Replace ("\r\n", "\n"), xmlschema.Replace ("\r\n", "\n"));
}
// bug #67793
[Test]
public void WriteXmlSchema6 ()
{
string xmlschema = @"<?xml version=""1.0"" encoding=""utf-16""?>
<xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
"+
#if NET_2_0
@" <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:UseCurrentLocale=""true"""
#else
@" <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:Locale=""fi-FI"""
#endif
+ @">
<xs:complexType>
<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
<xs:element name=""MyType"">
<xs:complexType>
<xs:attribute name=""Desc"">
<xs:simpleType>
<xs:restriction base=""xs:string"">
<xs:maxLength value=""32"" />
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>";
DataSet ds = new DataSet("Example");
// Add MyType DataTable
ds.Tables.Add ("MyType");
ds.Tables ["MyType"].Columns.Add (new DataColumn(
"Desc", typeof (string), "", MappingType.Attribute));
ds.Tables ["MyType"].Columns ["Desc"].MaxLength = 32;
ds.AcceptChanges ();
StringWriter sw = new StringWriter ();
ds.WriteXmlSchema (sw);
string result = sw.ToString ();
Assert.AreEqual (result.Replace ("\r\n", "\n"), xmlschema.Replace ("\r\n", "\n"));
}
// bug #68008
[Test]
public void WriteXmlSchema7 ()
{
DataSet ds = new DataSet ();
DataTable dt = new DataTable ("table");
dt.Columns.Add ("col1");
dt.Columns.Add ("col2");
ds.Tables.Add (dt);
dt.Rows.Add (new object [] {"foo", "bar"});
StringWriter sw = new StringWriter ();
ds.WriteXmlSchema (sw);
Assert.IsTrue (sw.ToString ().IndexOf ("xmlns=\"\"") > 0);
}
// bug #61233
[Test]
public void WriteXmlExtendedProperties ()
{
string xml = @"<?xml version=""1.0"" encoding=""utf-16""?>
<xs:schema id=""NewDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"" xmlns:msprop=""urn:schemas-microsoft-com:xml-msprop"">
" +
#if NET_2_0
@" <xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:UseCurrentLocale=""true"" msprop:version=""version 2.1"">"
#else
@" <xs:element name=""NewDataSet"" msdata:IsDataSet=""true"" msdata:Locale=""fi-FI"" msprop:version=""version 2.1"">"
#endif
+ @"
<xs:complexType>
<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
<xs:element name=""Foo"">
<xs:complexType>
<xs:sequence>
<xs:element name=""col1"" type=""xs:string"" minOccurs=""0"" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>";
DataSet ds = new DataSet ();
ds.ExtendedProperties ["version"] = "version 2.1";
DataTable dt = new DataTable ("Foo");
dt.Columns.Add ("col1");
dt.Rows.Add (new object [] {"foo"});
ds.Tables.Add (dt);
StringWriter sw = new StringWriter ();
ds.WriteXmlSchema (sw);
string result = sw.ToString ();
Assert.AreEqual (result.Replace ("\r\n", "\n"), xml.Replace ("\r\n", "\n"));
}
[Test]
public void WriteXmlModeSchema ()
{
// This is the MS output of WriteXmlSchema().
string xml = @"<Example>
<xs:schema id=""Example"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
" +
#if NET_2_0
@" <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:UseCurrentLocale=""true"">"
#else
@" <xs:element name=""Example"" msdata:IsDataSet=""true"" msdata:Locale=""fi-FI"">"
#endif
+ @"
<xs:complexType>
<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
<xs:element name=""Dimension"">
<xs:complexType>
<xs:sequence>
<xs:element name=""Number"" type=""xs:int"" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name=""Element"">
<xs:complexType>
<xs:sequence>
<xs:element name=""Dimension"" type=""xs:int"" />
<xs:element name=""Number"" type=""xs:int"" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
<xs:unique name=""PK_Dimension"" msdata:PrimaryKey=""true"">
<xs:selector xpath="".//Dimension"" />
<xs:field xpath=""Number"" />
</xs:unique>
<xs:unique name=""PK_Element"" msdata:PrimaryKey=""true"">
<xs:selector xpath="".//Element"" />
<xs:field xpath=""Dimension"" />
<xs:field xpath=""Number"" />
</xs:unique>
<xs:keyref name=""FK_Element_To_Dimension"" refer=""PK_Dimension"">
<xs:selector xpath="".//Element"" />
<xs:field xpath=""Dimension"" />
</xs:keyref>
</xs:element>
</xs:schema>
<Dimension>
<Number>0</Number>
</Dimension>
<Dimension>
<Number>1</Number>
</Dimension>
<Element>
<Dimension>0</Dimension>
<Number>0</Number>
</Element>
<Element>
<Dimension>0</Dimension>
<Number>1</Number>
</Element>
<Element>
<Dimension>0</Dimension>
<Number>2</Number>
</Element>
<Element>
<Dimension>0</Dimension>
<Number>3</Number>
</Element>
<Element>
<Dimension>1</Dimension>
<Number>0</Number>
</Element>
<Element>
<Dimension>1</Dimension>
<Number>1</Number>
</Element>
</Example>";
DataSet ds = new DataSet("Example");
// Dimension DataTable
DataTable dt1 = new DataTable ("Dimension");
ds.Tables.Add (dt1);
dt1.Columns.Add (new DataColumn ("Number", typeof (int)));
dt1.Columns ["Number"].AllowDBNull = false;
dt1.Constraints.Add ("PK_Dimension", dt1.Columns ["Number"], true);
// Element DataTable
DataTable dt2 = new DataTable ("Element");
ds.Tables.Add (dt2);
dt2.Columns.Add (new DataColumn ("Dimension", typeof (int)));
dt2.Columns ["Dimension"].AllowDBNull = false;
dt2.Columns.Add (new DataColumn ("Number", typeof (int)));
dt2.Columns ["Number"].AllowDBNull = false;
dt2.Constraints.Add ("PK_Element", new DataColumn[] {
dt2.Columns ["Dimension"],
dt2.Columns ["Number"] },
true);
// Add DataRelations
ds.Relations.Add ("FK_Element_To_Dimension",
dt1.Columns ["Number"],
dt2.Columns ["Dimension"], true);
// Add 2 Dimensions
for (int i = 0; i < 2; i++) {
DataRow newRow = dt1.NewRow ();
newRow ["Number"] = i;
dt1.Rows.Add (newRow);
}
// Dimension 0 => 4 Elements
for (int i = 0; i < 4; i++) {
DataRow newRow = dt2.NewRow();
newRow ["Dimension"] = 0;
newRow ["Number"] = i;
dt2.Rows.Add (newRow);
}
// Dimension 1 => 2 Elements
for (int i = 0; i < 2; i++) {
DataRow newRow = dt2.NewRow();
newRow ["Dimension"] = 1;
newRow ["Number"] = i;
dt2.Rows.Add (newRow);
}
ds.AcceptChanges ();
StringWriter sw = new StringWriter ();
ds.WriteXml(sw, XmlWriteMode.WriteSchema);
string result = sw.ToString ();
Assert.AreEqual (result.Replace ("\r\n", "\n"), xml.Replace ("\r\n", "\n"));
}
[Test]
public void WriteXmlModeSchema1 () {
string SerializedDataTable =
@"<rdData>
<MyDataTable CustomerID='VINET' CompanyName='Vins et alcools Chevalier' ContactName='Paul Henriot' />
</rdData>";
string expected =
@"<rdData>
<xs:schema id=""rdData"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
<xs:element name=""rdData"" msdata:IsDataSet=""true"" " +
@"msdata:Locale=""en-US"">" +
@"
<xs:complexType>
<xs:choice minOccurs=""0"" maxOccurs=""unbounded"">
<xs:element name=""MyDataTable"">
<xs:complexType>
<xs:attribute name=""CustomerID"" type=""xs:string"" />
<xs:attribute name=""CompanyName"" type=""xs:string"" />
<xs:attribute name=""ContactName"" type=""xs:string"" />
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>
<MyDataTable CustomerID=""VINET"" CompanyName=""Vins et alcools Chevalier"" ContactName=""Paul Henriot"" />
</rdData>";
DataSet set;
set = new DataSet ();
set.ReadXml (new StringReader (SerializedDataTable));
StringWriter w = new StringWriter ();
set.WriteXml (w, XmlWriteMode.WriteSchema);
string result = w.ToString ();
Assert.AreEqual (expected.Replace ("\r", ""), result.Replace ("\r", ""));
}
[Test]
public void DeserializeModifiedDataSet ()
{
// Serialization begins
DataSet prevDs = new DataSet ();
DataTable dt = prevDs.Tables.Add ();
dt.Columns.Add(new DataColumn("Id", typeof(string)));
DataRow dr = dt.NewRow();
dr [0] = "a";
dt.Rows.Add (dr);
prevDs.AcceptChanges ();
dr = prevDs.Tables[0].Rows[0];
dr [0] = "b";
XmlSerializer serializer = new XmlSerializer (typeof (DataSet));
StringWriter sw = new StringWriter ();
XmlTextWriter xw = new XmlTextWriter (sw);
xw.QuoteChar = '\'';
serializer.Serialize (xw, prevDs);
// Deserialization begins
StringReader sr = new StringReader (sw.ToString ());
XmlTextReader reader = new XmlTextReader (sr);
XmlSerializer serializer1 = new XmlSerializer (typeof (DataSet));
DataSet ds = serializer1.Deserialize (reader) as DataSet;
Assert.AreEqual (
prevDs.Tables[0].Rows [0][0,DataRowVersion.Original].ToString (),
ds.Tables[0].Rows [0][0,DataRowVersion.Original].ToString (),
"deserialization after modification does not give original values");
Assert.AreEqual (
prevDs.Tables[0].Rows [0][0,DataRowVersion.Current].ToString (),
ds.Tables[0].Rows [0][0,DataRowVersion.Current].ToString (),
"deserialization after modification oes not give current values");
}
[Test]
public void Bug420862 ()
{
DataSet ds = new DataSet ("d");
DataTable dt = ds.Tables.Add ("t");
dt.Columns.Add ("c", typeof (ushort));
XmlSchema xs = XmlSchema.Read (new StringReader (ds.GetXmlSchema ()), null);
xs.Compile (null);
// follow the nesting of the schema in the foreach
foreach (XmlSchemaElement d in xs.Items) {
Assert.AreEqual ("d", d.Name);
XmlSchemaChoice dsc = (XmlSchemaChoice) ((XmlSchemaComplexType) d.SchemaType).Particle;
foreach (XmlSchemaElement t in dsc.Items) {
Assert.AreEqual ("t", t.Name);
XmlSchemaSequence tss = (XmlSchemaSequence) ((XmlSchemaComplexType) t.SchemaType).Particle;
foreach (XmlSchemaElement c in tss.Items) {
Assert.AreEqual ("c", c.Name);
Assert.AreEqual ("unsignedShort", c.SchemaTypeName.Name);
return;
}
}
}
Assert.Fail ();
}
/// <summary>
/// Test for testing DataSet.Clear method with foriegn key relations
/// This is expected to clear all the related datatable rows also
/// </summary>
[Test]
public void DataSetClearTest ()
{
DataSet ds = new DataSet ();
DataTable parent = ds.Tables.Add ("Parent");
DataTable child = ds.Tables.Add ("Child");
parent.Columns.Add ("id", typeof (int));
child.Columns.Add ("ref_id", typeof(int));
child.Constraints.Add (new ForeignKeyConstraint ("fk_constraint", parent.Columns [0], child.Columns [0]));
DataRow dr = parent.NewRow ();
dr [0] = 1;
parent.Rows.Add (dr);
dr.AcceptChanges ();
dr = child.NewRow ();
dr [0] = 1;
child.Rows.Add (dr);
dr.AcceptChanges ();
try {
ds.Clear (); // this should clear all the rows in parent & child tables
} catch (Exception e) {
throw (new Exception ("Exception should not have been thrown at Clear method" + e.ToString ()));
}
Assert.AreEqual (0, parent.Rows.Count, "parent table rows should not exist!");
Assert.AreEqual (0, child.Rows.Count, "child table rows should not exist!");
}
[Test]
public void CloneSubClassTest()
{
MyDataSet ds1 = new MyDataSet();
MyDataSet ds = (MyDataSet)(ds1.Clone());
Assert.AreEqual (2, MyDataSet.count, "A#01");
}
#region DataSet.GetChanges Tests
public void GetChanges_Relations_DifferentRowStatesTest ()
{
DataSet ds = new DataSet ("ds");
DataTable parent = ds.Tables.Add ("parent");
DataTable child = ds.Tables.Add ("child");
parent.Columns.Add ("id", typeof (int));
parent.Columns.Add ("name", typeof (string));
child.Columns.Add ("id", typeof (int));
child.Columns.Add ("parent", typeof (int));
child.Columns.Add ("name", typeof (string));
parent.Rows.Add (new object [] { 1, "mono parent 1" } );
parent.Rows.Add (new object [] { 2, "mono parent 2" } );
parent.Rows.Add (new object [] { 3, "mono parent 3" } );
parent.Rows.Add (new object [] { 4, "mono parent 4" } );
parent.AcceptChanges ();
child.Rows.Add (new object [] { 1, 1, "mono child 1" } );
child.Rows.Add (new object [] { 2, 2, "mono child 2" } );
child.Rows.Add (new object [] { 3, 3, "mono child 3" } );
child.AcceptChanges ();
DataRelation relation = ds.Relations.Add ("parent_child",
parent.Columns ["id"],
child.Columns ["parent"]);
// modify the parent and get changes
child.Rows [1]["parent"] = 4;
DataSet changes = ds.GetChanges ();
DataRow row = changes.Tables ["parent"].Rows[0];
Assert.AreEqual ((int) parent.Rows [3][0], (int) row [0], "#RT1");
Assert.AreEqual (1, changes.Tables ["parent"].Rows.Count, "#RT2 only get parent row with current version");
ds.RejectChanges ();
// delete a child row and get changes.
child.Rows [0].Delete ();
changes = ds.GetChanges ();
Assert.AreEqual (changes.Tables.Count, 2, "#RT3 Should import parent table as well");
Assert.AreEqual (1, changes.Tables ["parent"].Rows.Count, "#RT4 only get parent row with original version");
Assert.AreEqual (1, (int) changes.Tables ["parent"].Rows [0][0], "#RT5 parent row based on original version");
}
#endregion // DataSet.GetChanges Tests
[Test]
public void RuleTest ()
{
DataSet ds = new DataSet ("testds");
DataTable parent = ds.Tables.Add ("parent");
DataTable child = ds.Tables.Add ("child");
parent.Columns.Add ("id", typeof (int));
parent.Columns.Add ("name", typeof (string));
parent.PrimaryKey = new DataColumn [] {parent.Columns ["id"]} ;
child.Columns.Add ("id", typeof (int));
child.Columns.Add ("parent", typeof (int));
child.Columns.Add ("name", typeof (string));
child.PrimaryKey = new DataColumn [] {child.Columns ["id"]} ;
DataRelation relation = ds.Relations.Add ("parent_child",
parent.Columns ["id"],
child.Columns ["parent"]);
parent.Rows.Add (new object [] {1, "mono test 1"});
parent.Rows.Add (new object [] {2, "mono test 2"});
parent.Rows.Add (new object [] {3, "mono test 3"});
child.Rows.Add (new object [] {1, 1, "mono child test 1"});
child.Rows.Add (new object [] {2, 2, "mono child test 2"});
child.Rows.Add (new object [] {3, 3, "mono child test 3"});
ds.AcceptChanges ();
parent.Rows [0] ["name"] = "mono changed test 1";
Assert.AreEqual (DataRowState.Unchanged, parent.Rows [0].GetChildRows (relation) [0].RowState,
"#RT1 child should not be modified");
ds.RejectChanges ();
parent.Rows [0] ["id"] = "4";
DataRow childRow = parent.Rows [0].GetChildRows (relation) [0];
Assert.AreEqual (DataRowState.Modified, childRow.RowState, "#RT2 child should be modified");
Assert.AreEqual (4, (int) childRow ["parent"], "#RT3 child should point to modified row");
}
[Test] // from bug #76480
public void WriteXmlEscapeName ()
{
// create dataset
DataSet data = new DataSet();
DataTable mainTable = data.Tables.Add ("main");
DataColumn mainkey = mainTable.Columns.Add ("mainkey", typeof(Guid));
mainTable.Columns.Add ("col.2<hi/>", typeof (string));
mainTable.Columns.Add ("#col3", typeof (string));
// populate data
mainTable.Rows.Add (new object [] { Guid.NewGuid (), "hi there", "my friend" } );
mainTable.Rows.Add (new object [] { Guid.NewGuid (), "what is", "your name" } );
mainTable.Rows.Add (new object [] { Guid.NewGuid (), "I have", "a bean" } );
// write xml
StringWriter writer = new StringWriter ();
data.WriteXml (writer, XmlWriteMode.WriteSchema);
string xml = writer.ToString ();
Assert.IsTrue (xml.IndexOf ("name=\"col.2_x003C_hi_x002F__x003E_\"") > 0, "#1");
Assert.IsTrue (xml.IndexOf ("name=\"_x0023_col3\"") > 0, "#2");
Assert.IsTrue (xml.IndexOf ("<col.2_x003C_hi_x002F__x003E_>hi there</col.2_x003C_hi_x002F__x003E_>") > 0, "#3");
// read xml
DataSet data2 = new DataSet();
data2.ReadXml (new StringReader (
writer.GetStringBuilder ().ToString ()));
}
#if NET_2_0
// it is basically a test for XmlSerializer, but I need it
// here to not add dependency on sys.data.dll in sys.xml test.
[Test]
public void ReflectTypedDataSet ()
{
XmlReflectionImporter imp = new XmlReflectionImporter ();
// it used to cause "missing GetDataSetSchema" error.
imp.ImportTypeMapping (typeof (MonkeyDataSet));
}
#region DataSet.CreateDataReader Tests and DataSet.Load Tests
private DataSet ds;
private DataTable dt1, dt2;
private void localSetup () {
ds = new DataSet ("test");
dt1 = new DataTable ("test1");
dt1.Columns.Add ("id1", typeof (int));
dt1.Columns.Add ("name1", typeof (string));
//dt1.PrimaryKey = new DataColumn[] { dt1.Columns["id"] };
dt1.Rows.Add (new object[] { 1, "mono 1" });
dt1.Rows.Add (new object[] { 2, "mono 2" });
dt1.Rows.Add (new object[] { 3, "mono 3" });
dt1.AcceptChanges ();
dt2 = new DataTable ("test2");
dt2.Columns.Add ("id2", typeof (int));
dt2.Columns.Add ("name2", typeof (string));
dt2.Columns.Add ("name3", typeof (string));
//dt2.PrimaryKey = new DataColumn[] { dt2.Columns["id"] };
dt2.Rows.Add (new object[] { 4, "mono 4", "four" });
dt2.Rows.Add (new object[] { 5, "mono 5", "five" });
dt2.Rows.Add (new object[] { 6, "mono 6", "six" });
dt2.AcceptChanges ();
ds.Tables.Add (dt1);
ds.Tables.Add (dt2);
ds.AcceptChanges ();
}
[Test]
public void CreateDataReader1 () {
// For First CreateDataReader Overload
localSetup ();
DataTableReader dtr = ds.CreateDataReader ();
Assert.IsTrue (dtr.HasRows, "HasRows");
int ti = 0;
do {
Assert.AreEqual (ds.Tables[ti].Columns.Count, dtr.FieldCount, "CountCols-" + ti);
int ri = 0;
while (dtr.Read ()) {
for (int i = 0; i < dtr.FieldCount; i++)
Assert.AreEqual (ds.Tables[ti].Rows[ri][i], dtr[i], "RowData-"+ti+"-"+ri+"-"+i);
ri++;
}
ti++;
} while (dtr.NextResult ());
}
[Test]
public void CreateDataReader2 () {
// For Second CreateDataReader Overload -
// compare to ds.Tables
localSetup ();
DataTableReader dtr = ds.CreateDataReader (dt1, dt2);
Assert.IsTrue (dtr.HasRows, "HasRows");
int ti = 0;
do {
Assert.AreEqual (ds.Tables[ti].Columns.Count, dtr.FieldCount, "CountCols-" + ti);
int ri = 0;
while (dtr.Read ()) {
for (int i = 0; i < dtr.FieldCount; i++)
Assert.AreEqual (ds.Tables[ti].Rows[ri][i], dtr[i], "RowData-" + ti + "-" + ri + "-" + i);
ri++;
}
ti++;
} while (dtr.NextResult ());
}
[Test]
public void CreateDataReader3 () {
// For Second CreateDataReader Overload -
// compare to dt1 and dt2
localSetup ();
ds.Tables.Clear ();
DataTableReader dtr = ds.CreateDataReader (dt1, dt2);
Assert.IsTrue (dtr.HasRows, "HasRows");
string name = "dt1";
DataTable dtn = dt1;
do {
Assert.AreEqual (dtn.Columns.Count, dtr.FieldCount, "CountCols-" + name);
int ri = 0;
while (dtr.Read ()) {
for (int i = 0; i < dtr.FieldCount; i++)
Assert.AreEqual (dtn.Rows[ri][i], dtr[i], "RowData-" + name + "-" + ri + "-" + i);
ri++;
}
if (dtn == dt1) {
dtn = dt2;
name = "dt2";
} else {
dtn = null;
name = null;
}
} while (dtr.NextResult ());
}
[Test]
[ExpectedException (typeof (ArgumentException))]
public void CreateDataReaderNoTable () {
DataSet dsr = new DataSet ();
DataTableReader dtr = dsr.CreateDataReader ();
}
internal struct fillErrorStruct {
internal string error;
internal string tableName;
internal int rowKey;
internal bool contFlag;
internal void init (string tbl, int row, bool cont, string err) {
tableName = tbl;
rowKey = row;
contFlag = cont;
error = err;
}
}
private fillErrorStruct[] fillErr = new fillErrorStruct[3];
private int fillErrCounter;
private void fillErrorHandler (object sender, FillErrorEventArgs e) {
e.Continue = fillErr[fillErrCounter].contFlag;
Assert.AreEqual (fillErr[fillErrCounter].tableName, e.DataTable.TableName, "fillErr-T");
Assert.AreEqual (fillErr[fillErrCounter].contFlag, e.Continue, "fillErr-C");
fillErrCounter++;
}
[Test]
public void Load_Basic () {
localSetup ();
DataSet dsLoad = new DataSet ("LoadBasic");
DataTable table1 = new DataTable ();
dsLoad.Tables.Add (table1);
DataTable table2 = new DataTable ();
dsLoad.Tables.Add (table2);
DataTableReader dtr = ds.CreateDataReader ();
dsLoad.Load (dtr, LoadOption.OverwriteChanges, table1, table2);
CompareTables (dsLoad);
}
[Test]
[ExpectedException (typeof (ArgumentException))]
public void Load_TableUnknown () {
localSetup ();
DataSet dsLoad = new DataSet ("LoadTableUnknown");
DataTable table1 = new DataTable ();
dsLoad.Tables.Add (table1);
DataTable table2 = new DataTable ();
// table2 is not added to dsLoad [dsLoad.Tables.Add (table2);]
DataTableReader dtr = ds.CreateDataReader ();
dsLoad.Load (dtr, LoadOption.OverwriteChanges, table1, table2);
}
[Test]
public void Load_TableConflictT () {
fillErrCounter = 0;
fillErr[0].init ("Table1", 1, true,
"Input string was not in a correct format.Couldn't store <mono 1> in name1 Column. Expected type is Double.");
fillErr[1].init ("Table1", 2, true,
"Input string was not in a correct format.Couldn't store <mono 2> in name1 Column. Expected type is Double.");
fillErr[2].init ("Table1", 3, true,
"Input string was not in a correct format.Couldn't store <mono 3> in name1 Column. Expected type is Double.");
localSetup ();
DataSet dsLoad = new DataSet ("LoadTableConflict");
DataTable table1 = new DataTable ();
table1.Columns.Add ("name1", typeof (double));
dsLoad.Tables.Add (table1);
DataTable table2 = new DataTable ();
dsLoad.Tables.Add (table2);
DataTableReader dtr = ds.CreateDataReader ();
dsLoad.Load (dtr, LoadOption.PreserveChanges,
fillErrorHandler, table1, table2);
}
[Test]
[ExpectedException (typeof (ArgumentException))]
public void Load_TableConflictF () {
fillErrCounter = 0;
fillErr[0].init ("Table1", 1, false,
"Input string was not in a correct format.Couldn't store <mono 1> in name1 Column. Expected type is Double.");
localSetup ();
DataSet dsLoad = new DataSet ("LoadTableConflict");
DataTable table1 = new DataTable ();
table1.Columns.Add ("name1", typeof (double));
dsLoad.Tables.Add (table1);
DataTable table2 = new DataTable ();
dsLoad.Tables.Add (table2);
DataTableReader dtr = ds.CreateDataReader ();
dsLoad.Load (dtr, LoadOption.Upsert,
fillErrorHandler, table1, table2);
}
[Test]
public void Load_StringsAsc () {
localSetup ();
DataSet dsLoad = new DataSet ("LoadStrings");
DataTable table1 = new DataTable ("First");
dsLoad.Tables.Add (table1);
DataTable table2 = new DataTable ("Second");
dsLoad.Tables.Add (table2);
DataTableReader dtr = ds.CreateDataReader ();
dsLoad.Load (dtr, LoadOption.OverwriteChanges, "First", "Second");
CompareTables (dsLoad);
}
[Test]
public void Load_StringsDesc () {
localSetup ();
DataSet dsLoad = new DataSet ("LoadStrings");
DataTable table1 = new DataTable ("First");
dsLoad.Tables.Add (table1);
DataTable table2 = new DataTable ("Second");
dsLoad.Tables.Add (table2);
DataTableReader dtr = ds.CreateDataReader ();
dsLoad.Load (dtr, LoadOption.PreserveChanges, "Second", "First");
Assert.AreEqual (2, dsLoad.Tables.Count, "Tables");
Assert.AreEqual (3, dsLoad.Tables[0].Rows.Count, "T1-Rows");
Assert.AreEqual (3, dsLoad.Tables[0].Columns.Count, "T1-Columns");
Assert.AreEqual (3, dsLoad.Tables[1].Rows.Count, "T2-Rows");
Assert.AreEqual (2, dsLoad.Tables[1].Columns.Count, "T2-Columns");
}
[Test]
public void Load_StringsNew () {
localSetup ();
DataSet dsLoad = new DataSet ("LoadStrings");
DataTable table1 = new DataTable ("First");
dsLoad.Tables.Add (table1);
DataTable table2 = new DataTable ("Second");
dsLoad.Tables.Add (table2);
DataTableReader dtr = ds.CreateDataReader ();
dsLoad.Load (dtr, LoadOption.Upsert, "Third", "Fourth");
Assert.AreEqual (4, dsLoad.Tables.Count, "Tables");
Assert.AreEqual ("First", dsLoad.Tables[0].TableName, "T1-Name");
Assert.AreEqual (0, dsLoad.Tables[0].Rows.Count, "T1-Rows");
Assert.AreEqual (0, dsLoad.Tables[0].Columns.Count, "T1-Columns");
Assert.AreEqual ("Second", dsLoad.Tables[1].TableName, "T2-Name");
Assert.AreEqual (0, dsLoad.Tables[1].Rows.Count, "T2-Rows");
Assert.AreEqual (0, dsLoad.Tables[1].Columns.Count, "T2-Columns");
Assert.AreEqual ("Third", dsLoad.Tables[2].TableName, "T3-Name");
Assert.AreEqual (3, dsLoad.Tables[2].Rows.Count, "T3-Rows");
Assert.AreEqual (2, dsLoad.Tables[2].Columns.Count, "T3-Columns");
Assert.AreEqual ("Fourth", dsLoad.Tables[3].TableName, "T4-Name");
Assert.AreEqual (3, dsLoad.Tables[3].Rows.Count, "T4-Rows");
Assert.AreEqual (3, dsLoad.Tables[3].Columns.Count, "T4-Columns");
}
[Test]
public void Load_StringsNewMerge () {
localSetup ();
DataSet dsLoad = new DataSet ("LoadStrings");
DataTable table1 = new DataTable ("First");
table1.Columns.Add ("col1", typeof (string));
table1.Rows.Add (new object[] { "T1Row1" });
dsLoad.Tables.Add (table1);
DataTable table2 = new DataTable ("Second");
table2.Columns.Add ("col2", typeof (string));
table2.Rows.Add (new object[] { "T2Row1" });
table2.Rows.Add (new object[] { "T2Row2" });
dsLoad.Tables.Add (table2);
DataTableReader dtr = ds.CreateDataReader ();
dsLoad.Load (dtr, LoadOption.OverwriteChanges, "Third", "First");
Assert.AreEqual (3, dsLoad.Tables.Count, "Tables");
Assert.AreEqual ("First", dsLoad.Tables[0].TableName, "T1-Name");
Assert.AreEqual (4, dsLoad.Tables[0].Rows.Count, "T1-Rows");
Assert.AreEqual (4, dsLoad.Tables[0].Columns.Count, "T1-Columns");
Assert.AreEqual ("Second", dsLoad.Tables[1].TableName, "T2-Name");
Assert.AreEqual (2, dsLoad.Tables[1].Rows.Count, "T2-Rows");
Assert.AreEqual (1, dsLoad.Tables[1].Columns.Count, "T2-Columns");
Assert.AreEqual ("Third", dsLoad.Tables[2].TableName, "T3-Name");
Assert.AreEqual (3, dsLoad.Tables[2].Rows.Count, "T3-Rows");
Assert.AreEqual (2, dsLoad.Tables[2].Columns.Count, "T3-Columns");
}
[Test]
public void ReadDiff ()
{
DataSet dsTest = new DataSet ("MonoTouchTest");
var dt = new DataTable ("123");
dt.Columns.Add (new DataColumn ("Value1"));
dt.Columns.Add (new DataColumn ("Value2"));
dsTest.Tables.Add (dt);
dsTest.ReadXml (new StringReader (@"
<diffgr:diffgram
xmlns:msdata='urn:schemas-microsoft-com:xml-msdata'
xmlns:diffgr='urn:schemas-microsoft-com:xml-diffgram-v1'>
<MonoTouchTest>
<_x0031_23 diffgr:id='1231' msdata:rowOrder='0'>
<Value1>Row1Value1</Value1>
<Value2>Row1Value2</Value2>
</_x0031_23>
</MonoTouchTest>
</diffgr:diffgram>
"));
Assert.AreEqual ("123", dsTest.Tables [0].TableName, "#1");
Assert.AreEqual (1, dsTest.Tables [0].Rows.Count, "#2");
}
private void CompareTables (DataSet dsLoad) {
Assert.AreEqual (ds.Tables.Count, dsLoad.Tables.Count, "NumTables");
for (int tc = 0; tc < dsLoad.Tables.Count; tc++) {
Assert.AreEqual (ds.Tables[tc].Columns.Count, dsLoad.Tables[tc].Columns.Count, "Table" + tc + "-NumCols");
Assert.AreEqual (ds.Tables[tc].Rows.Count, dsLoad.Tables[tc].Rows.Count, "Table" + tc + "-NumRows");
for (int cc = 0; cc < dsLoad.Tables[tc].Columns.Count; cc++) {
Assert.AreEqual (ds.Tables[tc].Columns[cc].ColumnName,
dsLoad.Tables[tc].Columns[cc].ColumnName,
"Table" + tc + "-" + "Col" + cc + "-Name");
}
for (int rc = 0; rc < dsLoad.Tables[tc].Rows.Count; rc++) {
for (int cc = 0; cc < dsLoad.Tables[tc].Columns.Count; cc++) {
Assert.AreEqual (ds.Tables[tc].Rows[rc].ItemArray[cc],
dsLoad.Tables[tc].Rows[rc].ItemArray[cc],
"Table" + tc + "-Row" + rc + "-Col" + cc + "-Data");
}
}
}
}
#endregion // DataSet.CreateDataReader Tests and DataSet.Load Tests
#endif
}
public class MyDataSet:DataSet {
public static int count = 0;
public MyDataSet() {
count++;
}
}
}