public void SequentialRead1()
{
// simple element -> simple table
var ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "SingleText", xml5,
XmlReadMode.Auto, XmlReadMode.InferSchema,
"root", 0);
DataSetAssertion.AssertReadXml(ds, "SimpleTable", xml6,
XmlReadMode.Auto, XmlReadMode.InferSchema,
"NewDataSet", 1);
DataSetAssertion.AssertDataTable("seq1", ds.Tables[0], "root", 1, 1, 0, 0, 0, 0);
}
public void IgnoredNamespaces()
{
string xml = "<root attr='val' xmlns:a='urn:foo' a:foo='hogehoge' />";
DataSet ds = new DataSet();
ds.InferXmlSchema(new StringReader(xml), null);
DataSetAssertion.AssertDataSet("ds", ds, "NewDataSet", 1, 0);
DataSetAssertion.AssertDataTable("dt", ds.Tables[0], "root", 2, 0, 0, 0, 0, 0);
ds = new DataSet();
ds.InferXmlSchema(new StringReader(xml), new string[] { "urn:foo" });
DataSetAssertion.AssertDataSet("ds", ds, "NewDataSet", 1, 0);
// a:foo is ignored
DataSetAssertion.AssertDataTable("dt", ds.Tables[0], "root", 1, 0, 0, 0, 0, 0);
}
public void SingleChild()
{
DataSet ds = GetDataSet(_xml5, null);
DataSetAssertion.AssertDataSet("ds", ds, "NewDataSet", 1, 0);
DataTable dt = ds.Tables[0];
DataSetAssertion.AssertDataTable("dt", dt, "root", 1, 0, 0, 0, 0, 0);
DataSetAssertion.AssertDataColumn("col", dt.Columns[0], "child", true, false, 0, 1, "child", MappingType.Element, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 0, string.Empty, false, false);
ds = GetDataSet(_xml6, null);
DataSetAssertion.AssertDataSet("ds", ds, "NewDataSet", 1, 0);
dt = ds.Tables[0];
DataSetAssertion.AssertDataTable("dt", dt, "root", 1, 0, 0, 0, 0, 0);
DataSetAssertion.AssertDataColumn("col", dt.Columns[0], "col1", true, false, 0, 1, "col1", MappingType.Element, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 0, string.Empty, false, false);
}
public void SignificantWhitespaceIgnored2()
{
// To make sure, create pure significant whitespace element
// using XmlNodeReader (that does not have xml:space attribute
// column).
DataSet ds = new DataSet();
XmlDocument doc = new XmlDocument();
doc.AppendChild(doc.CreateElement("root"));
doc.DocumentElement.AppendChild(doc.CreateSignificantWhitespace
(" \n\n"));
XmlReader xr = new XmlNodeReader(doc);
ds.InferXmlSchema(xr, null);
DataSetAssertion.AssertDataSet("pure_whitespace", ds, "root", 0, 0);
}
public void ReadAnnotatedRelations_MultipleColumns()
{
var ds = new DataSet();
ds.ReadXmlSchema(new StringReader(
@"<?xml version=""1.0"" standalone=""yes""?>
<xs:schema id=""NewDataSet"" xmlns="""" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:msdata=""urn:schemas-microsoft-com:xml-msdata"">
<xs:element name=""NewDataSet"" msdata:IsDataSet=""true"">
<xs:complexType>
<xs:choice maxOccurs=""unbounded"">
<xs:element name=""Table1"">
<xs:complexType>
<xs:sequence>
<xs:element name=""col_x0020_1"" type=""xs:int"" minOccurs=""0"" />
<xs:element name=""col2"" type=""xs:int"" minOccurs=""0"" />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name=""Table2"">
<xs:complexType>
<xs:sequence>
<xs:element name=""col1"" type=""xs:int"" minOccurs=""0"" />
<xs:element name=""col_x0020__x0020_2"" type=""xs:int"" minOccurs=""0"" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
<xs:annotation>
<xs:appinfo>
<msdata:Relationship name=""rel"" msdata:parent=""Table1"" msdata:child=""Table2"" msdata:parentkey=""col_x0020_1 col2"" msdata:childkey=""col1 col_x0020__x0020_2"" />
</xs:appinfo>
</xs:annotation>
</xs:schema>"));
Assert.Equal(1, ds.Relations.Count);
Assert.Equal("rel", ds.Relations[0].RelationName);
Assert.Equal(2, ds.Relations[0].ParentColumns.Length);
Assert.Equal(2, ds.Relations[0].ChildColumns.Length);
Assert.Equal(0, ds.Tables[0].Constraints.Count);
Assert.Equal(0, ds.Tables[1].Constraints.Count);
DataSetAssertion.AssertDataRelation("TestRel", ds.Relations[0], "rel", false, new string[] { "col 1", "col2" },
new string[] { "col1", "col 2" }, false, false);
}
private void ReadTest1Check(DataSet ds)
{
DataSetAssertion.AssertDataSet("dataset", ds, "NewDataSet", 2, 1);
DataSetAssertion.AssertDataTable("tbl1", ds.Tables[0], "Table1", 3, 0, 0, 1, 1, 0);
DataSetAssertion.AssertDataTable("tbl2", ds.Tables[1], "Table2", 3, 0, 1, 0, 1, 0);
DataRelation rel = ds.Relations[0];
DataSetAssertion.AssertDataRelation("rel", rel, "Rel1", false,
new string[] { "Column1_3" },
new string[] { "Column2_1" }, true, true);
DataSetAssertion.AssertUniqueConstraint("uc", rel.ParentKeyConstraint,
"Constraint1", false, new string[] { "Column1_3" });
DataSetAssertion.AssertForeignKeyConstraint("fk", rel.ChildKeyConstraint, "Rel1",
AcceptRejectRule.None, Rule.Cascade, Rule.Cascade,
new string[] { "Column2_1" },
new string[] { "Column1_3" });
}
public void SingleElement()
{
DataSet ds = GetDataSet(_xml1, null);
DataSetAssertion.AssertDataSet("xml1", ds, "root", 0, 0);
ds = GetDataSet(_xml4, null);
DataSetAssertion.AssertDataSet("xml4", ds, "root", 0, 0);
// namespaces
ds = GetDataSet(_xml14, null);
DataSetAssertion.AssertDataSet("xml14", ds, "root", 0, 0);
Assert.Equal(string.Empty, ds.Prefix);
Assert.Equal("urn:foo", ds.Namespace);
ds = GetDataSet(_xml17, null);
DataSetAssertion.AssertDataSet("xml17", ds, "root", 0, 0);
Assert.Equal("urn:foo", ds.Namespace);
}
public void TwoElementTable()
{
// FIXME: Also test ReadXml (, XmlReadMode.InferSchema) and
// make sure that ReadXml() stores DataRow to el1 (and maybe to others)
DataSet ds = GetDataSet(_xml15, null);
DataSetAssertion.AssertDataSet("ds", ds, "root", 2, 0);
DataTable dt = ds.Tables[0];
DataSetAssertion.AssertDataTable("dt", dt, "table1", 2, 0, 0, 0, 0, 0);
DataSetAssertion.AssertDataColumn("col1_1", dt.Columns[0], "col1_1", true, false, 0, 1, "col1_1", MappingType.Element, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 0, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("col1_2", dt.Columns[1], "col1_2", true, false, 0, 1, "col1_2", MappingType.Element, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 1, string.Empty, false, false);
dt = ds.Tables[1];
DataSetAssertion.AssertDataTable("dt", dt, "table2", 2, 0, 0, 0, 0, 0);
DataSetAssertion.AssertDataColumn("col2_1", dt.Columns[0], "col2_1", true, false, 0, 1, "col2_1", MappingType.Element, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 0, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("col2_2", dt.Columns[1], "col2_2", true, false, 0, 1, "col2_2", MappingType.Element, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 1, string.Empty, false, false);
}
public void IsDataSetOnLocalElementIgnored()
{
string xsbase = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata'>
<xs:element name='Root' type='unusedType'>
</xs:element>
<xs:complexType name='unusedType'>
<xs:sequence>
<xs:element name='Child' type='xs:string' msdata:IsDataSet='True' />
</xs:sequence>
</xs:complexType>
</xs:schema>";
// msdata:IsDataSet does not affect even if the value is invalid
string xs = string.Format(xsbase, "true");
var ds = new DataSet();
ds.ReadXmlSchema(new StringReader(xs));
// Child should not be regarded as DataSet element
DataSetAssertion.AssertDataSet("ds", ds, "NewDataSet", 1, 0);
}
public void TestSimpleSchemaPlusContentAll()
{
DataSet ds;
// ignored
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "IgnoreSchema", schema2,
XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,
"NewDataSet", 0, ReadState.Interactive);
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "InferSchema", schema2,
XmlReadMode.InferSchema, XmlReadMode.InferSchema,
"NewDataSet", 0, ReadState.Interactive);
// Fragment ... consumed both
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "Fragment", schema2,
XmlReadMode.Fragment, XmlReadMode.Fragment,
"NewDataSet", 1);
DataSetAssertion.AssertDataTable("fragment", ds.Tables[0], "Root", 1, 0, 0, 0, 0, 0);
// rest ... treated as schema
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "Auto", schema2,
XmlReadMode.Auto, XmlReadMode.ReadSchema,
"NewDataSet", 1, ReadState.Interactive);
DataSetAssertion.AssertDataTable("auto", ds.Tables[0], "Root", 1, 0, 0, 0, 0, 0);
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "DiffGram", schema2,
XmlReadMode.DiffGram, XmlReadMode.DiffGram,
"NewDataSet", 1, ReadState.Interactive);
DataSetAssertion.AssertDataTable("diffgram", ds.Tables[0], "Root", 1, 0, 0, 0, 0, 0);
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "ReadSchema", schema2,
XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,
"NewDataSet", 1, ReadState.Interactive);
}
public void TestSampleFileSimpleTables()
{
var ds = new DataSet();
ds.Tables.Add(new DataTable("foo"));
ds.Tables[0].ReadXmlSchema(new StringReader(
@"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>
<xs:element name='foo' type='ct' />
<xs:complexType name='ct'>
<xs:simpleContent>
<xs:extension base='xs:integer'>
<xs:attribute name='attr' />
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:schema>"));
DataSetAssertion.AssertDataSet("005", ds, "NewDataSet", 1, 0);
DataTable dt = ds.Tables[0];
DataSetAssertion.AssertDataTable("tab", dt, "foo", 2, 0, 0, 0, 0, 0);
DataSetAssertion.AssertDataColumn("attr", dt.Columns[0], "attr", true, false, 0, 1, "attr", MappingType.Attribute, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 0, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("text", dt.Columns[1], "foo_text", false, false, 0, 1, "foo_text", MappingType.SimpleContent, typeof(long), DBNull.Value, string.Empty, -1, string.Empty, 1, string.Empty, false, false);
ds = new DataSet();
ds.Tables.Add(new DataTable("foo"));
ds.Tables[0].ReadXmlSchema(new StringReader(
@"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>
<xs:element name='foo' type='st' />
<xs:complexType name='st'>
<xs:attribute name='att1' />
<xs:attribute name='att2' type='xs:int' default='2' />
</xs:complexType>
</xs:schema>"));
DataSetAssertion.AssertDataSet("006", ds, "NewDataSet", 1, 0);
dt = ds.Tables[0];
DataSetAssertion.AssertDataTable("tab", dt, "foo", 2, 0, 0, 0, 0, 0);
DataSetAssertion.AssertDataColumn("att1", dt.Columns["att1"], "att1", true, false, 0, 1, "att1", MappingType.Attribute, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, /*0*/ -1, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("att2", dt.Columns["att2"], "att2", true, false, 0, 1, "att2", MappingType.Attribute, typeof(int), 2, string.Empty, -1, string.Empty, /*1*/ -1, string.Empty, false, false);
}
public void TestSimpleSchemaXmlAll()
{
DataSet ds;
// ignored
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "IgnoreSchema", schema1,
XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,
"NewDataSet", 0);
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "InferSchema", schema1,
XmlReadMode.InferSchema, XmlReadMode.InferSchema,
"NewDataSet", 0);
// misc ... consume schema
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "Fragment", schema1,
XmlReadMode.Fragment, XmlReadMode.Fragment,
"NewDataSet", 1);
DataSetAssertion.AssertDataTable("fragment", ds.Tables[0], "Root", 1, 0, 0, 0, 0, 0);
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "ReadSchema", schema1,
XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,
"NewDataSet", 1);
DataSetAssertion.AssertDataTable("readschema", ds.Tables[0], "Root", 1, 0, 0, 0, 0, 0);
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "Auto", schema1,
XmlReadMode.Auto, XmlReadMode.ReadSchema,
"NewDataSet", 1);
DataSetAssertion.AssertDataTable("auto", ds.Tables[0], "Root", 1, 0, 0, 0, 0, 0);
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "DiffGram", schema1,
XmlReadMode.DiffGram, XmlReadMode.DiffGram,
"NewDataSet", 1);
}
public void ConflictColumnTable()
{
DataSet ds = GetDataSet(_xml19, null);
DataSetAssertion.AssertDataSet("ds", ds, "set", 2, 1);
DataTable dt = ds.Tables[0];
DataSetAssertion.AssertDataTable("dt", dt, "table", 1, 0, 0, 1, 1, 1);
DataSetAssertion.AssertDataColumn("table_Id", dt.Columns[0], "table_Id", false, true, 0, 1, "table_Id", MappingType.Hidden, typeof(int), DBNull.Value, string.Empty, -1, string.Empty, 0, string.Empty, false, true);
dt = ds.Tables[1];
DataSetAssertion.AssertDataTable("dt", dt, "col", 2, 0, 1, 0, 1, 0);
DataSetAssertion.AssertDataColumn("table_refId", dt.Columns["table_Id"], "table_Id", true, false, 0, 1, "table_Id", MappingType.Hidden, typeof(int), DBNull.Value, string.Empty, -1, string.Empty, /*0*/ -1, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("another_col", dt.Columns["another_col"], "another_col", true, false, 0, 1, "another_col", MappingType.Element, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, /*1*/ -1, string.Empty, false, false);
DataRelation dr = ds.Relations[0];
DataSetAssertion.AssertDataRelation("rel", dr, "table_col", true, new string[] { "table_Id" }, new string[] { "table_Id" }, true, true);
DataSetAssertion.AssertUniqueConstraint("uniq", dr.ParentKeyConstraint, "Constraint1", true, new string[] { "table_Id" });
DataSetAssertion.AssertForeignKeyConstraint("fkey", dr.ChildKeyConstraint, "table_col", AcceptRejectRule.None, Rule.Cascade, Rule.Cascade, new string[] { "table_Id" }, new string[] { "table_Id" });
}
public void TestMoreThanOneRepeatableColumns()
{
var ds = new DataSet();
ds.ReadXmlSchema(new StringReader(
@"<xsd:schema xmlns:xsd=""http://www.w3.org/2001/XMLSchema"">
<xsd:element name=""root"">
<xsd:complexType>
<xsd:sequence>
<xsd:element name=""x"" maxOccurs=""2"" />
<xsd:element ref=""y"" maxOccurs=""unbounded"" />
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name=""y"" />
</xsd:schema>"));
DataSetAssertion.AssertDataSet("014", ds, "NewDataSet", 3, 2);
DataTable dt = ds.Tables[0];
DataSetAssertion.AssertDataTable("parent", dt, "root", 1, 0, 0, 2, 1, 1);
DataSetAssertion.AssertDataColumn("key", dt.Columns[0], "root_Id", false, true, 0, 1, "root_Id", MappingType.Hidden, typeof(int), DBNull.Value, string.Empty, -1, string.Empty, 0, string.Empty, false, true);
dt = ds.Tables[1];
DataSetAssertion.AssertDataTable("repeated", dt, "x", 2, 0, 1, 0, 1, 0);
DataSetAssertion.AssertDataColumn("data_1", dt.Columns[0], "x_Column", false, false, 0, 1, "x_Column", MappingType.SimpleContent, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 0, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("refkey_1", dt.Columns[1], "root_Id", true, false, 0, 1, "root_Id", MappingType.Hidden, typeof(int), DBNull.Value, string.Empty, -1, string.Empty, 1, string.Empty, false, false);
dt = ds.Tables[2];
DataSetAssertion.AssertDataTable("repeated", dt, "y", 2, 0, 1, 0, 1, 0);
DataSetAssertion.AssertDataColumn("data", dt.Columns[0], "y_Column", false, false, 0, 1, "y_Column", MappingType.SimpleContent, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 0, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("refkey", dt.Columns[1], "root_Id", true, false, 0, 1, "root_Id", MappingType.Hidden, typeof(int), DBNull.Value, string.Empty, -1, string.Empty, 1, string.Empty, false, false);
DataSetAssertion.AssertDataRelation("rel", ds.Relations[0], "root_x", true, new string[] { "root_Id" }, new string[] { "root_Id" }, true, true);
DataSetAssertion.AssertDataRelation("rel", ds.Relations[1], "root_y", true, new string[] { "root_Id" }, new string[] { "root_Id" }, true, true);
}
public void ComplexElementAttributeTable1()
{
// FIXME: Also test ReadXml (, XmlReadMode.InferSchema) and
// make sure that ReadXml() stores DataRow to el1 (and maybe to others)
DataSet ds = GetDataSet(_xml9, null);
DataSetAssertion.AssertDataSet("ds", ds, "NewDataSet", 4, 3);
DataTable dt = ds.Tables[0];
DataSetAssertion.AssertDataTable("dt1", dt, "el1", 3, 0, 0, 1, 1, 1);
DataSetAssertion.AssertDataColumn("el1_Id", dt.Columns[0], "el1_Id", false, true, 0, 1, "el1_Id", MappingType.Hidden, typeof(int), DBNull.Value, string.Empty, -1, string.Empty, 0, string.Empty, false, true);
DataSetAssertion.AssertDataColumn("el1_attr1", dt.Columns[1], "attr1", true, false, 0, 1, "attr1", MappingType.Attribute, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 1, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("el1_attrA", dt.Columns[2], "attrA", true, false, 0, 1, "attrA", MappingType.Attribute, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 2, string.Empty, false, false);
dt = ds.Tables[1];
DataSetAssertion.AssertDataTable("dt2", dt, "el2", 6, 0, 1, 2, 2, 1);
DataSetAssertion.AssertDataColumn("el2_Id", dt.Columns[0], "el2_Id", false, true, 0, 1, "el2_Id", MappingType.Hidden, typeof(int), DBNull.Value, string.Empty, -1, string.Empty, 0, string.Empty, false, true);
DataSetAssertion.AssertDataColumn("el2_col2", dt.Columns[1], "column2", true, false, 0, 1, "column2", MappingType.Element, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 1, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("el2_col3", dt.Columns[2], "column3", true, false, 0, 1, "column3", MappingType.Element, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 2, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("el2_attr2", dt.Columns[3], "attr2", true, false, 0, 1, "attr2", MappingType.Attribute, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 3, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("el2_attrB", dt.Columns[4], "attrB", true, false, 0, 1, "attrB", MappingType.Attribute, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 4, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("el2_el1Id", dt.Columns[5], "el1_Id", true, false, 0, 1, "el1_Id", MappingType.Hidden, typeof(int), DBNull.Value, string.Empty, -1, string.Empty, 5, string.Empty, false, false);
dt = ds.Tables[2];
DataSetAssertion.AssertDataTable("dt3", dt, "el3", 4, 0, 1, 0, 1, 0);
DataSetAssertion.AssertDataColumn("el3_attr3", dt.Columns[0], "attr3", true, false, 0, 1, "attr3", MappingType.Attribute, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 0, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("el3_attrC", dt.Columns[1], "attrC", true, false, 0, 1, "attrC", MappingType.Attribute, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 1, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("el3_Text", dt.Columns[2], "el3_Text", true, false, 0, 1, "el3_Text", MappingType.SimpleContent, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 2, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("el3_el2Id", dt.Columns[3], "el2_Id", true, false, 0, 1, "el2_Id", MappingType.Hidden, typeof(int), DBNull.Value, string.Empty, -1, string.Empty, 3, string.Empty, false, false);
dt = ds.Tables[3];
DataSetAssertion.AssertDataTable("dt4", dt, "el4", 4, 0, 1, 0, 1, 0);
DataSetAssertion.AssertDataColumn("el3_attr4", dt.Columns[0], "attr4", true, false, 0, 1, "attr4", MappingType.Attribute, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 0, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("el4_attrD", dt.Columns[1], "attrD", true, false, 0, 1, "attrD", MappingType.Attribute, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 1, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("el4_Text", dt.Columns[2], "el4_Text", true, false, 0, 1, "el4_Text", MappingType.SimpleContent, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 2, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("el4_el2Id", dt.Columns[3], "el2_Id", true, false, 0, 1, "el2_Id", MappingType.Hidden, typeof(int), DBNull.Value, string.Empty, -1, string.Empty, 3, string.Empty, false, false);
}
public void TestSimpleDiffPlusContentAll()
{
DataSet ds;
// Fragment ... skipped
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "Fragment", diff2,
XmlReadMode.Fragment, XmlReadMode.Fragment,
"NewDataSet", 0);
// others ... kept
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "IgnoreSchema", diff2,
XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,
"NewDataSet", 0, ReadState.Interactive);
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "InferSchema", diff2,
XmlReadMode.InferSchema, XmlReadMode.InferSchema,
"NewDataSet", 0, ReadState.Interactive);
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "ReadSchema", diff2,
XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,
"NewDataSet", 0, ReadState.Interactive);
// Auto, DiffGram ... treated as DiffGram
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "Auto", diff2,
XmlReadMode.Auto, XmlReadMode.DiffGram,
"NewDataSet", 0, ReadState.Interactive);
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "DiffGram", diff2,
XmlReadMode.DiffGram, XmlReadMode.DiffGram,
"NewDataSet", 0, ReadState.Interactive);
}
public void UnusedComplexTypesIgnored()
{
string xs = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' id='hoge'>
<xs:element name='Root'>
<xs:complexType>
<xs:sequence>
<xs:element name='Child' type='xs:string' />
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:complexType name='unusedType'>
<xs:sequence>
<xs:element name='Orphan' type='xs:string' />
</xs:sequence>
</xs:complexType>
</xs:schema>";
var ds = new DataSet();
ds.ReadXmlSchema(new StringReader(xs));
// Here "unusedType" table is never imported.
DataSetAssertion.AssertDataSet("ds", ds, "hoge", 1, 0);
DataSetAssertion.AssertDataTable("dt", ds.Tables[0], "Root", 1, 0, 0, 0, 0, 0);
}
public void TestSimpleDiffXmlAll()
{
DataSet ds;
// ignored
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "Fragment", diff1,
XmlReadMode.Fragment, XmlReadMode.Fragment,
"NewDataSet", 0);
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "IgnoreSchema", diff1,
XmlReadMode.IgnoreSchema, XmlReadMode.IgnoreSchema,
"NewDataSet", 0);
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "InferSchema", diff1,
XmlReadMode.InferSchema, XmlReadMode.InferSchema,
"NewDataSet", 0);
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "ReadSchema", diff1,
XmlReadMode.ReadSchema, XmlReadMode.ReadSchema,
"NewDataSet", 0);
// Auto, DiffGram ... treated as DiffGram
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "Auto", diff1,
XmlReadMode.Auto, XmlReadMode.DiffGram,
"NewDataSet", 0);
ds = new DataSet();
DataSetAssertion.AssertReadXml(ds, "DiffGram", diff1,
XmlReadMode.DiffGram, XmlReadMode.DiffGram,
"NewDataSet", 0);
}
public void LocaleOnRootWithoutIsDataSet()
{
string xs = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' xmlns:msdata='urn:schemas-microsoft-com:xml-msdata'>
<xs:element name='Root' msdata:Locale='ja-JP'>
<xs:complexType>
<xs:sequence>
<xs:element name='Child' type='xs:string' />
</xs:sequence>
<xs:attribute name='Attr' type='xs:integer' />
</xs:complexType>
</xs:element>
</xs:schema>";
var ds = new DataSet();
ds.Tables.Add("Root");
ds.Tables[0].ReadXmlSchema(new StringReader(xs));
DataTable dt = ds.Tables[0];
DataSetAssertion.AssertDataTable("dt", dt, "Root", 2, 0, 0, 0, 0, 0);
Assert.Equal("ja-JP", dt.Locale.Name); // DataTable's Locale comes from msdata:Locale
DataSetAssertion.AssertDataColumn("col1", dt.Columns[0], "Attr", true, false, 0, 1, "Attr", MappingType.Attribute, typeof(long), DBNull.Value, string.Empty, -1, string.Empty, 0, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("col2", dt.Columns[1], "Child", false, false, 0, 1, "Child", MappingType.Element, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 1, string.Empty, false, false);
}
public void IgnoreSchemaShouldFillData()
{
// no such dataset
string xml1 = "<set><tab><col>test</col></tab></set>";
// no wrapper element
string xml2 = "<tab><col>test</col></tab>";
// no such table
string xml3 = "<tar><col>test</col></tar>";
var ds = new DataSet();
DataTable dt = new DataTable("tab");
ds.Tables.Add(dt);
dt.Columns.Add("col");
ds.ReadXml(new StringReader(xml1), XmlReadMode.IgnoreSchema);
DataSetAssertion.AssertDataSet("ds", ds, "NewDataSet", 1, 0);
Assert.Equal(1, dt.Rows.Count);
dt.Clear();
ds.ReadXml(new StringReader(xml2), XmlReadMode.IgnoreSchema);
Assert.Equal(1, dt.Rows.Count);
dt.Clear();
ds.ReadXml(new StringReader(xml3), XmlReadMode.IgnoreSchema);
Assert.Equal(0, dt.Rows.Count);
}
public void SuspiciousDataSetElement()
{
string schema = @"<?xml version='1.0'?>
<xsd:schema xmlns:xsd='http://www.w3.org/2001/XMLSchema'>
<xsd:attribute name='foo' type='xsd:string'/>
<xsd:attribute name='bar' type='xsd:string'/>
<xsd:complexType name='attRef'>
<xsd:attribute name='att1' type='xsd:int'/>
<xsd:attribute name='att2' type='xsd:string'/>
</xsd:complexType>
<xsd:element name='doc'>
<xsd:complexType>
<xsd:choice>
<xsd:element name='elem' type='attRef'/>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>";
var ds = new DataSet();
ds.Tables.Add(new DataTable("elem"));
ds.Tables[0].ReadXmlSchema(new StringReader(schema));
DataSetAssertion.AssertDataTable("table", ds.Tables[0], "elem", 2, 0, 0, 0, 0, 0);
}
public void SingleElementTreatmentDifference()
{
// This is one of the most complicated case. When the content
// type particle of 'Root' element is a complex element, it
// is DataSet element. Otherwise, it is just a data table.
//
// But also note that there is another test named
// LocaleOnRootWithoutIsDataSet(), that tests if locale on
// the (mere) data table modifies *DataSet's* locale.
// Moreover, when the schema contains another element
// (regardless of its schema type), the elements will
// never be treated as a DataSet.
string xsbase = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' id='hoge'>
<xs:element name='Root'> <!-- When simple, it becomes table. When complex, it becomes DataSet -->
<xs:complexType>
<xs:choice>
{0}
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>";
string xsbase2 = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' id='hoge'>
<xs:element name='Root'> <!-- When simple, it becomes table. When complex, it becomes DataSet -->
<xs:complexType>
<xs:choice>
{0}
</xs:choice>
</xs:complexType>
</xs:element>
<xs:element name='more' type='xs:string' />
</xs:schema>";
string simple = "<xs:element name='Child' type='xs:string' />";
string complex = @"<xs:element name='Child'>
<xs:complexType>
<xs:attribute name='a1' />
<xs:attribute name='a2' type='xs:integer' />
</xs:complexType>
</xs:element>";
string elref = "<xs:element ref='more' />";
string xs2 = @"<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' id='hoge'>
<xs:element name='Root' type='RootType' />
<xs:complexType name='RootType'>
<xs:choice>
<xs:element name='Child'>
<xs:complexType>
<xs:attribute name='a1' />
<xs:attribute name='a2' type='xs:integer' />
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:schema>";
var ds = new DataSet();
string xs = string.Format(xsbase, simple);
ds.ReadXmlSchema(new StringReader(xs));
DataSetAssertion.AssertDataSet("simple", ds, "hoge", 1, 0);
DataSetAssertion.AssertDataTable("simple", ds.Tables[0], "Root", 1, 0, 0, 0, 0, 0);
// reference to global complex type
ds = new DataSet();
ds.ReadXmlSchema(new StringReader(xs2));
DataSetAssertion.AssertDataSet("external complexType", ds, "hoge", 2, 1);
DataSetAssertion.AssertDataTable("external Tab1", ds.Tables[0], "Root", 1, 0, 0, 1, 1, 1);
DataSetAssertion.AssertDataTable("external Tab2", ds.Tables[1], "Child", 3, 0, 1, 0, 1, 0);
// xsbase2 + complex -> datatable
ds = new DataSet();
xs = string.Format(xsbase2, complex);
ds.ReadXmlSchema(new StringReader(xs));
DataSetAssertion.AssertDataSet("complex", ds, "hoge", 2, 1);
DataSetAssertion.AssertDataTable("complex", ds.Tables[0], "Root", 1, 0, 0, 1, 1, 1);
DataTable dt = ds.Tables[1];
DataSetAssertion.AssertDataTable("complex", dt, "Child", 3, 0, 1, 0, 1, 0);
DataSetAssertion.AssertDataColumn("a1", dt.Columns["a1"], "a1", true, false, 0, 1, "a1", MappingType.Attribute, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, /*0*/ -1, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("a2", dt.Columns["a2"], "a2", true, false, 0, 1, "a2", MappingType.Attribute, typeof(long), DBNull.Value, string.Empty, -1, string.Empty, /*1*/ -1, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("Root_Id", dt.Columns[2], "Root_Id", true, false, 0, 1, "Root_Id", MappingType.Hidden, typeof(int), DBNull.Value, string.Empty, -1, string.Empty, 2, string.Empty, false, false);
// xsbase + complex -> dataset
ds = new DataSet();
xs = string.Format(xsbase, complex);
ds.ReadXmlSchema(new StringReader(xs));
DataSetAssertion.AssertDataSet("complex", ds, "Root", 1, 0);
ds = new DataSet();
xs = string.Format(xsbase2, elref);
ds.ReadXmlSchema(new StringReader(xs));
DataSetAssertion.AssertDataSet("complex", ds, "hoge", 1, 0);
DataSetAssertion.AssertDataTable("complex", ds.Tables[0], "Root", 1, 0, 0, 0, 0, 0);
}
public static void AssertReadXml(DataSet ds, string label, string xml, XmlReadMode readMode, XmlReadMode resultMode, string datasetName, int tableCount, ReadState state)
{
DataSetAssertion.AssertReadXml(ds, label, xml, readMode, resultMode, datasetName, tableCount, state, null, null);
}
public void TestSampleFileComplexTables()
{
// Nested simple type element
var ds = new DataSet();
ds.ReadXmlSchema(new StringReader(
@"<!-- nested tables, root references to complex type -->
<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' targetNamespace='urn:foo' xmlns:x='urn:foo'>
<xs:element name='uno' type='x:t' />
<xs:complexType name='t'>
<xs:sequence>
<xs:element name='des'>
<xs:complexType>
<xs:sequence>
<xs:element name='tres' />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:schema>"));
DataSetAssertion.AssertDataSet("007", ds, "NewDataSet", 2, 1);
DataTable dt = ds.Tables[0];
DataSetAssertion.AssertDataTable("tab1", dt, "uno", 1, 0, 0, 1, 1, 1);
DataSetAssertion.AssertDataColumn("id", dt.Columns[0], "uno_Id", false, true, 0, 1, "uno_Id", MappingType.Hidden, typeof(int), DBNull.Value, string.Empty, -1, "urn:foo", 0, string.Empty, false, true);
dt = ds.Tables[1];
DataSetAssertion.AssertDataTable("tab2", dt, "des", 2, 0, 1, 0, 1, 0);
DataSetAssertion.AssertDataColumn("child", dt.Columns[0], "tres", false, false, 0, 1, "tres", MappingType.Element, typeof(string), DBNull.Value, string.Empty, -1, string.Empty, 0, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("id", dt.Columns[1], "uno_Id", true, false, 0, 1, "uno_Id", MappingType.Hidden, typeof(int), DBNull.Value, string.Empty, -1, string.Empty, 1, string.Empty, false, false);
// External simple type element
ds = new DataSet();
ds.ReadXmlSchema(new StringReader(
@"<!-- reference to external simple element -->
<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' targetNamespace='urn:foo' xmlns:x='urn:foo'>
<xs:element name='uno' type='x:t' />
<xs:element name='tres' type='xs:string' />
<xs:complexType name='t'>
<xs:sequence>
<xs:element name='des'>
<xs:complexType>
<xs:sequence>
<xs:element ref='x:tres' />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:schema>"));
DataSetAssertion.AssertDataSet("008", ds, "NewDataSet", 2, 1);
dt = ds.Tables[0];
DataSetAssertion.AssertDataTable("tab1", dt, "uno", 1, 0, 0, 1, 1, 1);
DataSetAssertion.AssertDataColumn("id", dt.Columns[0], "uno_Id", false, true, 0, 1, "uno_Id", MappingType.Hidden, typeof(int), DBNull.Value, string.Empty, -1, "urn:foo", 0, string.Empty, false, true);
dt = ds.Tables[1];
DataSetAssertion.AssertDataTable("tab2", dt, "des", 2, 0, 1, 0, 1, 0);
DataSetAssertion.AssertDataColumn("child", dt.Columns[0], "tres", false, false, 0, 1, "tres", MappingType.Element, typeof(string), DBNull.Value, string.Empty, -1, "urn:foo", 0, string.Empty, false, false);
DataSetAssertion.AssertDataColumn("id", dt.Columns[1], "uno_Id", true, false, 0, 1, "uno_Id", MappingType.Hidden, typeof(int), DBNull.Value, string.Empty, -1, string.Empty, 1, string.Empty, false, false);
}