* DataSetAssertion.cs: Don't derive from 'Assertion'. Modernize.
* DataSetInferXmlSchemaTest.cs, DataSetReadXmlSchemaTest.cs,
DataSetReadXmlTest.cs, DataSetTest.cs, DataTableLoadRowTest.cs,
DataTableReaderTest.cs, DataTableTest.cs: Modernize.
In System.Xml:
* XmlDataDocumentTest.cs: Modernize.
svn path=/trunk/mcs/; revision=69038
+2006-12-05 Raja R Harinath <rharinath@novell.com>
+
+ * DataSetAssertion.cs: Don't derive from 'Assertion'. Modernize.
+ * DataSetInferXmlSchemaTest.cs, DataSetReadXmlSchemaTest.cs,
+ DataSetReadXmlTest.cs, DataSetTest.cs, DataTableLoadRowTest.cs,
+ DataTableReaderTest.cs, DataTableTest.cs: Modernize.
+
2006-12-05 Nagappan A <anagappan@novell.com>
* DataSetReadXmlTest.cs (ColumnOrder, XmlSpace): Modified
namespace MonoTests.System.Data
{
- public class DataSetAssertion : Assertion
+ public class DataSetAssertion
{
public string GetNormalizedSchema (string source)
{
public void AssertDataSet (string label, DataSet ds, string name, int tableCount, int relCount)
{
- AssertEquals (label + ".DataSetName", name, ds.DataSetName);
- AssertEquals (label + ".TableCount", tableCount, ds.Tables.Count);
+ Assert.AreEqual (name, ds.DataSetName, label + ".DataSetName");
+ Assert.AreEqual (tableCount, ds.Tables.Count, label + ".TableCount");
if (relCount >= 0)
- AssertEquals (label + ".RelationCount", relCount, ds.Relations.Count);
+ Assert.AreEqual (relCount, ds.Relations.Count, label + ".RelationCount");
}
public void AssertDataTable (string label, DataTable dt, string name, int columnCount, int rowCount, int parentRelationCount, int childRelationCount, int constraintCount, int primaryKeyLength)
{
- AssertEquals (label + ".TableName", name, dt.TableName);
- AssertEquals (label + ".ColumnCount", columnCount, dt.Columns.Count);
- AssertEquals (label + ".RowCount", rowCount, dt.Rows.Count);
- AssertEquals (label + ".ParentRelCount", parentRelationCount, dt.ParentRelations.Count);
- AssertEquals (label + ".ChildRelCount", childRelationCount, dt.ChildRelations.Count);
- AssertEquals (label + ".ConstraintCount", constraintCount, dt.Constraints.Count);
- AssertEquals (label + ".PrimaryKeyLength", primaryKeyLength, dt.PrimaryKey.Length);
+ Assert.AreEqual (name, dt.TableName, label + ".TableName");
+ Assert.AreEqual (columnCount, dt.Columns.Count, label + ".ColumnCount");
+ Assert.AreEqual (rowCount, dt.Rows.Count, label + ".RowCount");
+ Assert.AreEqual (parentRelationCount, dt.ParentRelations.Count, label + ".ParentRelCount");
+ Assert.AreEqual (childRelationCount, dt.ChildRelations.Count, label + ".ChildRelCount");
+ Assert.AreEqual (constraintCount, dt.Constraints.Count, label + ".ConstraintCount");
+ Assert.AreEqual (primaryKeyLength, dt.PrimaryKey.Length, label + ".PrimaryKeyLength");
}
public void AssertReadXml (DataSet ds, string label, string xml, XmlReadMode readMode, XmlReadMode resultMode, string datasetName, int tableCount)
public void AssertReadXml (DataSet ds, string label, string xml, XmlReadMode readMode, XmlReadMode resultMode, string datasetName, int tableCount, ReadState state, string readerLocalName, string readerNS)
{
XmlReader xtr = new XmlTextReader (xml, XmlNodeType.Element, null);
- AssertEquals (label + ".return", resultMode, ds.ReadXml (xtr, readMode));
+ Assert.AreEqual (resultMode, ds.ReadXml (xtr, readMode), label + ".return");
AssertDataSet (label + ".dataset", ds, datasetName, tableCount, -1);
- AssertEquals (label + ".readstate", state, xtr.ReadState);
+ Assert.AreEqual (state, xtr.ReadState, label + ".readstate");
if (readerLocalName != null)
- AssertEquals (label + ".reader-localName",
- readerLocalName, xtr.LocalName);
+ Assert.AreEqual (readerLocalName, xtr.LocalName, label + ".reader-localName");
if (readerNS != null)
- AssertEquals (label + ".reader-ns", readerNS, xtr.NamespaceURI);
+ Assert.AreEqual (readerNS, xtr.NamespaceURI, label + ".reader-ns");
}
public void AssertDataRelation (string label, DataRelation rel, string name, bool nested,
string [] parentColNames, string [] childColNames,
bool existsUK, bool existsFK)
{
- AssertEquals (label + ".Name", name, rel.RelationName);
- AssertEquals (label + ".Nested", nested, rel.Nested);
+ Assert.AreEqual (name, rel.RelationName, label + ".Name");
+ Assert.AreEqual (nested, rel.Nested, label + ".Nested");
for (int i = 0; i < parentColNames.Length; i++)
- AssertEquals (label + ".parentColumn_" + i, parentColNames [i], rel.ParentColumns [i].ColumnName);
- AssertEquals (label + ".ParentColCount", parentColNames.Length, rel.ParentColumns.Length);
+ Assert.AreEqual (parentColNames [i], rel.ParentColumns [i].ColumnName, label + ".parentColumn_" + i);
+ Assert.AreEqual (parentColNames.Length, rel.ParentColumns.Length, label + ".ParentColCount");
for (int i = 0; i < childColNames.Length; i++)
- AssertEquals (label + ".childColumn_" + i, childColNames [i], rel.ChildColumns [i].ColumnName);
- AssertEquals (label + ".ChildColCount", childColNames.Length, rel.ChildColumns.Length);
+ Assert.AreEqual (childColNames [i], rel.ChildColumns [i].ColumnName, label + ".childColumn_" + i);
+ Assert.AreEqual (childColNames.Length, rel.ChildColumns.Length, label + ".ChildColCount");
if (existsUK)
- AssertNotNull (label + ".uniqKeyExists", rel.ParentKeyConstraint);
+ Assert.IsNotNull (rel.ParentKeyConstraint, label + ".uniqKeyExists");
else
- AssertNull (label + ".uniqKeyNotExists", rel.ParentKeyConstraint);
+ Assert.IsNull (rel.ParentKeyConstraint, label + ".uniqKeyNotExists");
if (existsFK)
- AssertNotNull (label + ".fkExists", rel.ChildKeyConstraint);
+ Assert.IsNotNull (rel.ChildKeyConstraint, label + ".fkExists");
else
- AssertNull (label + ".fkNotExists", rel.ChildKeyConstraint);
+ Assert.IsNull (rel.ChildKeyConstraint, label + ".fkNotExists");
}
public void AssertUniqueConstraint (string label, UniqueConstraint uc,
string name, bool isPrimaryKey, string [] colNames)
{
- AssertEquals (label + ".name", name, uc.ConstraintName);
- AssertEquals (label + ".pkey", isPrimaryKey, uc.IsPrimaryKey);
+ Assert.AreEqual (name, uc.ConstraintName, label + ".name");
+ Assert.AreEqual (isPrimaryKey, uc.IsPrimaryKey, label + ".pkey");
for (int i = 0; i < colNames.Length; i++)
- AssertEquals (label + ".column_" + i, colNames [i], uc.Columns [i].ColumnName);
- AssertEquals (label + ".colCount", colNames.Length, uc.Columns.Length);
+ Assert.AreEqual (colNames [i], uc.Columns [i].ColumnName, label + ".column_" + i);
+ Assert.AreEqual (colNames.Length, uc.Columns.Length, label + ".colCount");
}
public void AssertForeignKeyConstraint (string label,
AcceptRejectRule acceptRejectRule, Rule delRule, Rule updateRule,
string [] colNames, string [] relColNames)
{
- AssertEquals (label + ".name", name, fk.ConstraintName);
- AssertEquals (label + ".acceptRejectRule", acceptRejectRule, fk.AcceptRejectRule);
- AssertEquals (label + ".delRule", delRule, fk.DeleteRule);
- AssertEquals (label + ".updateRule", updateRule, fk.UpdateRule);
+ Assert.AreEqual (name, fk.ConstraintName, label + ".name");
+ Assert.AreEqual (acceptRejectRule, fk.AcceptRejectRule, label + ".acceptRejectRule");
+ Assert.AreEqual (delRule, fk.DeleteRule, label + ".delRule");
+ Assert.AreEqual (updateRule, fk.UpdateRule, label + ".updateRule");
for (int i = 0; i < colNames.Length; i++)
- AssertEquals (label + ".column_" + i, colNames [i], fk.Columns [i].ColumnName);
- AssertEquals (label + ".colCount", colNames.Length, fk.Columns.Length);
+ Assert.AreEqual (colNames [i], fk.Columns [i].ColumnName, label + ".column_" + i);
+ Assert.AreEqual (colNames.Length, fk.Columns.Length, label + ".colCount");
for (int i = 0; i < relColNames.Length; i++)
- AssertEquals (label + ".relatedColumn_" + i, relColNames [i], fk.RelatedColumns [i].ColumnName);
- AssertEquals (label + ".relatedColCount", relColNames.Length, fk.RelatedColumns.Length);
+ Assert.AreEqual (relColNames [i], fk.RelatedColumns [i].ColumnName, label + ".relatedColumn_" + i);
+ Assert.AreEqual (relColNames.Length, fk.RelatedColumns.Length, label + ".relatedColCount");
+ }
+
+ public void AssertDataColumn (string label, DataColumn col,
+ string colName, bool allowDBNull,
+ bool autoIncr, int autoIncrSeed, int autoIncrStep,
+ string caption, MappingType colMap,
+ Type type, object defaultValue, string expression,
+ int maxLength, string ns, int ordinal, string prefix,
+ bool readOnly, bool unique)
+ {
+ Assert.AreEqual (colName, col.ColumnName, label + "ColumnName: " );
+ Assert.AreEqual (allowDBNull, col.AllowDBNull, label + "AllowDBNull? " );
+ Assert.AreEqual (autoIncr, col.AutoIncrement, label + "AutoIncrement? " );
+ Assert.AreEqual (autoIncrSeed, col.AutoIncrementSeed, label + " Seed: " );
+ Assert.AreEqual (autoIncrStep, col.AutoIncrementStep, label + " Step: " );
+ Assert.AreEqual (caption, col.Caption, label + "Caption " );
+ Assert.AreEqual (colMap, col.ColumnMapping, label + "Mapping: " );
+ Assert.AreEqual (type, col.DataType, label + "Type: " );
+ Assert.AreEqual (defaultValue, col.DefaultValue, label + "DefaultValue: " );
+ Assert.AreEqual (expression, col.Expression, label + "Expression: " );
+ Assert.AreEqual (maxLength, col.MaxLength, label + "MaxLength: " );
+ Assert.AreEqual (ns, col.Namespace, label + "Namespace: " );
+ if (ordinal >= 0)
+ Assert.AreEqual (ordinal, col.Ordinal, label + "Ordinal: " );
+ Assert.AreEqual (prefix, col.Prefix, label + "Prefix: " );
+ Assert.AreEqual (readOnly, col.ReadOnly, label + "ReadOnly: " );
+ Assert.AreEqual (unique, col.Unique, label + "Unique: " );
}
-\r
- public void AssertDataColumn (string label, DataColumn col, \r
- string colName, bool allowDBNull, \r
- bool autoIncr, int autoIncrSeed, int autoIncrStep, \r
- string caption, MappingType colMap, \r
- Type type, object defaultValue, string expression, \r
- int maxLength, string ns, int ordinal, string prefix, \r
- bool readOnly, bool unique)\r
- {\r
- AssertEquals (label + "ColumnName: " , colName, col.ColumnName);\r
- AssertEquals (label + "AllowDBNull? " , allowDBNull, col.AllowDBNull);\r
- AssertEquals (label + "AutoIncrement? " , autoIncr, col.AutoIncrement);\r
- AssertEquals (label + " Seed: " , autoIncrSeed, col.AutoIncrementSeed);\r
- AssertEquals (label + " Step: " , autoIncrStep, col.AutoIncrementStep);\r
- AssertEquals (label + "Caption " , caption, col.Caption);\r
- AssertEquals (label + "Mapping: " , colMap, col.ColumnMapping);\r
- AssertEquals (label + "Type: " , type, col.DataType);\r
- AssertEquals (label + "DefaultValue: " , defaultValue, col.DefaultValue);\r
- AssertEquals (label + "Expression: " , expression, col.Expression);\r
- AssertEquals (label + "MaxLength: " , maxLength, col.MaxLength);\r
- AssertEquals (label + "Namespace: " , ns, col.Namespace);\r
- if (ordinal >= 0)\r
- AssertEquals (label + "Ordinal: " , ordinal, col.Ordinal);\r
- AssertEquals (label + "Prefix: " , prefix, col.Prefix);\r
- AssertEquals (label + "ReadOnly: " , readOnly, col.ReadOnly);\r
- AssertEquals (label + "Unique: " , unique, col.Unique);\r
- }\r
}
}
// namespaces
ds = GetDataSet (xml14, null);
AssertDataSet ("xml14", ds, "root", 0, 0);
- AssertEquals ("p", ds.Prefix);
- AssertEquals ("urn:foo", ds.Namespace);
+ Assert.AreEqual ("p", ds.Prefix);
+ Assert.AreEqual ("urn:foo", ds.Namespace);
ds = GetDataSet (xml17, null);
AssertDataSet ("xml17", ds, "root", 0, 0);
- AssertEquals ("urn:foo", ds.Namespace);
+ Assert.AreEqual ("urn:foo", ds.Namespace);
}
[Test]
ds.WriteXml(sw);
XmlDocument doc = new XmlDocument ();
doc.LoadXml (sw.ToString ());
- AssertEquals (2, doc.DocumentElement.ChildNodes.Count);
+ Assert.AreEqual (2, doc.DocumentElement.ChildNodes.Count);
}
}
}
DataSet ds = new DataSet ();
ds.ReadXmlSchema (new StringReader (xs));
AssertDataSet ("ds", ds, "NewDataSet", 1, 0);
- AssertEquals ("fi-FI", ds.Locale.Name); // DataSet's Locale comes from current thread
+ Assert.AreEqual ("fi-FI", ds.Locale.Name); // DataSet's Locale comes from current thread
DataTable dt = ds.Tables [0];
AssertDataTable ("dt", dt, "Root", 2, 0, 0, 0, 0, 0);
- AssertEquals ("ja-JP", dt.Locale.Name); // DataTable's Locale comes from msdata:Locale
+ Assert.AreEqual ("ja-JP", dt.Locale.Name); // DataTable's Locale comes from msdata:Locale
AssertDataColumn ("col1", dt.Columns [0], "Attr", true, false, 0, 1, "Attr", MappingType.Attribute, typeof (Int64), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, false);
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);
}
string xs = String.Format (xsbase, constraints, String.Empty, String.Empty);
DataSet ds = new DataSet ();
ds.ReadXmlSchema (new StringReader (xs));
- AssertEquals (1, ds.Relations.Count);
+ Assert.AreEqual (1, ds.Relations.Count);
// Constraints on another global element - just ignored
xs = String.Format (xsbase, String.Empty, constraints, String.Empty);
ds = new DataSet ();
ds.ReadXmlSchema (new StringReader (xs));
- AssertEquals (0, ds.Relations.Count);
+ Assert.AreEqual (0, ds.Relations.Count);
// Constraints on local element - just ignored
xs = String.Format (xsbase, String.Empty, String.Empty, constraints);
ds = new DataSet ();
ds.ReadXmlSchema (new StringReader (xs));
- AssertEquals (0, ds.Relations.Count);
+ Assert.AreEqual (0, ds.Relations.Count);
}
[Test]
col.AutoIncrementSeed = -1;
col.AutoIncrementStep = -1;
tbl.Columns.Add("data", typeof(string));
- Assert (ds.GetXmlSchema ().IndexOf ("AutoIncrementStep") > 0);
+ Assert.IsTrue (ds.GetXmlSchema ().IndexOf ("AutoIncrementStep") > 0);
}
[Test]
dt.Columns.Add ("col");\r
ds.ReadXml (new StringReader (xml1), XmlReadMode.IgnoreSchema);\r
AssertDataSet ("ds", ds, "NewDataSet", 1, 0);\r
- AssertEquals ("wrapper element", 1, dt.Rows.Count);\r
+ Assert.AreEqual (1, dt.Rows.Count, "wrapper element");\r
dt.Clear ();\r
\r
ds.ReadXml (new StringReader (xml2), XmlReadMode.IgnoreSchema);\r
- AssertEquals ("no wrapper element", 1, dt.Rows.Count);\r
+ Assert.AreEqual (1, dt.Rows.Count, "no wrapper element");\r
dt.Clear ();\r
\r
ds.ReadXml (new StringReader (xml3), XmlReadMode.IgnoreSchema);\r
- AssertEquals ("no such table", 0, dt.Rows.Count);\r
+ Assert.AreEqual (0, dt.Rows.Count, "no such table");\r
}\r
\r
// bug #60118\r
\r
DataSet ds = new DataSet ();\r
ds.ReadXml (new StringReader (xml));\r
- AssertNotNull (ds.Tables ["PriceListDetails"]);\r
+ Assert.IsNotNull (ds.Tables ["PriceListDetails"]);\r
}\r
\r
[Test] // bug #80045\r
\r
DataSet ds = new DataSet ();\r
ds.ReadXml (new StringReader (xml));\r
- NUnit.Framework.Assert.AreEqual (1, ds.Tables.Count, "#1");\r
- NUnit.Framework.Assert.AreEqual ("Table", ds.Tables [0].TableName, "#2");\r
- NUnit.Framework.Assert.AreEqual (4, ds.Tables [0].Columns.Count, "#3");\r
- NUnit.Framework.Assert.AreEqual ("Name", ds.Tables [0].Columns [0].ColumnName, "#4a");\r
- NUnit.Framework.Assert.AreEqual (0, ds.Tables [0].Columns [0].Ordinal, "#4b");\r
- NUnit.Framework.Assert.AreEqual ("FirstName", ds.Tables [0].Columns [1].ColumnName, "#5a");\r
- NUnit.Framework.Assert.AreEqual (1, ds.Tables [0].Columns [1].Ordinal, "#5b");\r
+ Assert.AreEqual (1, ds.Tables.Count, "#1");\r
+ Assert.AreEqual ("Table", ds.Tables [0].TableName, "#2");\r
+ Assert.AreEqual (4, ds.Tables [0].Columns.Count, "#3");\r
+ Assert.AreEqual ("Name", ds.Tables [0].Columns [0].ColumnName, "#4a");\r
+ Assert.AreEqual (0, ds.Tables [0].Columns [0].Ordinal, "#4b");\r
+ Assert.AreEqual ("FirstName", ds.Tables [0].Columns [1].ColumnName, "#5a");\r
+ Assert.AreEqual (1, ds.Tables [0].Columns [1].Ordinal, "#5b");\r
#if NET_2_0\r
- NUnit.Framework.Assert.AreEqual ("Address", ds.Tables [0].Columns [2].ColumnName, "#6a");\r
- NUnit.Framework.Assert.AreEqual (2, ds.Tables [0].Columns [2].Ordinal, "#6b");\r
- NUnit.Framework.Assert.AreEqual ("Income", ds.Tables [0].Columns [3].ColumnName, "#7a");\r
- NUnit.Framework.Assert.AreEqual (3, ds.Tables [0].Columns [3].Ordinal, "#7b");\r
+ Assert.AreEqual ("Address", ds.Tables [0].Columns [2].ColumnName, "#6a");\r
+ Assert.AreEqual (2, ds.Tables [0].Columns [2].Ordinal, "#6b");\r
+ Assert.AreEqual ("Income", ds.Tables [0].Columns [3].ColumnName, "#7a");\r
+ Assert.AreEqual (3, ds.Tables [0].Columns [3].Ordinal, "#7b");\r
#else\r
- NUnit.Framework.Assert.AreEqual ("Income", ds.Tables [0].Columns [2].ColumnName, "#6a");\r
- NUnit.Framework.Assert.AreEqual (2, ds.Tables [0].Columns [2].Ordinal, "#6b");\r
- NUnit.Framework.Assert.AreEqual ("Address", ds.Tables [0].Columns [3].ColumnName, "#7a");\r
- NUnit.Framework.Assert.AreEqual (3, ds.Tables [0].Columns [3].Ordinal, "#7b");\r
+ Assert.AreEqual ("Income", ds.Tables [0].Columns [2].ColumnName, "#6a");\r
+ Assert.AreEqual (2, ds.Tables [0].Columns [2].Ordinal, "#6b");\r
+ Assert.AreEqual ("Address", ds.Tables [0].Columns [3].ColumnName, "#7a");\r
+ Assert.AreEqual (3, ds.Tables [0].Columns [3].Ordinal, "#7b");\r
#endif\r
}\r
\r
DataSet ds = new DataSet ();\r
ds.ReadXml (new StringReader (xml));\r
#if NET_2_0\r
- NUnit.Framework.Assert.AreEqual (1, ds.Tables.Count, "#1");\r
- NUnit.Framework.Assert.AreEqual ("Table", ds.Tables [0].TableName, "#2");\r
- NUnit.Framework.Assert.AreEqual (3, ds.Tables [0].Columns.Count, "#3");\r
- NUnit.Framework.Assert.AreEqual ("Name", ds.Tables [0].Columns [0].ColumnName, "#4a");\r
- NUnit.Framework.Assert.AreEqual (0, ds.Tables [0].Columns [0].Ordinal, "#4b");\r
- NUnit.Framework.Assert.AreEqual ("FirstName", ds.Tables [0].Columns [1].ColumnName, "#5a");\r
- NUnit.Framework.Assert.AreEqual (1, ds.Tables [0].Columns [1].Ordinal, "#5b");\r
- NUnit.Framework.Assert.AreEqual ("Income", ds.Tables [0].Columns [2].ColumnName, "#6a");\r
- NUnit.Framework.Assert.AreEqual (2, ds.Tables [0].Columns [2].Ordinal, "#6b");\r
+ Assert.AreEqual (1, ds.Tables.Count, "#1");\r
+ Assert.AreEqual ("Table", ds.Tables [0].TableName, "#2");\r
+ Assert.AreEqual (3, ds.Tables [0].Columns.Count, "#3");\r
+ Assert.AreEqual ("Name", ds.Tables [0].Columns [0].ColumnName, "#4a");\r
+ Assert.AreEqual (0, ds.Tables [0].Columns [0].Ordinal, "#4b");\r
+ Assert.AreEqual ("FirstName", ds.Tables [0].Columns [1].ColumnName, "#5a");\r
+ Assert.AreEqual (1, ds.Tables [0].Columns [1].Ordinal, "#5b");\r
+ Assert.AreEqual ("Income", ds.Tables [0].Columns [2].ColumnName, "#6a");\r
+ Assert.AreEqual (2, ds.Tables [0].Columns [2].Ordinal, "#6b");\r
#else\r
- NUnit.Framework.Assert.AreEqual (2, ds.Tables.Count, "#1");\r
- NUnit.Framework.Assert.AreEqual ("Table", ds.Tables [0].TableName, "#2");\r
- NUnit.Framework.Assert.AreEqual (3, ds.Tables [0].Columns.Count, "#3");\r
- NUnit.Framework.Assert.AreEqual ("Name", ds.Tables [0].Columns [0].ColumnName, "#4a");\r
- NUnit.Framework.Assert.AreEqual (0, ds.Tables [0].Columns [0].Ordinal, "#4b");\r
- NUnit.Framework.Assert.AreEqual ("Table_Id", ds.Tables [0].Columns [1].ColumnName, "#5a");\r
- NUnit.Framework.Assert.AreEqual (1, ds.Tables [0].Columns [1].Ordinal, "#5b");\r
- NUnit.Framework.Assert.AreEqual ("Income", ds.Tables [0].Columns [2].ColumnName, "#6a");\r
- NUnit.Framework.Assert.AreEqual (2, ds.Tables [0].Columns [2].Ordinal, "#6b");\r
- NUnit.Framework.Assert.AreEqual ("FirstName", ds.Tables [1].TableName, "#7");\r
- NUnit.Framework.Assert.AreEqual (3, ds.Tables [1].Columns.Count, "#8");\r
- NUnit.Framework.Assert.AreEqual ("space", ds.Tables [1].Columns [0].ColumnName, "#9a");\r
- NUnit.Framework.Assert.AreEqual (0, ds.Tables [1].Columns [0].Ordinal, "#9b");\r
- NUnit.Framework.Assert.AreEqual ("FirstName_Text", ds.Tables [1].Columns [1].ColumnName, "#10a");\r
- NUnit.Framework.Assert.AreEqual (1, ds.Tables [1].Columns [1].Ordinal, "#10b");\r
- NUnit.Framework.Assert.AreEqual ("Table_Id", ds.Tables [1].Columns [2].ColumnName, "#11a");\r
- NUnit.Framework.Assert.AreEqual (2, ds.Tables [1].Columns [2].Ordinal, "#11b");\r
+ Assert.AreEqual (2, ds.Tables.Count, "#1");\r
+ Assert.AreEqual ("Table", ds.Tables [0].TableName, "#2");\r
+ Assert.AreEqual (3, ds.Tables [0].Columns.Count, "#3");\r
+ Assert.AreEqual ("Name", ds.Tables [0].Columns [0].ColumnName, "#4a");\r
+ Assert.AreEqual (0, ds.Tables [0].Columns [0].Ordinal, "#4b");\r
+ Assert.AreEqual ("Table_Id", ds.Tables [0].Columns [1].ColumnName, "#5a");\r
+ Assert.AreEqual (1, ds.Tables [0].Columns [1].Ordinal, "#5b");\r
+ Assert.AreEqual ("Income", ds.Tables [0].Columns [2].ColumnName, "#6a");\r
+ Assert.AreEqual (2, ds.Tables [0].Columns [2].Ordinal, "#6b");\r
+ Assert.AreEqual ("FirstName", ds.Tables [1].TableName, "#7");\r
+ Assert.AreEqual (3, ds.Tables [1].Columns.Count, "#8");\r
+ Assert.AreEqual ("space", ds.Tables [1].Columns [0].ColumnName, "#9a");\r
+ Assert.AreEqual (0, ds.Tables [1].Columns [0].Ordinal, "#9b");\r
+ Assert.AreEqual ("FirstName_Text", ds.Tables [1].Columns [1].ColumnName, "#10a");\r
+ Assert.AreEqual (1, ds.Tables [1].Columns [1].Ordinal, "#10b");\r
+ Assert.AreEqual ("Table_Id", ds.Tables [1].Columns [2].ColumnName, "#11a");\r
+ Assert.AreEqual (2, ds.Tables [1].Columns [2].Ordinal, "#11b");\r
#endif\r
}\r
}\r
using System.Threading;
using System.Text;
-using AssertType = NUnit.Framework.Assert;
-
namespace MonoTests.System.Data
{
[TestFixture]
public void Properties ()
{
DataSet ds = new DataSet ();
- AssertEquals ("default namespace", String.Empty, ds.Namespace);
+ Assert.AreEqual (String.Empty, ds.Namespace, "default namespace");
ds.Namespace = null; // setting null == setting ""
- AssertEquals ("after setting null to namespace", String.Empty, ds.Namespace);
+ Assert.AreEqual (String.Empty, ds.Namespace, "after setting null to namespace");
- AssertEquals ("default prefix", String.Empty, ds.Prefix);
+ Assert.AreEqual (String.Empty, ds.Prefix, "default prefix");
ds.Prefix = null; // setting null == setting ""
- AssertEquals ("after setting null to prefix", String.Empty, ds.Prefix);
+ Assert.AreEqual (String.Empty, ds.Prefix, "after setting null to prefix");
}
[Test]
DataSet ds = new DataSet ();
ds.ReadXmlSchema ("Test/System.Data/own_schema.xsd");
- AssertEquals ("test#01", 2, ds.Tables.Count);
+ Assert.AreEqual (2, ds.Tables.Count, "test#01");
DataTable Table = ds.Tables [0];
- AssertEquals ("test#02", "test_table", Table.TableName);
- AssertEquals ("test#03", "", Table.Namespace);
- AssertEquals ("test#04", 2, Table.Columns.Count);
- AssertEquals ("test#05", 0, Table.Rows.Count);
- AssertEquals ("test#06", false, Table.CaseSensitive);
- AssertEquals ("test#07", 1, Table.Constraints.Count);
- AssertEquals ("test#08", "", Table.Prefix);
+ 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];
- AssertEquals ("test#09", "Constraint1", cons.ConstraintName.ToString ());
- AssertEquals ("test#10", "Constraint1", cons.ToString ());
+ Assert.AreEqual ("Constraint1", cons.ConstraintName.ToString (), "test#09");
+ Assert.AreEqual ("Constraint1", cons.ToString (), "test#10");
DataColumn column = Table.Columns [0];
- AssertEquals ("test#11", true, column.AllowDBNull);
- AssertEquals ("test#12", false, column.AutoIncrement);
- AssertEquals ("test#13", 0L, column.AutoIncrementSeed);
- AssertEquals ("test#14", 1L, column.AutoIncrementStep);
- AssertEquals ("test#15", "test", column.Caption);
- AssertEquals ("test#16", "Element", column.ColumnMapping.ToString ());
- AssertEquals ("test#17", "first", column.ColumnName);
- AssertEquals ("test#18", "System.String", column.DataType.ToString ());
- AssertEquals ("test#19", "test_default_value", column.DefaultValue.ToString ());
- AssertEquals ("test#20", false, column.DesignMode);
- AssertEquals ("test#21", "", column.Expression);
- AssertEquals ("test#22", 100, column.MaxLength);
- AssertEquals ("test#23", "", column.Namespace);
- AssertEquals ("test#24", 0, column.Ordinal);
- AssertEquals ("test#25", "", column.Prefix);
- AssertEquals ("test#26", false, column.ReadOnly);
- AssertEquals ("test#27", true, column.Unique);
+ 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];
- AssertEquals ("test#28", true, column2.AllowDBNull);
- AssertEquals ("test#29", false, column2.AutoIncrement);
- AssertEquals ("test#30", 0L, column2.AutoIncrementSeed);
- AssertEquals ("test#31", 1L, column2.AutoIncrementStep);
- AssertEquals ("test#32", "second", column2.Caption);
- AssertEquals ("test#33", "Element", column2.ColumnMapping.ToString ());
- AssertEquals ("test#34", "second", column2.ColumnName);
- AssertEquals ("test#35", "System.Data.SqlTypes.SqlGuid", column2.DataType.ToString ());
- AssertEquals ("test#36", "", column2.DefaultValue.ToString ());
- AssertEquals ("test#37", false, column2.DesignMode);
- AssertEquals ("test#38", "", column2.Expression);
- AssertEquals ("test#39", -1, column2.MaxLength);
- AssertEquals ("test#40", "", column2.Namespace);
- AssertEquals ("test#41", 1, column2.Ordinal);
- AssertEquals ("test#42", "", column2.Prefix);
- AssertEquals ("test#43", false, column2.ReadOnly);
- AssertEquals ("test#44", false, column2.Unique);
+ 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");
+ Assert.AreEqual ("", column2.DefaultValue.ToString (), "test#36");
+ 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];
- AssertEquals ("test#45", "second_test_table", Table2.TableName);
- AssertEquals ("test#46", "", Table2.Namespace);
- AssertEquals ("test#47", 1, Table2.Columns.Count);
- AssertEquals ("test#48", 0, Table2.Rows.Count);
- AssertEquals ("test#49", false, Table2.CaseSensitive);
- AssertEquals ("test#50", 1, Table2.Constraints.Count);
- AssertEquals ("test#51", "", Table2.Prefix);
+ 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];
- AssertEquals ("test#52", true, column3.AllowDBNull);
- AssertEquals ("test#53", false, column3.AutoIncrement);
- AssertEquals ("test#54", 0L, column3.AutoIncrementSeed);
- AssertEquals ("test#55", 1L, column3.AutoIncrementStep);
- AssertEquals ("test#56", "second_first", column3.Caption);
- AssertEquals ("test#57", "Element", column3.ColumnMapping.ToString ());
- AssertEquals ("test#58", "second_first", column3.ColumnName);
- AssertEquals ("test#59", "System.String", column3.DataType.ToString ());
- AssertEquals ("test#60", "default_value", column3.DefaultValue.ToString ());
- AssertEquals ("test#61", false, column3.DesignMode);
- AssertEquals ("test#62", "", column3.Expression);
- AssertEquals ("test#63", 100, column3.MaxLength);
- AssertEquals ("test#64", "", column3.Namespace);
- AssertEquals ("test#65", 0, column3.Ordinal);
- AssertEquals ("test#66", "", column3.Prefix);
- AssertEquals ("test#67", false, column3.ReadOnly);
- AssertEquals ("test#68", true, column3.Unique);
+ 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]
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#01", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
+ 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
-// AssertEquals ("test#02", "<xs:schema id=\"test_dataset\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring);
- AssertEquals ("test#02", "<xs:schema id=\"test_dataset\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring);
+// 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
-// AssertEquals ("test#03", " <xs:element name=\"test_dataset\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\">", substring);
+// Assert.AreEqual (" <xs:element name=\"test_dataset\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\">", substring, "test#03");
#if !NET_2_0
- AssertEquals ("test#03", " <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\" name=\"test_dataset\">", substring);
+ Assert.AreEqual (" <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\" name=\"test_dataset\">", substring, "test#03");
#else
- AssertEquals ("test#03", " <xs:element msdata:IsDataSet=\"true\" msdata:UseCurrentLocale=\"true\" name=\"test_dataset\">", substring);
+ 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);
- AssertEquals ("test#04", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#05", " <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring);
+ 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);
- AssertEquals ("test#06", " <xs:element name=\"test_table\">", substring);
+ 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);
- AssertEquals ("test#07", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#08", " <xs:sequence>", substring);
+ 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
-// AssertEquals ("test#09", " <xs:element name=\"first\" msdata:Caption=\"test\" default=\"test_default_value\" minOccurs=\"0\">", substring);
- AssertEquals ("test#09", " <xs:element default=\"test_default_value\" minOccurs=\"0\" msdata:Caption=\"test\" name=\"first\">", substring);
+// 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);
- AssertEquals ("test#10", " <xs:simpleType>", substring);
+ Assert.AreEqual (" <xs:simpleType>", substring, "test#10");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#11", " <xs:restriction base=\"xs:string\">", substring);
+ 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);
- AssertEquals ("test#12", " <xs:maxLength value=\"100\" />", substring);
+ Assert.AreEqual (" <xs:maxLength value=\"100\" />", substring, "test#12");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#13", " </xs:restriction>", substring);
+ Assert.AreEqual (" </xs:restriction>", substring, "test#13");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#14", " </xs:simpleType>", substring);
+ Assert.AreEqual (" </xs:simpleType>", substring, "test#14");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#15", " </xs:element>", substring);
+ 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
-// AssertEquals ("test#16", " <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);
+// 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
- AssertEquals ("test#16", " <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);
+ 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
- AssertEquals ("test#16", " <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);
+ 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)
- Fail ("test#16: " + substring);
+ Assert.Fail ("test#16: " + substring);
if (substring.IndexOf ("name=\"second\"") < 0)
- Fail ("test#16: " + substring);
+ Assert.Fail ("test#16: " + substring);
if (substring.IndexOf ("msdata:DataType=\"System.Data.SqlTypes.SqlGuid, System.Data, Version=") < 0)
- Fail ("test#16: " + substring);
+ Assert.Fail ("test#16: " + substring);
if (substring.IndexOf ("type=\"xs:string\"") < 0)
- Fail ("test#16: " + substring);
+ Assert.Fail ("test#16: " + substring);
if (substring.IndexOf ("minOccurs=\"0\"") < 0)
- Fail ("test#16: " + substring);
+ Assert.Fail ("test#16: " + substring);
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#17", " </xs:sequence>", substring);
+ Assert.AreEqual (" </xs:sequence>", substring, "test#17");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#18", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#18");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#19", " </xs:element>", substring);
+ Assert.AreEqual (" </xs:element>", substring, "test#19");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#20", " <xs:element name=\"second_test_table\">", substring);
+ 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);
- AssertEquals ("test#21", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#21");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#22", " <xs:sequence>", substring);
+ 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
-// AssertEquals ("test#23", " <xs:element name=\"second_first\" default=\"default_value\" minOccurs=\"0\">", substring);
- AssertEquals ("test#23", " <xs:element default=\"default_value\" minOccurs=\"0\" name=\"second_first\">", substring);
+// 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);
- AssertEquals ("test#24", " <xs:simpleType>", substring);
+ Assert.AreEqual (" <xs:simpleType>", substring, "test#24");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#25", " <xs:restriction base=\"xs:string\">", substring);
+ 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);
- AssertEquals ("test#26", " <xs:maxLength value=\"100\" />", substring);
+ Assert.AreEqual (" <xs:maxLength value=\"100\" />", substring, "test#26");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#27", " </xs:restriction>", substring);
+ Assert.AreEqual (" </xs:restriction>", substring, "test#27");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#28", " </xs:simpleType>", substring);
+ Assert.AreEqual (" </xs:simpleType>", substring, "test#28");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#29", " </xs:element>", substring);
+ Assert.AreEqual (" </xs:element>", substring, "test#29");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#30", " </xs:sequence>", substring);
+ Assert.AreEqual (" </xs:sequence>", substring, "test#30");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#31", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#31");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#32", " </xs:element>", substring);
+ Assert.AreEqual (" </xs:element>", substring, "test#32");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#33", " </xs:choice>", substring);
+ Assert.AreEqual (" </xs:choice>", substring, "test#33");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#34", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#34");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#36", " <xs:unique name=\"Constraint1\">", substring);
+ Assert.AreEqual (" <xs:unique name=\"Constraint1\">", substring, "test#36");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#37", " <xs:selector xpath=\".//test_table\" />", substring);
+ 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);
- AssertEquals ("test#38", " <xs:field xpath=\"first\" />", substring);
+ Assert.AreEqual (" <xs:field xpath=\"first\" />", substring, "test#38");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#39", " </xs:unique>", substring);
+ 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
-// AssertEquals ("test#40", " <xs:unique name=\"second_test_table_Constraint1\" msdata:ConstraintName=\"Constraint1\">", substring);
- AssertEquals ("test#40", " <xs:unique msdata:ConstraintName=\"Constraint1\" name=\"second_test_table_Constraint1\">", substring);
+// 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);
- AssertEquals ("test#41", " <xs:selector xpath=\".//second_test_table\" />", substring);
+ 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);
- AssertEquals ("test#42", " <xs:field xpath=\"second_first\" />", substring);
+ 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);
- AssertEquals ("test#43", " </xs:unique>", substring);
+ Assert.AreEqual (" </xs:unique>", substring, "test#43");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#44", " </xs:element>", substring);
- AssertEquals ("test#45", "</xs:schema>", TextString);
+ Assert.AreEqual (" </xs:element>", substring, "test#44");
+ Assert.AreEqual ("</xs:schema>", TextString, "test#45");
}
[Test]
string TextString = writer.ToString ();
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#01", "<Root>", substring);
+ Assert.AreEqual ("<Root>", substring, "test#01");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#02", " <Region>", substring);
+ Assert.AreEqual (" <Region>", substring, "test#02");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#03", " <RegionID>1</RegionID>", substring);
+ 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);
- AssertEquals ("test#04", " <RegionDescription>Eastern", substring);
+ Assert.AreEqual (" <RegionDescription>Eastern", substring, "test#04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#05", " </RegionDescription>", substring);
+ Assert.AreEqual (" </RegionDescription>", substring, "test#05");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#06", " </Region>", substring);
+ Assert.AreEqual (" </Region>", substring, "test#06");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#07", " <Region>", substring);
+ Assert.AreEqual (" <Region>", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#08", " <RegionID>2</RegionID>", substring);
+ 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);
- AssertEquals ("test#09", " <RegionDescription>Western", substring);
+ Assert.AreEqual (" <RegionDescription>Western", substring, "test#09");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#10", " </RegionDescription>", substring);
+ Assert.AreEqual (" </RegionDescription>", substring, "test#10");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#11", " </Region>", substring);
+ Assert.AreEqual (" </Region>", substring, "test#11");
- AssertEquals ("test#11", "</Root>", TextString);
+ Assert.AreEqual ("</Root>", TextString, "test#11");
}
[Test]
ds.WriteXml (writer);
string TextString = writer.ToString ();
- AssertEquals ("test#01", "<NewDataSet />", TextString);
+ Assert.AreEqual ("<NewDataSet />", TextString, "test#01");
ds.WriteXml (writer, XmlWriteMode.DiffGram);
TextString = writer.ToString ();
- AssertEquals ("test#02", "<NewDataSet /><diffgr:diffgram xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:diffgr=\"urn:schemas-microsoft-com:xml-diffgram-v1\" />", TextString);
+ 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 ();
TextString = writer.ToString ();
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#03", "<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);
+ 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);
- AssertEquals ("test#04", " <Root>", substring);
+ Assert.AreEqual (" <Root>", substring, "test#04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#05", " <Region diffgr:id=\"Region1\" msdata:rowOrder=\"0\" diffgr:hasChanges=\"inserted\">", substring);
+ 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);
- AssertEquals ("test#06", " <RegionID>64</RegionID>", substring);
+ 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);
- AssertEquals ("test#07", " <RegionDescription>Eastern", substring);
+ Assert.AreEqual (" <RegionDescription>Eastern", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#07", " </RegionDescription>", substring);
+ Assert.AreEqual (" </RegionDescription>", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#08", " </Region>", substring);
+ Assert.AreEqual (" </Region>", substring, "test#08");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#09", " <Region diffgr:id=\"Region2\" msdata:rowOrder=\"1\" diffgr:hasChanges=\"inserted\">", substring);
+ 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);
- AssertEquals ("test#10", " <RegionID>2</RegionID>", substring);
+ 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);
- AssertEquals ("test#11", " <RegionDescription>Western", substring);
+ Assert.AreEqual (" <RegionDescription>Western", substring, "test#11");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#12", " </RegionDescription>", substring);
+ Assert.AreEqual (" </RegionDescription>", substring, "test#12");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#13", " </Region>", substring);
+ Assert.AreEqual (" </Region>", substring, "test#13");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#14", " </Root>", substring);
+ Assert.AreEqual (" </Root>", substring, "test#14");
- AssertEquals ("test#15", "</diffgr:diffgram>", TextString);
+ Assert.AreEqual ("</diffgr:diffgram>", TextString, "test#15");
}
[Test]
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#01", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
+ 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
-// AssertEquals ("test#02", "<xs:schema id=\"Root\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring);
- AssertEquals ("test#02", "<xs:schema id=\"Root\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring);
+// 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);
// This is original DataSet.WriteXmlSchema() output
-// AssertEquals ("test#03", " <xs:element name=\"Root\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\">", substring);
+// Assert.AreEqual (" <xs:element name=\"Root\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\">", substring, "test#03");
#if !NET_2_0
- AssertEquals ("test#03", " <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\" name=\"Root\">", substring);
+ Assert.AreEqual (" <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\" name=\"Root\">", substring, "test#03");
#else
- AssertEquals ("test#03", " <xs:element msdata:IsDataSet=\"true\" msdata:UseCurrentLocale=\"true\" name=\"Root\">", substring);
+ Assert.AreEqual (" <xs:element msdata:IsDataSet=\"true\" msdata:UseCurrentLocale=\"true\" name=\"Root\">", substring, "test#03");
#endif
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#04", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#05", " <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring);
+ 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);
- AssertEquals ("test#06", " <xs:element name=\"Region\">", substring);
+ Assert.AreEqual (" <xs:element name=\"Region\">", substring, "test#06");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#07", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#08", " <xs:sequence>", substring);
+ 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
-// AssertEquals ("test#09", " <xs:element name=\"RegionID\" type=\"xs:string\" minOccurs=\"0\" />", substring);
- AssertEquals ("test#09", " <xs:element minOccurs=\"0\" name=\"RegionID\" type=\"xs:string\" />", substring);
+// 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
-// AssertEquals ("test#10", " <xs:element name=\"RegionDescription\" type=\"xs:string\" minOccurs=\"0\" />", substring);
- AssertEquals ("test#10", " <xs:element minOccurs=\"0\" name=\"RegionDescription\" type=\"xs:string\" />", substring);
+// 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);
- AssertEquals ("test#11", " </xs:sequence>", substring);
+ Assert.AreEqual (" </xs:sequence>", substring, "test#11");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#12", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#12");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#13", " </xs:element>", substring);
+ Assert.AreEqual (" </xs:element>", substring, "test#13");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#14", " </xs:choice>", substring);
+ Assert.AreEqual (" </xs:choice>", substring, "test#14");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#15", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#15");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#16", " </xs:element>", substring);
+ Assert.AreEqual (" </xs:element>", substring, "test#16");
- AssertEquals ("test#17", "</xs:schema>", TextString);
+ Assert.AreEqual ("</xs:schema>", TextString, "test#17");
}
[Test]
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#01", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
+ 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
-// AssertEquals ("test#02", "<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring);
- AssertEquals ("test#02", "<xs:schema id=\"NewDataSet\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring);
+// 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);
- AssertEquals ("test#03", " <xs:complexType name=\"bookstoreType\">", substring);
+ Assert.AreEqual (" <xs:complexType name=\"bookstoreType\">", substring, "test#03");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#04", " <xs:sequence>", substring);
+ 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
-// AssertEquals ("test#05", " <xs:element name=\"book\" type=\"bookType\" minOccurs=\"0\" maxOccurs=\"unbounded\" />", substring);
- AssertEquals ("test#05", " <xs:element maxOccurs=\"unbounded\" minOccurs=\"0\" name=\"book\" type=\"bookType\" />", substring);
+// 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);
- AssertEquals ("test#06", " </xs:sequence>", substring);
+ Assert.AreEqual (" </xs:sequence>", substring, "test#06");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#07", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#08", " <xs:complexType name=\"bookType\">", substring);
+ Assert.AreEqual (" <xs:complexType name=\"bookType\">", substring, "test#08");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#09", " <xs:sequence>", substring);
+ 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
-// AssertEquals ("test#10", " <xs:element name=\"title\" type=\"xs:string\" msdata:Ordinal=\"1\" />", substring);
+// Assert.AreEqual (" <xs:element name=\"title\" type=\"xs:string\" msdata:Ordinal=\"1\" />", substring, "test#10");
- AssertEquals ("test#10", " <xs:element msdata:Ordinal=\"1\" name=\"title\" type=\"xs:string\" />", substring);
+ 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
-// AssertEquals ("test#11", " <xs:element name=\"price\" type=\"xs:decimal\" msdata:Ordinal=\"2\" />", substring);
- AssertEquals ("test#11", " <xs:element msdata:Ordinal=\"2\" name=\"price\" type=\"xs:decimal\" />", substring);
+// 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
-// AssertEquals ("test#12", " <xs:element name=\"author\" type=\"authorName\" minOccurs=\"0\" maxOccurs=\"unbounded\" />", substring);
- AssertEquals ("test#12", " <xs:element maxOccurs=\"unbounded\" minOccurs=\"0\" name=\"author\" type=\"authorName\" />", substring);
+// 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);
- AssertEquals ("test#13", " </xs:sequence>", substring);
+ Assert.AreEqual (" </xs:sequence>", substring, "test#13");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#14", " <xs:attribute name=\"genre\" type=\"xs:string\" />", substring);
+ 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);
- AssertEquals ("test#15", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#15");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#16", " <xs:complexType name=\"authorName\">", substring);
+ Assert.AreEqual (" <xs:complexType name=\"authorName\">", substring, "test#16");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#17", " <xs:sequence>", substring);
+ Assert.AreEqual (" <xs:sequence>", substring, "test#17");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#18", " <xs:element name=\"first-name\" type=\"xs:string\" />", substring);
+ 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);
- AssertEquals ("test#19", " <xs:element name=\"last-name\" type=\"xs:string\" />", substring);
+ 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);
- AssertEquals ("test#20", " </xs:sequence>", substring);
+ Assert.AreEqual (" </xs:sequence>", substring, "test#20");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#21", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#21");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#22", " <xs:element name=\"bookstore\" type=\"bookstoreType\" />", substring);
+ 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
-// AssertEquals ("test#23", " <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\">", substring);
- AssertEquals ("test#23", " <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\" name=\"NewDataSet\">", substring);
+// 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);
- AssertEquals ("test#24", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#24");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#25", " <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring);
+ 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);
- AssertEquals ("test#26", " <xs:element ref=\"bookstore\" />", substring);
+ Assert.AreEqual (" <xs:element ref=\"bookstore\" />", substring, "test#26");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#27", " </xs:choice>", substring);
+ Assert.AreEqual (" </xs:choice>", substring, "test#27");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#28", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#28");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#29", " </xs:element>", substring);
+ Assert.AreEqual (" </xs:element>", substring, "test#29");
- AssertEquals ("test#30", "</xs:schema>", TextString);
+ Assert.AreEqual ("</xs:schema>", TextString, "test#30");
}
[Test]
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#01", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
+ 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
-// AssertEquals ("test#02", "<xs:schema id=\"Root\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring);
- AssertEquals ("test#02", "<xs:schema id=\"Root\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring);
+// 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);
- AssertEquals ("test#03", " <xs:complexType name=\"bookstoreType\">", substring);
+ Assert.AreEqual (" <xs:complexType name=\"bookstoreType\">", substring, "test#03");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#04", " <xs:sequence>", substring);
+ 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
-// AssertEquals ("test#05", " <xs:element name=\"book\" type=\"bookType\" minOccurs=\"0\" maxOccurs=\"unbounded\" />", substring);
- AssertEquals ("test#05", " <xs:element maxOccurs=\"unbounded\" minOccurs=\"0\" name=\"book\" type=\"bookType\" />", substring);
+// 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);
- AssertEquals ("test#06", " </xs:sequence>", substring);
+ Assert.AreEqual (" </xs:sequence>", substring, "test#06");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#07", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#08", " <xs:complexType name=\"bookType\">", substring);
+ Assert.AreEqual (" <xs:complexType name=\"bookType\">", substring, "test#08");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#09", " <xs:sequence>", substring);
+ 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
-// AssertEquals ("test#10", " <xs:element name=\"title\" type=\"xs:string\" msdata:Ordinal=\"1\" />", substring);
- AssertEquals ("test#10", " <xs:element msdata:Ordinal=\"1\" name=\"title\" type=\"xs:string\" />", substring);
+// 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
-// AssertEquals ("test#11", " <xs:element name=\"price\" type=\"xs:decimal\" msdata:Ordinal=\"2\" />", substring);
- AssertEquals ("test#11", " <xs:element msdata:Ordinal=\"2\" name=\"price\" type=\"xs:decimal\" />", substring);
+// 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
-// AssertEquals ("test#12", " <xs:element name=\"author\" type=\"authorName\" minOccurs=\"0\" maxOccurs=\"unbounded\" />", substring);
- AssertEquals ("test#12", " <xs:element maxOccurs=\"unbounded\" minOccurs=\"0\" name=\"author\" type=\"authorName\" />", substring);
+// 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);
- AssertEquals ("test#13", " </xs:sequence>", substring);
+ Assert.AreEqual (" </xs:sequence>", substring, "test#13");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#14", " <xs:attribute name=\"genre\" type=\"xs:string\" />", substring);
+ 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);
- AssertEquals ("test#15", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#15");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#16", " <xs:complexType name=\"authorName\">", substring);
+ Assert.AreEqual (" <xs:complexType name=\"authorName\">", substring, "test#16");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#17", " <xs:sequence>", substring);
+ Assert.AreEqual (" <xs:sequence>", substring, "test#17");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#18", " <xs:element name=\"first-name\" type=\"xs:string\" />", substring);
+ 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);
- AssertEquals ("test#19", " <xs:element name=\"last-name\" type=\"xs:string\" />", substring);
+ 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);
- AssertEquals ("test#20", " </xs:sequence>", substring);
+ Assert.AreEqual (" </xs:sequence>", substring, "test#20");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#21", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#21");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#22", " <xs:element name=\"bookstore\" type=\"bookstoreType\" />", substring);
+ 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
-// AssertEquals ("test#23", " <xs:element name=\"Root\" msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\">", substring);
- AssertEquals ("test#23", " <xs:element msdata:IsDataSet=\"true\" msdata:Locale=\"fi-FI\" name=\"Root\">", substring);
+// 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);
- AssertEquals ("test#24", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#24");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#25", " <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring);
+ 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);
- AssertEquals ("test#26", " <xs:element ref=\"bookstore\" />", substring);
+ Assert.AreEqual (" <xs:element ref=\"bookstore\" />", substring, "test#26");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#27", " <xs:element name=\"Region\">", substring);
+ Assert.AreEqual (" <xs:element name=\"Region\">", substring, "test#27");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#28", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#28");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#29", " <xs:sequence>", substring);
+ 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
-// AssertEquals ("test#30", " <xs:element name=\"RegionID\" type=\"xs:string\" minOccurs=\"0\" />", substring);
- AssertEquals ("test#30", " <xs:element minOccurs=\"0\" name=\"RegionID\" type=\"xs:string\" />", substring);
+// 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
-// AssertEquals ("test#31", " <xs:element name=\"RegionDescription\" type=\"xs:string\" minOccurs=\"0\" />", substring);
- AssertEquals ("test#31", " <xs:element minOccurs=\"0\" name=\"RegionDescription\" type=\"xs:string\" />", substring);
+// 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);
- AssertEquals ("test#32", " </xs:sequence>", substring);
+ Assert.AreEqual (" </xs:sequence>", substring, "test#32");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#33", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#33");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#34", " </xs:element>", substring);
+ Assert.AreEqual (" </xs:element>", substring, "test#34");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#35", " </xs:choice>", substring);
+ Assert.AreEqual (" </xs:choice>", substring, "test#35");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#36", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#36");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#37", " </xs:element>", substring);
+ Assert.AreEqual (" </xs:element>", substring, "test#37");
- AssertEquals ("test#38", "</xs:schema>", TextString);
+ Assert.AreEqual ("</xs:schema>", TextString, "test#38");
}
[Test]
ds.WriteXmlSchema (xw);
string result = sw.ToString ();
- AssertEquals (schema, result.Replace ("\r\n", "\n"));
+ Assert.AreEqual (result.Replace ("\r\n", "\n"), schema);
}
[Test]
StringWriter sw = new StringWriter ();
ds.WriteXml (new XmlTextWriter (sw));
string xml = @"<DS xmlns=""urn:foo""><tab><TEST>test</TEST></tab></DS>";
- AssertEquals (xml, sw.ToString ());
+ Assert.AreEqual (xml, sw.ToString ());
}
[Test]
ser.Serialize (xw, ds);
string result = sw.ToString ();
- AssertEquals (xml, result.Replace ("\r\n", "\n"));
+ Assert.AreEqual (result.Replace ("\r\n", "\n"), xml);
}
// bug #70961
string result = sw.ToString ();
- AssertEquals (xml, result);
+ Assert.AreEqual (xml, result);
}
[Test]
ds.WriteXml (sw, XmlWriteMode.DiffGram);
string xml = sw.ToString ();
string result = new StreamReader ("Test/System.Data/DataSetReadXmlTest1.xml", Encoding.ASCII).ReadToEnd ();
- AssertEquals ("#01", result, xml);
+ Assert.AreEqual (result, xml, "#01");
// load diffgram above
ds.ReadXml (new StringReader (sw.ToString ()));
ds.WriteXml (sw, XmlWriteMode.WriteSchema);
xml = sw.ToString ();
result = new StreamReader ("Test/System.Data/DataSetReadXmlTest2.xml", Encoding.ASCII).ReadToEnd ();
- AssertEquals ("#02", result, xml);
+ Assert.AreEqual (result, xml, "#02");
}
*/
//Testing Copy ()
DataSet copySet = set.Copy ();
- AssertEquals ("#A01", set.CaseSensitive, copySet.CaseSensitive);
- AssertEquals ("#A02", set.DataSetName, copySet.DataSetName);
- AssertEquals ("#A03", set.EnforceConstraints, copySet.EnforceConstraints);
- AssertEquals ("#A04", set.HasErrors, copySet.HasErrors);
- AssertEquals ("#A05", set.Namespace, copySet.Namespace);
- AssertEquals ("#A06", set.Prefix, copySet.Prefix);
- AssertEquals ("#A07", set.Relations.Count, copySet.Relations.Count);
- AssertEquals ("#A08", set.Tables.Count, copySet.Tables.Count);
- AssertEquals ("#A09", set.ExtendedProperties ["TimeStamp"], copySet.ExtendedProperties ["TimeStamp"]);
+ 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++) {
- AssertEquals ("#A10", set.Tables [i].Rows.Count, copySet.Tables [i].Rows.Count);
- AssertEquals ("#A11", set.Tables [i].Columns.Count, copySet.Tables [i].Columns.Count);
+ 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 ();
- AssertEquals ("#A12", set.CaseSensitive, copySet.CaseSensitive);
- AssertEquals ("#A13", set.DataSetName, copySet.DataSetName);
- AssertEquals ("#A14", set.EnforceConstraints, copySet.EnforceConstraints);
- AssertEquals ("#A15", false, copySet.HasErrors);
- AssertEquals ("#A16", set.Namespace, copySet.Namespace);
- AssertEquals ("#A17", set.Prefix, copySet.Prefix);
- AssertEquals ("#A18", set.Relations.Count, copySet.Relations.Count);
- AssertEquals ("#A19", set.Tables.Count, copySet.Tables.Count);
- AssertEquals ("#A20", set.ExtendedProperties ["TimeStamp"], copySet.ExtendedProperties ["TimeStamp"]);
+ 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++) {
- AssertEquals ("#A21", 0, copySet.Tables [i].Rows.Count);
- AssertEquals ("#A22", set.Tables [i].Columns.Count, copySet.Tables [i].Columns.Count);
+ Assert.AreEqual (0, copySet.Tables [i].Rows.Count, "#A21");
+ Assert.AreEqual (set.Tables [i].Columns.Count, copySet.Tables [i].Columns.Count, "#A22");
}
}
ds.Tables["Files"].Constraints.Add(fk);
ds.EnforceConstraints = true;
- AssertEquals ("#1", 1, ds.Tables["Directories"].Constraints.Count);
- AssertEquals ("#2", 1, ds.Tables["Files"].Constraints.Count);
+ 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 ();
- AssertEquals ("#3", 1, cloned_ds.Tables["Directories"].Constraints.Count);
- AssertEquals ("#4", 1, cloned_ds.Tables["Files"].Constraints.Count);
+ 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];
- AssertEquals ("#5", "FK_Test", clonedFk.ConstraintName);
- AssertEquals ("#6", 1, clonedFk.Columns.Length);
- AssertEquals ("#7", "DirectoryID", clonedFk.Columns[0].ColumnName);
+ 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];
- AssertEquals ("#8", origUc.ConstraintName, clonedUc.ConstraintName);
- AssertEquals ("#9", 1, clonedUc.Columns.Length);
- AssertEquals ("#10", "UID", clonedUc.Columns[0].ColumnName);
+ 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 ();
- AssertEquals ("#11", 1, copy_ds.Tables["Directories"].Constraints.Count);
- AssertEquals ("#12", 1, copy_ds.Tables["Files"].Constraints.Count);
+ 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];
- AssertEquals ("#13", "FK_Test", copyFk.ConstraintName);
- AssertEquals ("#14", 1, copyFk.Columns.Length);
- AssertEquals ("#15", "DirectoryID", copyFk.Columns[0].ColumnName);
+ 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];
- AssertEquals ("#16", origUc.ConstraintName, copyUc.ConstraintName);
- AssertEquals ("#17", 1, copyUc.Columns.Length);
- AssertEquals ("#18", "UID", copyUc.Columns[0].ColumnName);
+ Assert.AreEqual (origUc.ConstraintName, copyUc.ConstraintName, "#16");
+ Assert.AreEqual (1, copyUc.Columns.Length, "#17");
+ Assert.AreEqual ("UID", copyUc.Columns[0].ColumnName, "#18");
}
[Test]
ds.Relations.Add (rel);
StringWriter sw = new StringWriter ();
ds.WriteXml (sw);
- AssertEquals (xml, sw.ToString ().Replace ("\r\n", "\n"));
+ Assert.AreEqual (sw.ToString ().Replace ("\r\n", "\n"), xml);
}
[Test]
<col3>sample text 2</col3>
</table2>
</set>";
- AssertEquals (result, sr.ReadToEnd ().Replace ("\r\n", "\n"));
+ Assert.AreEqual (sr.ReadToEnd ().Replace ("\r\n", "\n"), result);
}
[Test]
ds.Tables [0].Rows.Add (new object [] {"content string."});
StringWriter sw = new StringWriter ();
ds.WriteXml (sw);
- AssertEquals (xml, sw.ToString ().Replace ("\r\n", "\n"));
+ Assert.AreEqual (sw.ToString ().Replace ("\r\n", "\n"), xml);
}
[Test]
XmlTextWriter xtw = new XmlTextWriter (sw);
xtw.QuoteChar = '\'';
ds.WriteXml (xtw);
- AssertEquals (xml, sw.ToString ());
+ Assert.AreEqual (xml, sw.ToString ());
}
// bug #53959.
xtw.QuoteChar = '\'';
ds.WriteXml (xtw);
xtw.Flush ();
- AssertEquals (input, sw.ToString ().Replace ("\r\n", "\n"));
+ Assert.AreEqual (input, sw.ToString ().Replace ("\r\n", "\n"));
}
[Test] // bug #60469
OriginalDataSet.WriteXml (xtw);
string result = sw.ToString ();
- AssertEquals (xml, result);
+ Assert.AreEqual (xml, result);
sw = new StringWriter ();
xtw = new XmlTextWriter (sw);
result = sw.ToString ();
result = result.Replace ("\r\n", "\n").Replace ('"', '\'');
- AssertEquals (schema, result);
+ Assert.AreEqual (schema, result);
}
// bug #66366
string result = sw.ToString ();
- AssertEquals (xmlschema, result.Replace ("\r\n", "\n"));
+ Assert.AreEqual (result.Replace ("\r\n", "\n"), xmlschema);
}
// bug #67792.
string result = sw.ToString ();
- AssertEquals (xmlschema, result.Replace ("\r\n", "\n"));
+ Assert.AreEqual (result.Replace ("\r\n", "\n"), xmlschema);
}
// bug # 68432
string result = sw.ToString ();
- AssertEquals (xmlschema, result.Replace ("\r\n", "\n"));
+ Assert.AreEqual (result.Replace ("\r\n", "\n"), xmlschema);
}
// bug #67793
string result = sw.ToString ();
- AssertEquals (xmlschema, result.Replace ("\r\n", "\n"));
+ Assert.AreEqual (result.Replace ("\r\n", "\n"), xmlschema);
}
// bug #68008
dt.Rows.Add (new object [] {"foo", "bar"});
StringWriter sw = new StringWriter ();
ds.WriteXmlSchema (sw);
- Assert (sw.ToString ().IndexOf ("xmlns=\"\"") > 0);
+ Assert.IsTrue (sw.ToString ().IndexOf ("xmlns=\"\"") > 0);
}
// bug #61233
string result = sw.ToString ();
- AssertEquals (xml, result.Replace ("\r\n", "\n"));
+ Assert.AreEqual (result.Replace ("\r\n", "\n"), xml);
}
[Test]
string result = sw.ToString ();
- AssertEquals (xml, result.Replace ("\r\n", "\n"));
+ Assert.AreEqual (result.Replace ("\r\n", "\n"), xml);
}
[Test]
XmlTextReader reader = new XmlTextReader (sr);
XmlSerializer serializer1 = new XmlSerializer (typeof (DataSet));
DataSet ds = serializer1.Deserialize (reader) as DataSet;
- AssertEquals ("deserialization after modification does not give original values",
+ Assert.AreEqual (
prevDs.Tables[0].Rows [0][0,DataRowVersion.Original].ToString (),
- ds.Tables[0].Rows [0][0,DataRowVersion.Original].ToString ());
- AssertEquals ("deserialization after modification oes not give current values",
+ 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 ());
+ ds.Tables[0].Rows [0][0,DataRowVersion.Current].ToString (),
+ "deserialization after modification oes not give current values");
}
/// <summary>
} catch (Exception e) {
throw (new Exception ("Exception should not have been thrown at Clear method" + e.ToString ()));
}
- Assertion.AssertEquals ("parent table rows should not exist!", 0, parent.Rows.Count);
- Assertion.AssertEquals ("child table rows should not exist!", 0, child.Rows.Count);
+ 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]
{
MyDataSet ds1 = new MyDataSet();
MyDataSet ds = (MyDataSet)(ds1.Clone());
- AssertEquals("A#01",2,MyDataSet.count);
+ Assert.AreEqual (2, MyDataSet.count, "A#01");
}
#region DataSet.GetChanges Tests
child.Rows [1]["parent"] = 4;
DataSet changes = ds.GetChanges ();
DataRow row = changes.Tables ["parent"].Rows[0];
- AssertType.AreEqual ((int) parent.Rows [3][0], (int) row [0], "#RT1");
- AssertType.AreEqual (1, changes.Tables ["parent"].Rows.Count, "#RT2 only get parent row with current version");
+ 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 ();
- AssertType.AreEqual (changes.Tables.Count, 2, "#RT3 Should import parent table as well");
- AssertType.AreEqual (1, changes.Tables ["parent"].Rows.Count, "#RT4 only get parent row with original version");
- AssertType.AreEqual (1, (int) changes.Tables ["parent"].Rows [0][0], "#RT5 parent row based on original version");
+ 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
parent.Rows [0] ["name"] = "mono changed test 1";
- Assertion.AssertEquals ("#RT1 child should not be modified",
- DataRowState.Unchanged,
- parent.Rows [0].GetChildRows (relation) [0].RowState);
+ 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];
- Assertion.AssertEquals ("#RT2 child should be modified",
- DataRowState.Modified,
- childRow.RowState);
- Assertion.AssertEquals ("#RT3 child should point to modified row",
- 4,
- (int) childRow ["parent"]);
+ 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
StringWriter writer = new StringWriter ();
data.WriteXml (writer, XmlWriteMode.WriteSchema);
string xml = writer.ToString ();
- Assert ("#1", xml.IndexOf ("name=\"col.2_x003C_hi_x002F__x003E_\"") > 0);
- Assert ("#2", xml.IndexOf ("name=\"_x0023_col3\"") > 0);
- Assert ("#3", xml.IndexOf ("<col.2_x003C_hi_x002F__x003E_>hi there</col.2_x003C_hi_x002F__x003E_>") > 0);
+ 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();
// For First CreateDataReader Overload
localSetup ();
DataTableReader dtr = ds.CreateDataReader ();
- Assert ("HasRows", dtr.HasRows);
+ Assert.IsTrue (dtr.HasRows, "HasRows");
int ti = 0;
do {
- AssertEquals ("CountCols-" + ti,
- ds.Tables[ti].Columns.Count,
- dtr.FieldCount);
+ 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++) {
- AssertEquals ("RowData-"+ti+"-"+ri+"-"+i,
- ds.Tables[ti].Rows[ri][i],
- dtr[i]);
- }
+ for (int i = 0; i < dtr.FieldCount; i++)
+ Assert.AreEqual (ds.Tables[ti].Rows[ri][i], dtr[i], "RowData-"+ti+"-"+ri+"-"+i);
ri++;
}
ti++;
// compare to ds.Tables
localSetup ();
DataTableReader dtr = ds.CreateDataReader (dt1, dt2);
- Assert ("HasRows", dtr.HasRows);
+ Assert.IsTrue (dtr.HasRows, "HasRows");
int ti = 0;
do {
- AssertEquals ("CountCols-" + ti,
- ds.Tables[ti].Columns.Count,
- dtr.FieldCount);
+ 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++) {
- AssertEquals ("RowData-" + ti + "-" + ri + "-" + i,
- ds.Tables[ti].Rows[ri][i],
- dtr[i]);
- }
+ for (int i = 0; i < dtr.FieldCount; i++)
+ Assert.AreEqual (ds.Tables[ti].Rows[ri][i], dtr[i], "RowData-" + ti + "-" + ri + "-" + i);
ri++;
}
ti++;
localSetup ();
ds.Tables.Clear ();
DataTableReader dtr = ds.CreateDataReader (dt1, dt2);
- Assert ("HasRows", dtr.HasRows);
+ Assert.IsTrue (dtr.HasRows, "HasRows");
+ string name = "dt1";
DataTable dtn = dt1;
do {
- AssertEquals ("CountCols-",
- dtn.Columns.Count,
- dtr.FieldCount);
+ Assert.AreEqual (dtn.Columns.Count, dtr.FieldCount, "CountCols-" + name);
int ri = 0;
while (dtr.Read ()) {
- for (int i = 0; i < dtr.FieldCount; i++) {
- AssertEquals ("RowData-" + ri + "-" + i,
- dtn.Rows[ri][i],
- dtr[i]);
- }
+ for (int i = 0; i < dtr.FieldCount; i++)
+ Assert.AreEqual (dtn.Rows[ri][i], dtr[i], "RowData-" + name + "-" + ri + "-" + i);
ri++;
}
- dtn = dt2;
+ if (dtn == dt1) {
+ dtn = dt2;
+ name = "dt2";
+ } else {
+ dtn = null;
+ name = null;
+ }
} while (dtr.NextResult ());
}
private int fillErrCounter;
private void fillErrorHandler (object sender, FillErrorEventArgs e) {
e.Continue = fillErr[fillErrCounter].contFlag;
- AssertEquals ("fillErr-T", fillErr[fillErrCounter].tableName, e.DataTable.TableName);
- AssertEquals ("fillErr-C", fillErr[fillErrCounter].contFlag, e.Continue);
+ Assert.AreEqual (fillErr[fillErrCounter].tableName, e.DataTable.TableName, "fillErr-T");
+ Assert.AreEqual (fillErr[fillErrCounter].contFlag, e.Continue, "fillErr-C");
fillErrCounter++;
}
dsLoad.Tables.Add (table2);
DataTableReader dtr = ds.CreateDataReader ();
dsLoad.Load (dtr, LoadOption.PreserveChanges, "Second", "First");
- AssertEquals ("Tables", 2, dsLoad.Tables.Count);
- AssertEquals ("T1-Rows", 3, dsLoad.Tables[0].Rows.Count);
- AssertEquals ("T1-Columns", 3, dsLoad.Tables[0].Columns.Count);
- AssertEquals ("T2-Rows", 3, dsLoad.Tables[1].Rows.Count);
- AssertEquals ("T2-Columns", 2, dsLoad.Tables[1].Columns.Count);
+ 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]
dsLoad.Tables.Add (table2);
DataTableReader dtr = ds.CreateDataReader ();
dsLoad.Load (dtr, LoadOption.Upsert, "Third", "Fourth");
- AssertEquals ("Tables", 4, dsLoad.Tables.Count);
- AssertEquals ("T1-Name", "First", dsLoad.Tables[0].TableName);
- AssertEquals ("T1-Rows", 0, dsLoad.Tables[0].Rows.Count);
- AssertEquals ("T1-Columns", 0, dsLoad.Tables[0].Columns.Count);
- AssertEquals ("T2-Name", "Second", dsLoad.Tables[1].TableName);
- AssertEquals ("T2-Rows", 0, dsLoad.Tables[1].Rows.Count);
- AssertEquals ("T2-Columns", 0, dsLoad.Tables[1].Columns.Count);
- AssertEquals ("T3-Name", "Third", dsLoad.Tables[2].TableName);
- AssertEquals ("T3-Rows", 3, dsLoad.Tables[2].Rows.Count);
- AssertEquals ("T3-Columns", 2, dsLoad.Tables[2].Columns.Count);
- AssertEquals ("T4-Name", "Fourth", dsLoad.Tables[3].TableName);
- AssertEquals ("T4-Rows", 3, dsLoad.Tables[3].Rows.Count);
- AssertEquals ("T4-Columns", 3, dsLoad.Tables[3].Columns.Count);
+ 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]
dsLoad.Tables.Add (table2);
DataTableReader dtr = ds.CreateDataReader ();
dsLoad.Load (dtr, LoadOption.OverwriteChanges, "Third", "First");
- AssertEquals ("Tables", 3, dsLoad.Tables.Count);
- AssertEquals ("T1-Name", "First", dsLoad.Tables[0].TableName);
- AssertEquals ("T1-Rows", 4, dsLoad.Tables[0].Rows.Count);
- AssertEquals ("T1-Columns", 4, dsLoad.Tables[0].Columns.Count);
- AssertEquals ("T2-Name", "Second", dsLoad.Tables[1].TableName);
- AssertEquals ("T2-Rows", 2, dsLoad.Tables[1].Rows.Count);
- AssertEquals ("T2-Columns", 1, dsLoad.Tables[1].Columns.Count);
- AssertEquals ("T3-Name", "Third", dsLoad.Tables[2].TableName);
- AssertEquals ("T3-Rows", 3, dsLoad.Tables[2].Rows.Count);
- AssertEquals ("T3-Columns", 2, dsLoad.Tables[2].Columns.Count);
+ 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");
}
private void CompareTables (DataSet dsLoad) {
- AssertEquals ("NumTables",
- ds.Tables.Count, dsLoad.Tables.Count);
+ Assert.AreEqual (ds.Tables.Count, dsLoad.Tables.Count, "NumTables");
for (int tc = 0; tc < dsLoad.Tables.Count; tc++) {
- AssertEquals ("Table" + tc + "-NumCols",
- ds.Tables[tc].Columns.Count,
- dsLoad.Tables[tc].Columns.Count);
- AssertEquals ("Table" + tc + "-NumRows",
- ds.Tables[tc].Rows.Count,
- dsLoad.Tables[tc].Rows.Count);
+ 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++) {
- AssertEquals ("Table" + tc + "-" + "Col" + cc + "-Name",
- ds.Tables[tc].Columns[cc].ColumnName,
- dsLoad.Tables[tc].Columns[cc].ColumnName);
+ 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++) {
- AssertEquals ("Table" + tc + "-Row" + rc + "-Col" + cc + "-Data",
- ds.Tables[tc].Rows[rc].ItemArray[cc],
- dsLoad.Tables[tc].Rows[rc].ItemArray[cc]);
+ Assert.AreEqual (ds.Tables[tc].Rows[rc].ItemArray[cc],
+ dsLoad.Tables[tc].Rows[rc].ItemArray[cc],
+ "Table" + tc + "-Row" + rc + "-Col" + cc + "-Data");
}
}
}
Assert.AreEqual ("mono test", dt.Rows [1] [1], "#2 should change the current");
Assert.AreEqual ("mono 2", dt.Rows [1] [1, DataRowVersion.Original], "#3 should not change original");
Assert.AreEqual (DataRowState.Modified, dt.Rows [1].RowState, "#4 should change state");
- Assert.AreEqual (true, rowChanging, "#ev1 row changing not called");
+ Assert.IsTrue (rowChanging, "#ev1 row changing not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changing, "#ev2 this row is not intended to change");
Assert.AreEqual (DataRowAction.Change, rowAction_Changing, "#ev3 row action is not Change");
- Assert.AreEqual (true, rowChanged, "#ev4 row changed not called");
+ Assert.IsTrue (rowChanged, "#ev4 row changed not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changed, "#ev5 this row is not intended to change");
Assert.AreEqual (DataRowAction.Change, rowAction_Changed, "#ev6 row action is not Change");
Assert.AreEqual ("mono test 2", dt.Rows [1] [1], "#c1 should change the current");
Assert.AreEqual ("mono 2", dt.Rows [1] [1, DataRowVersion.Original], "#c2 should not change original");
Assert.AreEqual (DataRowState.Modified, dt.Rows [1].RowState, "#c3 should not change state");
- Assert.AreEqual (true, rowChanging, "#ev11 row changing not called");
+ Assert.IsTrue (rowChanging, "#ev11 row changing not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changing, "#ev12 this row is not intended to change");
Assert.AreEqual (DataRowAction.Change, rowAction_Changing, "#ev13 row action is not Change");
- Assert.AreEqual (true, rowChanged, "#ev14 row changed not called");
+ Assert.IsTrue (rowChanged, "#ev14 row changed not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changed, "#ev15 this row is not intended to change");
Assert.AreEqual (DataRowAction.Change, rowAction_Changed, "#ev16 row action is not Change");
Assert.AreEqual ("mono test 2", dt.Rows [1] [1], "#c4 should not change the current");
Assert.AreEqual ("mono test 2", dt.Rows [1] [1, DataRowVersion.Original], "#c5 should not change original");
Assert.AreEqual (DataRowState.Unchanged, dt.Rows [1].RowState, "#c6 should not change state");
- Assert.AreEqual (true, rowChanging, "#ev21 row changing not called");
+ Assert.IsTrue (rowChanging, "#ev21 row changing not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changing, "#ev22 this row is not intended to change");
Assert.AreEqual (DataRowAction.Nothing, rowAction_Changing, "#ev13 row action is not Nothing");
- Assert.AreEqual (true, rowChanged, "#ev24 row changed not called");
+ Assert.IsTrue (rowChanged, "#ev24 row changed not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changed, "#ev25 this row is not intended to change");
Assert.AreEqual (DataRowAction.Nothing, rowAction_Changed, "#ev26 row action is not Nothing");
ResetEventFlags ();
dt.LoadDataRow (new object [] { 2, "mono test 3" }, LoadOption.Upsert);
Assert.AreEqual (DataRowState.Modified, dt.Rows [1].RowState, "#c7 should not change state");
- Assert.AreEqual (true, rowChanging, "#ev31 row changing not called");
+ Assert.IsTrue (rowChanging, "#ev31 row changing not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changing, "#ev32 this row is not intended to change");
Assert.AreEqual (DataRowAction.Change, rowAction_Changing, "#ev33 row action is not Change");
- Assert.AreEqual (true, rowChanged, "#ev34 row changed not called");
+ Assert.IsTrue (rowChanged, "#ev34 row changed not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changed, "#ev35 this row is not intended to change");
Assert.AreEqual (DataRowAction.Change, rowAction_Changed, "#ev36 row action is not Change");
Assert.Fail ("#c9 should have thrown version not found exception");
} catch (VersionNotFoundException) { }
Assert.AreEqual (DataRowState.Added, dt.Rows [3].RowState, "#c10 should not change state");
- Assert.AreEqual (true, rowChanging, "#ev41 row changing not called");
+ Assert.IsTrue (rowChanging, "#ev41 row changing not called");
Assert.AreEqual (dt.Rows [3], rowInAction_Changing, "#ev42 this row is not intended to change");
Assert.AreEqual (DataRowAction.Change, rowAction_Changing, "#ev43 row action is not Change");
- Assert.AreEqual (true, rowChanged, "#ev44 row changed not called");
+ Assert.IsTrue (rowChanged, "#ev44 row changed not called");
Assert.AreEqual (dt.Rows [3], rowInAction_Changed, "#ev45 this row is not intended to change");
Assert.AreEqual (DataRowAction.Change, rowAction_Changed, "#ev46 row action is not Change");
Assert.Fail ("#c12 should have thrown version not found exception");
} catch (VersionNotFoundException) { }
Assert.AreEqual (DataRowState.Added, dt.Rows [4].RowState, "#c13 should change state");
- Assert.AreEqual (true, rowChanging, "#ev51 row changing not called");
+ Assert.IsTrue (rowChanging, "#ev51 row changing not called");
Assert.AreEqual (dt.Rows [4], rowInAction_Changing, "#ev52 this row is not intended to change");
Assert.AreEqual (DataRowAction.Add, rowAction_Changing, "#ev53 row action is not Change");
- Assert.AreEqual (true, rowChanged, "#ev54 row changed not called");
+ Assert.IsTrue (rowChanged, "#ev54 row changed not called");
Assert.AreEqual (dt.Rows [4], rowInAction_Changed, "#ev55 this row is not intended to change");
Assert.AreEqual (DataRowAction.Add, rowAction_Changed, "#ev56 row action is not Change");
Assert.Fail ("#c16 expected version not found exception ");
} catch (VersionNotFoundException) { }
Assert.AreEqual (DataRowState.Added, dt.Rows [5].RowState, "#c17 should change state");
- Assert.AreEqual (true, rowChanging, "#ev61 row changing not called");
+ Assert.IsTrue (rowChanging, "#ev61 row changing not called");
Assert.AreEqual (dt.Rows [5], rowInAction_Changing, "#ev62 this row is not intended to change");
Assert.AreEqual (DataRowAction.Add, rowAction_Changing, "#ev63 row action is not Change");
- Assert.AreEqual (true, rowChanged, "#ev64 row changed not called");
+ Assert.IsTrue (rowChanged, "#ev64 row changed not called");
Assert.AreEqual (dt.Rows [5], rowInAction_Changed, "#ev65 this row is not intended to change");
Assert.AreEqual (DataRowAction.Add, rowAction_Changed, "#ev66 row action is not Change");
Assert.AreEqual ("mono test", dt.Rows [1] [1], "#3 should change the current");
Assert.AreEqual ("mono test", dt.Rows [1] [1, DataRowVersion.Original], "#4 should change the original");
Assert.AreEqual (DataRowState.Unchanged, dt.Rows [1].RowState, "#5 has not changed the row state");
- Assert.AreEqual (true, rowChanging, "#ltoc11 row changing not called");
+ Assert.IsTrue (rowChanging, "#ltoc11 row changing not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changing, "#ltoc12 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeCurrentAndOriginal, rowAction_Changing, "#ltoc13 row action is not Change");
- Assert.AreEqual (true, rowChanged, "#ltoc14 row changed not called");
+ Assert.IsTrue (rowChanged, "#ltoc14 row changed not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changed, "#ltoc15 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeCurrentAndOriginal, rowAction_Changed, "#ltoc16 row action is not Change");
Assert.AreEqual ("mono test 2", dt.Rows [1] [1], "#c1 should change the current");
Assert.AreEqual ("mono test 2", dt.Rows [1] [1, DataRowVersion.Original], "#c2 should change original");
Assert.AreEqual (DataRowState.Unchanged, dt.Rows [1].RowState, "#c3 should not change state");
- Assert.AreEqual (true, rowChanging, "#ltoc21 row changing not called");
+ Assert.IsTrue (rowChanging, "#ltoc21 row changing not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changing, "#ltoc22 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeCurrentAndOriginal, rowAction_Changing, "#ltoc23 row action is not Change");
- Assert.AreEqual (true, rowChanged, "#ltoc24 row changed not called");
+ Assert.IsTrue (rowChanged, "#ltoc24 row changed not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changed, "#ltoc25 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeCurrentAndOriginal, rowAction_Changed, "#ltoc26 row action is not Change");
Assert.AreEqual ("mono test 2", dt.Rows [1] [1], "#c4 should change the current");
Assert.AreEqual ("mono test 2", dt.Rows [1] [1, DataRowVersion.Original], "#c5 should change original");
Assert.AreEqual (DataRowState.Unchanged, dt.Rows [1].RowState, "#c6 should not change state");
- Assert.AreEqual (true, rowChanging, "#ltoc31 row changing not called");
+ Assert.IsTrue (rowChanging, "#ltoc31 row changing not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changing, "#ltoc32 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeCurrentAndOriginal, rowAction_Changing, "#ltoc33 row action is not Change");
- Assert.AreEqual (true, rowChanged, "#ltoc34 row changed not called");
+ Assert.IsTrue (rowChanged, "#ltoc34 row changed not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changed, "#ltoc35 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeCurrentAndOriginal, rowAction_Changed, "#ltoc36 row action is not Change");
Assert.AreEqual ("mono 4", dt.Rows [3] [1], "#c8 should change the current");
Assert.AreEqual ("mono 4", dt.Rows [3] [1, DataRowVersion.Original], "#c9 should change the original");
Assert.AreEqual (DataRowState.Unchanged, dt.Rows [3].RowState, "#c10 should not change state");
- Assert.AreEqual (true, rowChanging, "#ltoc41 row changing not called");
+ Assert.IsTrue (rowChanging, "#ltoc41 row changing not called");
Assert.AreEqual (dt.Rows [3], rowInAction_Changing, "#ltoc42 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeCurrentAndOriginal, rowAction_Changing, "#ltoc43 row action is not Change");
- Assert.AreEqual (true, rowChanged, "#ltoc44 row changed not called");
+ Assert.IsTrue (rowChanged, "#ltoc44 row changed not called");
Assert.AreEqual (dt.Rows [3], rowInAction_Changed, "#ltoc45 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeCurrentAndOriginal, rowAction_Changed, "#ltoc46 row action is not Change");
Assert.AreEqual ("mono 5", dt.Rows [4] [1], "#c11 should change the current");
Assert.AreEqual ("mono 5", dt.Rows [4] [1, DataRowVersion.Original], "#c12 should change original");
Assert.AreEqual (DataRowState.Unchanged, dt.Rows [4].RowState, "#c13 should change state");
- Assert.AreEqual (true, rowChanging, "#ltoc51 row changing not called");
+ Assert.IsTrue (rowChanging, "#ltoc51 row changing not called");
Assert.AreEqual (dt.Rows [4], rowInAction_Changing, "#ltoc52 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeCurrentAndOriginal, rowAction_Changing, "#ltoc53 row action is not Change");
- Assert.AreEqual (true, rowChanged, "#ltoc54 row changed not called");
+ Assert.IsTrue (rowChanged, "#ltoc54 row changed not called");
Assert.AreEqual (dt.Rows [4], rowInAction_Changed, "#ltoc55 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeCurrentAndOriginal, rowAction_Changed, "#ltoc56 row action is not Change");
Assert.AreEqual ("mono 51", dt.Rows [4] [1], "#c15 should change the current");
Assert.AreEqual ("mono 51", dt.Rows [4] [1, DataRowVersion.Original], "#c16 should change the current");
Assert.AreEqual (DataRowState.Unchanged, dt.Rows [4].RowState, "#c17 should change state");
- Assert.AreEqual (true, rowChanging, "#ltoc61 row changing not called");
+ Assert.IsTrue (rowChanging, "#ltoc61 row changing not called");
Assert.AreEqual (dt.Rows [4], rowInAction_Changing, "#ltoc62 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeCurrentAndOriginal, rowAction_Changing, "#ltoc63 row action is not Change");
- Assert.AreEqual (true, rowChanged, "#ltoc64 row changed not called");
+ Assert.IsTrue (rowChanged, "#ltoc64 row changed not called");
Assert.AreEqual (dt.Rows [4], rowInAction_Changed, "#ltoc65 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeCurrentAndOriginal, rowAction_Changed, "#ltoc66 row action is not Change");
Assert.AreEqual ("mono test", dt.Rows [1] [1], "#2 should change the current");
Assert.AreEqual ("mono test", dt.Rows [1] [1, DataRowVersion.Original], "#3 should change the original");
Assert.AreEqual (DataRowState.Unchanged, dt.Rows [1].RowState, "#4 has not changed the row state");
- Assert.AreEqual (true, rowChanging, "#ltpc11 row changing not called");
+ Assert.IsTrue (rowChanging, "#ltpc11 row changing not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changing, "#ltpc12 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeCurrentAndOriginal, rowAction_Changing, "#ltpc13 row action is not Change");
- Assert.AreEqual (true, rowChanged, "#ltpc14 row changed not called");
+ Assert.IsTrue (rowChanged, "#ltpc14 row changed not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changed, "#ltpc15 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeCurrentAndOriginal, rowAction_Changed, "#ltpc16 row action is not Change");
Assert.AreEqual ("mono 4", dt.Rows [3] [1], "#6 should change the current");
Assert.AreEqual ("mono 4", dt.Rows [3] [1, DataRowVersion.Original], "#7 should change the original");
Assert.AreEqual (DataRowState.Unchanged, dt.Rows [3].RowState, "#8 has not changed the row state");
- Assert.AreEqual (true, rowChanging, "#ltpc21 row changing not called");
+ Assert.IsTrue (rowChanging, "#ltpc21 row changing not called");
Assert.AreEqual (dt.Rows [3], rowInAction_Changing, "#ltpc22 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeCurrentAndOriginal, rowAction_Changing, "#ltpc23 row action is not Change");
- Assert.AreEqual (true, rowChanged, "#ltpc24 row changed not called");
+ Assert.IsTrue (rowChanged, "#ltpc24 row changed not called");
Assert.AreEqual (dt.Rows [3], rowInAction_Changed, "#ltpc25 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeCurrentAndOriginal, rowAction_Changed, "#ltpc16 row action is not Change");
Assert.AreEqual ("mono 5", dt.Rows [4] [1], "#10 should not change the current");
Assert.AreEqual ("mono test", dt.Rows [4] [1, DataRowVersion.Original], "#11 should change the original");
Assert.AreEqual (DataRowState.Modified, dt.Rows [4].RowState, "#12 has not changed the row state");
- Assert.AreEqual (true, rowChanging, "#ltpc31 row changing not called");
+ Assert.IsTrue (rowChanging, "#ltpc31 row changing not called");
Assert.AreEqual (dt.Rows [4], rowInAction_Changing, "#ltpc32 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeOriginal, rowAction_Changing, "#ltpc33 row action is not Change");
- Assert.AreEqual (true, rowChanged, "#ltpc34 row changed not called");
+ Assert.IsTrue (rowChanged, "#ltpc34 row changed not called");
Assert.AreEqual (dt.Rows [4], rowInAction_Changed, "#ltpc35 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeOriginal, rowAction_Changed, "#ltpc36 row action is not Change");
Assert.AreEqual (5, dt.Rows.Count, "#13 should not add a new row");
Assert.AreEqual ("mono deleted", dt.Rows [1] [1, DataRowVersion.Original], "#14 should change the original");
Assert.AreEqual (DataRowState.Deleted, dt.Rows [1].RowState, "#15 has not changed the row state");
- Assert.AreEqual (true, rowChanging, "#ltpc41 row changing not called");
+ Assert.IsTrue (rowChanging, "#ltpc41 row changing not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changing, "#ltpc42 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeOriginal, rowAction_Changing, "#ltoc43 row action is not Change");
- Assert.AreEqual (true, rowChanged, "#ltpc44 row changed not called");
+ Assert.IsTrue (rowChanged, "#ltpc44 row changed not called");
Assert.AreEqual (dt.Rows [1], rowInAction_Changed, "#ltpc45 this row is not intended to change");
Assert.AreEqual (DataRowAction.ChangeOriginal, rowAction_Changed, "#ltpc46 row action is not Change");
ds.Tables[0].ReadXmlSchema (new StringReader (xs));
DataTable dt = ds.Tables [0];
AssertDataTable ("dt", dt, "Root", 2, 0, 0, 0, 0, 0);
- AssertEquals ("ja-JP", dt.Locale.Name); // DataTable's Locale comes from msdata:Locale
+ Assert.AreEqual ("ja-JP", dt.Locale.Name); // DataTable's Locale comes from msdata:Locale
AssertDataColumn ("col1", dt.Columns [0], "Attr", true, false, 0, 1, "Attr", MappingType.Attribute, typeof (Int64), DBNull.Value, String.Empty, -1, String.Empty, 0, String.Empty, false, false);
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);
}
DataTableReader reader = new DataTableReader (dt);
try {
- Assert.AreEqual (false, reader.Read (), "#1 there are no rows");
- Assert.AreEqual (false, reader.NextResult (), "#2 there are no further resultsets");
+ Assert.IsFalse (reader.Read (), "#1 there are no rows");
+ Assert.IsFalse (reader.NextResult (), "#2 there are no further resultsets");
} finally {
if (reader != null && !reader.IsClosed)
reader.Close ();
dt.Rows.Add (new object [] {8, "mono 8"});
dt.AcceptChanges ();
bool success = reader.Read ();
- Assert.AreEqual (false, success, "#2 is always invalid");
+ Assert.IsFalse (success, "#2 is always invalid");
// clear when reader is not read yet
reader.Close ();
dt.Rows.Add (new object [] {8, "mono 8"});
dt.AcceptChanges ();
success = reader.Read ();
- Assert.AreEqual (true, success, "#3 should add");
+ Assert.IsTrue (success, "#3 should add");
} finally {
if (reader != null && !reader.IsClosed)
reader.Close ();
{
DataTable dt = new DataTable();
- AssertEquals("CaseSensitive must be false." ,false,dt.CaseSensitive);
- Assert("Col",dt.Columns != null);
- //Assert(dt.ChildRelations != null);
- Assert("Const", dt.Constraints != null);
- Assert("ds", dt.DataSet == null);
- Assert("dv", dt.DefaultView != null);
- Assert("de", dt.DisplayExpression == "");
- Assert("ep", dt.ExtendedProperties != null);
- Assert("he", dt.HasErrors == false);
- Assert("lc", dt.Locale != null);
- Assert("mc", dt.MinimumCapacity == 50); //LAMESPEC:
- Assert("ns", dt.Namespace == "");
- //Assert(dt.ParentRelations != null);
- Assert("pf", dt.Prefix == "");
- Assert("pk", dt.PrimaryKey != null);
- Assert("rows", dt.Rows != null);
- Assert("Site", dt.Site == null);
- Assert("tname", dt.TableName == "");
+ Assert.IsFalse (dt.CaseSensitive, "CaseSensitive must be false.");
+ Assert.IsTrue (dt.Columns != null, "Col");
+ //Assert.IsTrue (dt.ChildRelations != null);
+ Assert.IsTrue (dt.Constraints != null, "Const");
+ Assert.IsTrue (dt.DataSet == null, "ds");
+ Assert.IsTrue (dt.DefaultView != null, "dv");
+ Assert.IsTrue (dt.DisplayExpression == "", "de");
+ Assert.IsTrue (dt.ExtendedProperties != null, "ep");
+ Assert.IsTrue (dt.HasErrors == false, "he");
+ Assert.IsTrue (dt.Locale != null, "lc");
+ Assert.IsTrue (dt.MinimumCapacity == 50, "mc"); //LAMESPEC:
+ Assert.IsTrue (dt.Namespace == "", "ns");
+ //Assert.IsTrue (dt.ParentRelations != null);
+ Assert.IsTrue (dt.Prefix == "", "pf");
+ Assert.IsTrue (dt.PrimaryKey != null, "pk");
+ Assert.IsTrue (dt.Rows != null, "rows");
+ Assert.IsTrue (dt.Site == null, "Site");
+ Assert.IsTrue (dt.TableName == "", "tname");
}
Child.Rows.Add (Row);
DataRow [] Rows = Mom.Select ("Name = 'Teresa'");
- AssertEquals ("test#01", 2, Rows.Length);
+ Assert.AreEqual (2, Rows.Length, "test#01");
// test with apos escaped
Rows = Mom.Select ("Name = '''Jhon O'''' Collenal'''");
- AssertEquals ("test#01.1", 1, Rows.Length);
+ Assert.AreEqual (1, Rows.Length, "test#01.1");
Rows = Mom.Select ("Name = 'Teresa' and ChildName = 'Nick'");
- AssertEquals ("test#02", 0, Rows.Length);
+ Assert.AreEqual (0, Rows.Length, "test#02");
Rows = Mom.Select ("Name = 'Teresa' and ChildName = 'Jack'");
- AssertEquals ("test#03", 1, Rows.Length);
+ Assert.AreEqual (1, Rows.Length, "test#03");
Rows = Mom.Select ("Name = 'Teresa' and ChildName <> 'Jack'");
- AssertEquals ("test#04", "Mack", Rows [0] [1]);
+ Assert.AreEqual ("Mack", Rows [0] [1], "test#04");
Rows = Mom.Select ("Name = 'Teresa' or ChildName <> 'Jack'");
- AssertEquals ("test#05", 6, Rows.Length);
+ Assert.AreEqual (6, Rows.Length, "test#05");
Rows = Child.Select ("age = 20 - 1");
- AssertEquals ("test#06", 1, Rows.Length);
+ Assert.AreEqual (1, Rows.Length, "test#06");
Rows = Child.Select ("age <= 20");
- AssertEquals ("test#07", 3, Rows.Length);
+ Assert.AreEqual (3, Rows.Length, "test#07");
Rows = Child.Select ("age >= 20");
- AssertEquals ("test#08", 4, Rows.Length);
+ Assert.AreEqual (4, Rows.Length, "test#08");
Rows = Child.Select ("age >= 20 and name = 'Mack' or name = 'Nick'");
- AssertEquals ("test#09", 2, Rows.Length);
+ Assert.AreEqual (2, Rows.Length, "test#09");
Rows = Child.Select ("age >= 20 and (name = 'Mack' or name = 'Nick')");
- AssertEquals ("test#10", 1, Rows.Length);
- AssertEquals ("test#11", "Mack", Rows [0] [0]);
+ Assert.AreEqual (1, Rows.Length, "test#10");
+ Assert.AreEqual ("Mack", Rows [0] [0], "test#11");
Rows = Child.Select ("not (Name = 'Jack')");
- AssertEquals ("test#12", 6, Rows.Length);
+ Assert.AreEqual (6, Rows.Length, "test#12");
}
[Test]
Child.Rows.Add (Row);
DataRow [] Rows = Child.Select ("age >= 20", "age DESC");
- AssertEquals ("test#01", 3, Rows.Length);
- AssertEquals ("test#02", "Mack", Rows [0] [0]);
- AssertEquals ("test#03", "Mick", Rows [1] [0]);
- AssertEquals ("test#04", "Dick", Rows [2] [0]);
+ Assert.AreEqual (3, Rows.Length, "test#01");
+ Assert.AreEqual ("Mack", Rows [0] [0], "test#02");
+ Assert.AreEqual ("Mick", Rows [1] [0], "test#03");
+ Assert.AreEqual ("Dick", Rows [2] [0], "test#04");
Rows = Child.Select ("age >= 20", "age asc");
- AssertEquals ("test#05", 3, Rows.Length);
- AssertEquals ("test#06", "Dick", Rows [0] [0]);
- AssertEquals ("test#07", "Mick", Rows [1] [0]);
- AssertEquals ("test#08", "Mack", Rows [2] [0]);
+ Assert.AreEqual (3, Rows.Length, "test#05");
+ Assert.AreEqual ("Dick", Rows [0] [0], "test#06");
+ Assert.AreEqual ("Mick", Rows [1] [0], "test#07");
+ Assert.AreEqual ("Mack", Rows [2] [0], "test#08");
Rows = Child.Select ("age >= 20", "name asc");
- AssertEquals ("test#09", 3, Rows.Length);
- AssertEquals ("test#10", "Dick", Rows [0] [0]);
- AssertEquals ("test#11", "Mack", Rows [1] [0]);
- AssertEquals ("test#12", "Mick", Rows [2] [0]);
+ Assert.AreEqual (3, Rows.Length, "test#09");
+ Assert.AreEqual ("Dick", Rows [0] [0], "test#10");
+ Assert.AreEqual ("Mack", Rows [1] [0], "test#11");
+ Assert.AreEqual ("Mick", Rows [2] [0], "test#12");
Rows = Child.Select ("age >= 20", "name desc");
- AssertEquals ("test#09", 3, Rows.Length);
- AssertEquals ("test#10", "Mick", Rows [0] [0]);
- AssertEquals ("test#11", "Mack", Rows [1] [0]);
- AssertEquals ("test#12", "Dick", Rows [2] [0]);
+ Assert.AreEqual (3, Rows.Length, "test#09");
+ Assert.AreEqual ("Mick", Rows [0] [0], "test#10");
+ Assert.AreEqual ("Mack", Rows [1] [0], "test#11");
+ Assert.AreEqual ("Dick", Rows [2] [0], "test#12");
}
Row [2] = 1;
T.Rows.Add (Row);
- AssertEquals ("test#01", 12, T.Select ("age<=10").Length);
+ Assert.AreEqual (12, T.Select ("age<=10").Length, "test#01");
- AssertEquals ("test#02", 12, T.Select ("age\n\t<\n\t=\t\n10").Length);
+ Assert.AreEqual (12, T.Select ("age\n\t<\n\t=\t\n10").Length, "test#02");
try {
T.Select ("name = 1human ");
- Fail ("test#03");
+ Assert.Fail ("test#03");
} catch (Exception e) {
// missing operand after 'human' operand
- AssertEquals ("test#04", typeof (SyntaxErrorException), e.GetType ());
+ Assert.AreEqual (typeof (SyntaxErrorException), e.GetType (), "test#04");
}
try {
T.Select ("name = 1");
- Fail ("test#05");
+ Assert.Fail ("test#05");
} catch (Exception e) {
// Cannot perform '=' operation between string and Int32
- AssertEquals ("test#06", typeof (EvaluateException), e.GetType ());
+ Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#06");
}
- AssertEquals ("test#07", 1, T.Select ("age = '13'").Length);
+ Assert.AreEqual (1, T.Select ("age = '13'").Length, "test#07");
}
dt.Rows.Add (new object [] {"\t"});
dt.Rows.Add (new object [] {"\\"});
- AssertEquals ("test#01", 1, dt.Select (@"SomeCol='\t'").Length);
- AssertEquals ("test#02", 1, dt.Select (@"SomeCol='\\'").Length);
+ Assert.AreEqual (1, dt.Select (@"SomeCol='\t'").Length, "test#01");
+ Assert.AreEqual (1, dt.Select (@"SomeCol='\\'").Length, "test#02");
try {
dt.Select (@"SomeCol='\x'");
- Fail("test#03");
+ Assert.Fail("test#03");
} catch (SyntaxErrorException) {}
}
Row [2] = 1;
T.Rows.Add (Row);
- AssertEquals ("test#01", 11, T.Select ("age < 10").Length);
- AssertEquals ("test#02", 12, T.Select ("age <= 10").Length);
- AssertEquals ("test#03", 12, T.Select ("age< =10").Length);
- AssertEquals ("test#04", 89, T.Select ("age > 10").Length);
- AssertEquals ("test#05", 90, T.Select ("age >= 10").Length);
- AssertEquals ("test#06", 100, T.Select ("age <> 10").Length);
- AssertEquals ("test#07", 3, T.Select ("name < 'human10'").Length);
- AssertEquals ("test#08", 3, T.Select ("id < '10'").Length);
+ Assert.AreEqual (11, T.Select ("age < 10").Length, "test#01");
+ Assert.AreEqual (12, T.Select ("age <= 10").Length, "test#02");
+ Assert.AreEqual (12, T.Select ("age< =10").Length, "test#03");
+ Assert.AreEqual (89, T.Select ("age > 10").Length, "test#04");
+ Assert.AreEqual (90, T.Select ("age >= 10").Length, "test#05");
+ Assert.AreEqual (100, T.Select ("age <> 10").Length, "test#06");
+ Assert.AreEqual (3, T.Select ("name < 'human10'").Length, "test#07");
+ Assert.AreEqual (3, T.Select ("id < '10'").Length, "test#08");
// FIXME: Somebody explain how this can be possible.
// it seems that it is no matter between 10 - 30. The
// result is allways 25 :-P
- //AssertEquals ("test#09", 25, T.Select ("id < 10").Length);
+ //Assert.AreEqual (25, T.Select ("id < 10").Length, "test#09");
}
try {
T.Select ("name = human1");
- Fail ("test#01");
+ Assert.Fail ("test#01");
} catch (Exception e) {
// column name human not found
- AssertEquals ("test#02", typeof (EvaluateException), e.GetType ());
+ Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#02");
}
- AssertEquals ("test#04", 1, T.Select ("id = '12'").Length);
- AssertEquals ("test#05", 1, T.Select ("id = 12").Length);
+ Assert.AreEqual (1, T.Select ("id = '12'").Length, "test#04");
+ Assert.AreEqual (1, T.Select ("id = 12").Length, "test#05");
try {
T.Select ("id = 1k3");
- Fail ("test#06");
+ Assert.Fail ("test#06");
} catch (Exception e) {
// no operands after k3 operator
- AssertEquals ("test#07", typeof (SyntaxErrorException), e.GetType ());
+ Assert.AreEqual (typeof (SyntaxErrorException), e.GetType (), "test#07");
}
}
Row [2] = 1;
T.Rows.Add (Row);
- AssertEquals ("test#01", 1, T.Select ("name = 'human' + 1").Length);
+ Assert.AreEqual (1, T.Select ("name = 'human' + 1").Length, "test#01");
- AssertEquals ("test#02", "human1", T.Select ("name = 'human' + 1") [0] ["name"]);
- AssertEquals ("test#03", 1, T.Select ("name = 'human' + '1'").Length);
- AssertEquals ("test#04", "human1", T.Select ("name = 'human' + '1'") [0] ["name"]);
- AssertEquals ("test#05", 1, T.Select ("name = 'human' + 1 + 2").Length);
- AssertEquals ("test#06", "human12", T.Select ("name = 'human' + '1' + '2'") [0] ["name"]);
+ Assert.AreEqual ("human1", T.Select ("name = 'human' + 1") [0] ["name"], "test#02");
+ Assert.AreEqual (1, T.Select ("name = 'human' + '1'").Length, "test#03");
+ Assert.AreEqual ("human1", T.Select ("name = 'human' + '1'") [0] ["name"], "test#04");
+ Assert.AreEqual (1, T.Select ("name = 'human' + 1 + 2").Length, "test#05");
+ Assert.AreEqual ("human12", T.Select ("name = 'human' + '1' + '2'") [0] ["name"], "test#06");
- AssertEquals ("test#07", 1, T.Select ("name = 'huMAn' + 1").Length);
+ Assert.AreEqual (1, T.Select ("name = 'huMAn' + 1").Length, "test#07");
Set.CaseSensitive = true;
- AssertEquals ("test#08", 0, T.Select ("name = 'huMAn' + 1").Length);
+ Assert.AreEqual (0, T.Select ("name = 'huMAn' + 1").Length, "test#08");
T.CaseSensitive = false;
- AssertEquals ("test#09", 1, T.Select ("name = 'huMAn' + 1").Length);
+ Assert.AreEqual (1, T.Select ("name = 'huMAn' + 1").Length, "test#09");
T.CaseSensitive = true;
- AssertEquals ("test#10", 0, T.Select ("name = 'huMAn' + 1").Length);
+ Assert.AreEqual (0, T.Select ("name = 'huMAn' + 1").Length, "test#10");
Set.CaseSensitive = false;
- AssertEquals ("test#11", 0, T.Select ("name = 'huMAn' + 1").Length);
+ Assert.AreEqual (0, T.Select ("name = 'huMAn' + 1").Length, "test#11");
T.CaseSensitive = false;
- AssertEquals ("test#12", 1, T.Select ("name = 'huMAn' + 1").Length);
+ Assert.AreEqual (1, T.Select ("name = 'huMAn' + 1").Length, "test#12");
- AssertEquals ("test#13", 0, T.Select ("name = 'human1*'").Length);
- AssertEquals ("test#14", 11, T.Select ("name like 'human1*'").Length);
- AssertEquals ("test#15", 11, T.Select ("name like 'human1%'").Length);
+ Assert.AreEqual (0, T.Select ("name = 'human1*'").Length, "test#13");
+ Assert.AreEqual (11, T.Select ("name like 'human1*'").Length, "test#14");
+ Assert.AreEqual (11, T.Select ("name like 'human1%'").Length, "test#15");
try {
- AssertEquals ("test#16", 11, T.Select ("name like 'h*an1'").Length);
- Fail ("test#16");
+ Assert.AreEqual (11, T.Select ("name like 'h*an1'").Length, "test#16");
+ Assert.Fail ("test#16");
} catch (Exception e) {
// 'h*an1' is invalid
- AssertEquals ("test#17", typeof (EvaluateException), e.GetType ());
+ Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#17");
}
try {
- AssertEquals ("test#18", 11, T.Select ("name like 'h%an1'").Length);
- Fail ("test#19");
+ Assert.AreEqual (11, T.Select ("name like 'h%an1'").Length, "test#18");
+ Assert.Fail ("test#19");
} catch (Exception e) {
// 'h%an1' is invalid
- AssertEquals ("test#20", typeof (EvaluateException), e.GetType ());
+ Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#20");
}
- AssertEquals ("test#21", 0, T.Select ("name like 'h[%]an'").Length);
- AssertEquals ("test#22", 1, T.Select ("name like 'h[*]an'").Length);
+ Assert.AreEqual (0, T.Select ("name like 'h[%]an'").Length, "test#21");
+ Assert.AreEqual (1, T.Select ("name like 'h[*]an'").Length, "test#22");
}
T.Rows.Add (Row);
}
- AssertEquals ("test#01", 1000, T.Select ("Sum(age) > 10").Length);
- AssertEquals ("test#02", 1000, T.Select ("avg(age) = 499").Length);
- AssertEquals ("test#03", 1000, T.Select ("min(age) = 0").Length);
- AssertEquals ("test#04", 1000, T.Select ("max(age) = 999").Length);
- AssertEquals ("test#05", 1000, T.Select ("count(age) = 1000").Length);
- AssertEquals ("test#06", 1000, T.Select ("stdev(age) > 287 and stdev(age) < 289").Length);
- AssertEquals ("test#07", 1000, T.Select ("var(age) < 83417 and var(age) > 83416").Length);
+ Assert.AreEqual (1000, T.Select ("Sum(age) > 10").Length, "test#01");
+ Assert.AreEqual (1000, T.Select ("avg(age) = 499").Length, "test#02");
+ Assert.AreEqual (1000, T.Select ("min(age) = 0").Length, "test#03");
+ Assert.AreEqual (1000, T.Select ("max(age) = 999").Length, "test#04");
+ Assert.AreEqual (1000, T.Select ("count(age) = 1000").Length, "test#05");
+ Assert.AreEqual (1000, T.Select ("stdev(age) > 287 and stdev(age) < 289").Length, "test#06");
+ Assert.AreEqual (1000, T.Select ("var(age) < 83417 and var(age) > 83416").Length, "test#07");
}
[Test]
T.Rows.Add (Row);
//TODO: How to test Convert-function
- AssertEquals ("test#01", 25, T.Select ("age = 5*5") [0]["age"]);
- AssertEquals ("test#02", 901, T.Select ("len(name) > 7").Length);
- AssertEquals ("test#03", 125, T.Select ("age = 5*5*5 AND len(name)>7") [0]["age"]);
- AssertEquals ("test#04", 1, T.Select ("isnull(id, 'test') = 'test'").Length);
- AssertEquals ("test#05", 1000, T.Select ("iif(id = '56', 'test', 'false') = 'false'").Length);
- AssertEquals ("test#06", 1, T.Select ("iif(id = '56', 'test', 'false') = 'test'").Length);
- AssertEquals ("test#07", 9, T.Select ("substring(id, 2, 3) = '23'").Length);
- AssertEquals ("test#08", "123", T.Select ("substring(id, 2, 3) = '23'") [0] ["id"]);
- AssertEquals ("test#09", "423", T.Select ("substring(id, 2, 3) = '23'") [3] ["id"]);
- AssertEquals ("test#10", "923", T.Select ("substring(id, 2, 3) = '23'") [8] ["id"]);
+ Assert.AreEqual (25, T.Select ("age = 5*5") [0]["age"], "test#01");
+ Assert.AreEqual (901, T.Select ("len(name) > 7").Length, "test#02");
+ Assert.AreEqual (125, T.Select ("age = 5*5*5 AND len(name)>7") [0]["age"], "test#03");
+ Assert.AreEqual (1, T.Select ("isnull(id, 'test') = 'test'").Length, "test#04");
+ Assert.AreEqual (1000, T.Select ("iif(id = '56', 'test', 'false') = 'false'").Length, "test#05");
+ Assert.AreEqual (1, T.Select ("iif(id = '56', 'test', 'false') = 'test'").Length, "test#06");
+ Assert.AreEqual (9, T.Select ("substring(id, 2, 3) = '23'").Length, "test#07");
+ Assert.AreEqual ("123", T.Select ("substring(id, 2, 3) = '23'") [0] ["id"], "test#08");
+ Assert.AreEqual ("423", T.Select ("substring(id, 2, 3) = '23'") [3] ["id"], "test#09");
+ Assert.AreEqual ("923", T.Select ("substring(id, 2, 3) = '23'") [8] ["id"], "test#10");
}
Child.Rows.Add (Row);
DataRow [] Rows = Child.Select ("name = Parent.Childname");
- AssertEquals ("test#01", 6, Rows.Length);
+ Assert.AreEqual (6, Rows.Length, "test#01");
Rows = Child.Select ("Parent.childname = 'Jack'");
- AssertEquals ("test#02", 1, Rows.Length);
+ Assert.AreEqual (1, Rows.Length, "test#02");
/*
try {
// FIXME: LAMESPEC: Why the exception is thrown why... why...
Mom.Select ("Child.Name = 'Jack'");
- Fail ("test#03");
+ Assert.Fail ("test#03");
} catch (Exception e) {
- AssertEquals ("test#04", typeof (SyntaxErrorException), e.GetType ());
- AssertEquals ("test#05", "Cannot interpret token 'Child' at position 1.", e.Message);
+ Assert.AreEqual (typeof (SyntaxErrorException), e.GetType (), "test#04");
+ Assert.AreEqual ("Cannot interpret token 'Child' at position 1.", e.Message, "test#05");
}
*/
Rows = Child.Select ("Parent.name = 'Laura'");
- AssertEquals ("test#06", 3, Rows.Length);
+ Assert.AreEqual (3, Rows.Length, "test#06");
DataTable Parent2 = new DataTable ("Parent2");
Col = new DataColumn ("Name");
try {
Rows = Child.Select ("Parent.ChildName = 'Jack'");
- Fail ("test#07");
+ Assert.Fail ("test#07");
} catch (Exception e) {
- AssertEquals ("test#08", typeof (EvaluateException), e.GetType ());
- //AssertEquals ("test#09", "The table [Child] involved in more than one relation. You must explicitly mention a relation name in the expression 'parent.[ChildName]'.", e.Message);
+ Assert.AreEqual (typeof (EvaluateException), e.GetType (), "test#08");
+ //Assert.AreEqual ("The table [Child] involved in more than one relation. You must explicitly mention a relation name in the expression 'parent.[ChildName]'.", e.Message, "test#09");
}
Rows = Child.Select ("Parent(rel).ChildName = 'Jack'");
- AssertEquals ("test#10", 1, Rows.Length);
+ Assert.AreEqual (1, Rows.Length, "test#10");
Rows = Child.Select ("Parent(Rel2).ChildName = 'Jack'");
- AssertEquals ("test#10", 1, Rows.Length);
+ Assert.AreEqual (1, Rows.Length, "test#10");
try {
Mom.Select ("Parent.name = 'John'");
} catch (Exception e) {
- AssertEquals ("test#11", typeof (IndexOutOfRangeException), e.GetType ());
- AssertEquals ("test#12", "Cannot find relation 0.", e.Message);
+ Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (), "test#11");
+ Assert.AreEqual ("Cannot find relation 0.", e.Message, "test#12");
}
}
DataTable d = new DataTable();
d.Columns.Add (new DataColumn ("aaa"));
DataRow [] rows = d.Select (null, null, DataViewRowState.Deleted);
- AssertEquals(0, rows.Length);
+ Assert.AreEqual (0, rows.Length);
d.Rows.Add (new object [] {"bbb"});
d.Rows.Add (new object [] {"bbb"});
rows = d.Select (null, null, DataViewRowState.Deleted);
- AssertEquals(0, rows.Length);
+ Assert.AreEqual (0, rows.Length);
}
[Test]
string cmpr = dt.TableName + " + " + dt.DisplayExpression;
- AssertEquals(cmpr,dt.ToString());
+ Assert.AreEqual (cmpr, dt.ToString());
}
[Test]
dt.Columns.Add ();
dt.Columns.Add ();
- AssertEquals ("test#01", 0, dt.PrimaryKey.Length);
+ Assert.AreEqual (0, dt.PrimaryKey.Length, "test#01");
dt.PrimaryKey = new DataColumn [] {dt.Columns [0]};
- AssertEquals ("test#02", 1, dt.PrimaryKey.Length);
- AssertEquals ("test#03", "Column1", dt.PrimaryKey [0].ColumnName);
+ Assert.AreEqual (1, dt.PrimaryKey.Length, "test#02");
+ Assert.AreEqual ("Column1", dt.PrimaryKey [0].ColumnName, "test#03");
dt.PrimaryKey = null;
- AssertEquals ("test#04", 0, dt.PrimaryKey.Length);
+ Assert.AreEqual (0, dt.PrimaryKey.Length, "test#04");
Col = new DataColumn ("failed");
try {
dt.PrimaryKey = new DataColumn [] {Col};
- Fail ("test#05");
+ Assert.Fail ("test#05");
} catch (Exception e) {
- AssertEquals ("test#06", typeof (ArgumentException), e.GetType ());
- AssertEquals ("test#07", "Column must belong to a table.", e.Message);
+ Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#06");
+ Assert.AreEqual ("Column must belong to a table.", e.Message, "test#07");
}
DataTable dt2 = new DataTable ();
try {
dt.PrimaryKey = new DataColumn [] {dt2.Columns [0]};
- Fail ("test#08");
+ Assert.Fail ("test#08");
} catch (Exception e) {
- AssertEquals ("test#09", typeof (ArgumentException), e.GetType ());
- AssertEquals ("test#10", "PrimaryKey columns do not belong to this table.", e.Message);
+ Assert.AreEqual (typeof (ArgumentException), e.GetType (), "test#09");
+ Assert.AreEqual ("PrimaryKey columns do not belong to this table.", e.Message, "test#10");
}
- AssertEquals ("test#11", 0, dt.Constraints.Count);
+ Assert.AreEqual (0, dt.Constraints.Count, "test#11");
dt.PrimaryKey = new DataColumn [] {dt.Columns [0], dt.Columns [1]};
- AssertEquals ("test#12", 2, dt.PrimaryKey.Length);
- AssertEquals ("test#13", 1, dt.Constraints.Count);
- AssertEquals ("test#14", true, dt.Constraints [0] is UniqueConstraint);
- AssertEquals ("test#15", "Column1", dt.PrimaryKey [0].ColumnName);
- AssertEquals ("test#16", "Column2", dt.PrimaryKey [1].ColumnName);
+ Assert.AreEqual (2, dt.PrimaryKey.Length, "test#12");
+ Assert.AreEqual (1, dt.Constraints.Count, "test#13");
+ Assert.IsTrue (dt.Constraints [0] is UniqueConstraint, "test#14");
+ Assert.AreEqual ("Column1", dt.PrimaryKey [0].ColumnName, "test#15");
+ Assert.AreEqual ("Column2", dt.PrimaryKey [1].ColumnName, "test#16");
}
try {
table.CaseSensitive = true;
table1.CaseSensitive = true;
- Fail ("#A01");
+ Assert.Fail ("#A01");
}
catch (Exception e) {
if (e.GetType () != typeof (AssertionException))
- AssertEquals ("#A02", "Cannot change CaseSensitive or Locale property. This change would lead to at least one DataRelation or Constraint to have different Locale or CaseSensitive settings between its related tables.",e.Message);
+ Assert.AreEqual ("Cannot change CaseSensitive or Locale property. This change would lead to at least one DataRelation or Constraint to have different Locale or CaseSensitive settings between its related tables.", e.Message, "#A02");
else
Console.WriteLine (e);
}
CultureInfo cultureInfo = new CultureInfo ("en-gb");
table.Locale = cultureInfo;
table1.Locale = cultureInfo;
- Fail ("#A03");
+ Assert.Fail ("#A03");
}
catch (Exception e) {
if (e.GetType () != typeof (AssertionException))
- AssertEquals ("#A04", "Cannot change CaseSensitive or Locale property. This change would lead to at least one DataRelation or Constraint to have different Locale or CaseSensitive settings between its related tables.",e.Message);
+ Assert.AreEqual ("Cannot change CaseSensitive or Locale property. This change would lead to at least one DataRelation or Constraint to have different Locale or CaseSensitive settings between its related tables.", e.Message, "#A04");
else
Console.WriteLine (e);
}
try {
table.Prefix = "Prefix#1";
- Fail ("#A05");
+ Assert.Fail ("#A05");
}
catch (Exception e){
if (e.GetType () != typeof (AssertionException))
- AssertEquals ("#A06", "Prefix 'Prefix#1' is not valid, because it contains special characters.",e.Message);
+ Assert.AreEqual ("Prefix 'Prefix#1' is not valid, because it contains special characters.",e.Message, "#A06");
else
Console.WriteLine (e);
row.RowError = "Error#1";
table.Rows.Add (row);
- AssertEquals ("#A01", 1, table.GetErrors ().Length);
- AssertEquals ("#A02", "Error#1", (table.GetErrors ())[0].RowError);
+ Assert.AreEqual (1, table.GetErrors ().Length, "#A01");
+ Assert.AreEqual ("Error#1", (table.GetErrors ())[0].RowError, "#A02");
}
#if NET_2_0
[Test]
row ["name"] = "Abc";
table.Rows.Add (row);
- AssertEquals ("#NewRowAdded Event #01", true, _tableNewRowAddedEventFired);
+ Assert.IsTrue (_tableNewRowAddedEventFired, "#NewRowAdded Event #01");
}
#endif
[Test]
//Testing properties of clone
DataTable cloneTable = table.Clone ();
- AssertEquals ("#A01",true ,cloneTable.CaseSensitive);
- AssertEquals ("#A02", 0 , cloneTable.ChildRelations.Count);
- AssertEquals ("#A03", 0 , cloneTable.ParentRelations.Count);
- AssertEquals ("#A04", 2, cloneTable.Columns.Count);
- AssertEquals ("#A05", 1, cloneTable.Constraints.Count);
- AssertEquals ("#A06", "Id / Name + (Id * Id)", cloneTable.DisplayExpression);
- AssertEquals ("#A07", 1 ,cloneTable.ExtendedProperties.Count);
- AssertEquals ("#A08", false ,cloneTable.HasErrors);
+ Assert.IsTrue (cloneTable.CaseSensitive, "#A01");
+ Assert.AreEqual (0 , cloneTable.ChildRelations.Count, "#A02");
+ Assert.AreEqual (0 , cloneTable.ParentRelations.Count, "#A03");
+ Assert.AreEqual (2, cloneTable.Columns.Count, "#A04");
+ Assert.AreEqual (1, cloneTable.Constraints.Count, "#A05");
+ Assert.AreEqual ("Id / Name + (Id * Id)", cloneTable.DisplayExpression, "#A06");
+ Assert.AreEqual (1, cloneTable.ExtendedProperties.Count, "#A07");
+ Assert.IsFalse (cloneTable.HasErrors, "#A08");
#if NET_1_1
#else
- AssertEquals ("#A09", 2057, cloneTable.Locale.LCID);
+ Assert.AreEqual (2057, cloneTable.Locale.LCID, "#A09");
#endif
- AssertEquals ("#A10", 100, cloneTable.MinimumCapacity);
- AssertEquals ("#A11","Namespace#1", cloneTable.Namespace);
- AssertEquals ("#A12", "PrefixNo:1",cloneTable.Prefix);
- AssertEquals ("#A13", "Id", cloneTable.PrimaryKey[0].ColumnName);
- AssertEquals ("#A14",0 , cloneTable.Rows.Count );
- AssertEquals ("#A15", "Table#1", cloneTable.TableName);
+ Assert.AreEqual (100, cloneTable.MinimumCapacity, "#A10");
+ Assert.AreEqual ("Namespace#1", cloneTable.Namespace, "#A11");
+ Assert.AreEqual ("PrefixNo:1", cloneTable.Prefix, "#A12");
+ Assert.AreEqual ("Id", cloneTable.PrimaryKey[0].ColumnName, "#A13");
+ Assert.AreEqual (0, cloneTable.Rows.Count , "#A14");
+ Assert.AreEqual ("Table#1", cloneTable.TableName, "#A15");
//Testing properties of copy
DataTable copyTable = table.Copy ();
- AssertEquals ("#A16",true ,copyTable.CaseSensitive);
- AssertEquals ("#A17", 0 , copyTable.ChildRelations.Count);
- AssertEquals ("#A18", 0 , copyTable.ParentRelations.Count);
- AssertEquals ("#A19", 2, copyTable.Columns.Count);
- AssertEquals ("#A20", 1, copyTable.Constraints.Count);
- AssertEquals ("#A21", "Id / Name + (Id * Id)", copyTable.DisplayExpression);
- AssertEquals ("#A22", 1 ,copyTable.ExtendedProperties.Count);
- AssertEquals ("#A23", true ,copyTable.HasErrors);
+ Assert.IsTrue (copyTable.CaseSensitive, "#A16");
+ Assert.AreEqual (0 , copyTable.ChildRelations.Count, "#A17");
+ Assert.AreEqual (0 , copyTable.ParentRelations.Count, "#A18");
+ Assert.AreEqual (2, copyTable.Columns.Count, "#A19");
+ Assert.AreEqual (1, copyTable.Constraints.Count, "#A20");
+ Assert.AreEqual ("Id / Name + (Id * Id)", copyTable.DisplayExpression, "#A21");
+ Assert.AreEqual (1, copyTable.ExtendedProperties.Count, "#A22");
+ Assert.IsTrue (copyTable.HasErrors, "#A23");
#if NET_1_1
#else
- AssertEquals ("#A24", 2057, copyTable.Locale.LCID);
+ Assert.AreEqual (2057, copyTable.Locale.LCID, "#A24");
#endif
- AssertEquals ("#A25", 100, copyTable.MinimumCapacity);
- AssertEquals ("#A26","Namespace#1", copyTable.Namespace);
- AssertEquals ("#A27", "PrefixNo:1",copyTable.Prefix);
- AssertEquals ("#A28", "Id", copyTable.PrimaryKey[0].ColumnName);
- AssertEquals ("#A29", 2 , copyTable.Rows.Count );
- AssertEquals ("#A30", "Table#1", copyTable.TableName);
+ Assert.AreEqual (100, copyTable.MinimumCapacity, "#A25");
+ Assert.AreEqual ("Namespace#1", copyTable.Namespace, "#A26");
+ Assert.AreEqual ("PrefixNo:1", copyTable.Prefix, "#A27");
+ Assert.AreEqual ("Id", copyTable.PrimaryKey[0].ColumnName, "#A28");
+ Assert.AreEqual (2, copyTable.Rows.Count, "#A29");
+ Assert.AreEqual ("Table#1", copyTable.TableName, "#A30");
}
[Test]
try {
table.EndLoadData ();
- Fail ("#A01");
+ Assert.Fail ("#A01");
}
catch (ConstraintException) {
}
//Testing GetChanges
DataTable changesTable = table.GetChanges ();
- AssertEquals ("#A01", 1 ,changesTable.Rows.Count);
- AssertEquals ("#A02","Efg" ,changesTable.Rows[0]["Name"]);
+ Assert.AreEqual (1, changesTable.Rows.Count, "#A01");
+ Assert.AreEqual ("Efg", changesTable.Rows[0]["Name"], "#A02");
table.AcceptChanges ();
changesTable = table.GetChanges ();
try {
}
catch(Exception e) {
if (e.GetType () != typeof (AssertionException))
- AssertEquals ("#A03",typeof(NullReferenceException) ,e.GetType ());
+ Assert.AreEqual (typeof(NullReferenceException), e.GetType (), "#A03");
else
Console.WriteLine (e);
}
(table.Rows [0])["Name"] = "AaBbCc";
table.RejectChanges ();
- AssertEquals ("#A03", "Abc" , (table.Rows [0]) ["Name"]);
- AssertEquals ("#A04", 2, table.Rows.Count);
+ Assert.AreEqual ("Abc" , (table.Rows [0]) ["Name"], "#A03");
+ Assert.AreEqual (2, table.Rows.Count, "#A04");
}
[Test]
try {
target.ImportRow (src.Rows [2]); // import 3rd row again
- Fail ("#AA1 Should have thrown exception violativ PK");
+ Assert.Fail ("#AA1 Should have thrown exception violativ PK");
} catch (ConstraintException e) {}
// check row states
- AssertEquals ("#A1", src.Rows [0].RowState, target.Rows [0].RowState);
- AssertEquals ("#A2", src.Rows [1].RowState, target.Rows [1].RowState);
- AssertEquals ("#A3", src.Rows [2].RowState, target.Rows [2].RowState);
- AssertEquals ("#A4", src.Rows [3].RowState, target.Rows [3].RowState);
+ Assert.AreEqual (src.Rows [0].RowState, target.Rows [0].RowState, "#A1");
+ Assert.AreEqual (src.Rows [1].RowState, target.Rows [1].RowState, "#A2");
+ Assert.AreEqual (src.Rows [2].RowState, target.Rows [2].RowState, "#A3");
+ Assert.AreEqual (src.Rows [3].RowState, target.Rows [3].RowState, "#A4");
// check for modified row (1st row)
- AssertEquals ("#B1", (string) src.Rows [0] [1], (string) target.Rows [0] [1]);
- AssertEquals ("#B2", (string) src.Rows [0] [1, DataRowVersion.Default], (string) target.Rows [0] [1, DataRowVersion.Default]);
- AssertEquals ("#B3", (string) src.Rows [0] [1, DataRowVersion.Original], (string) target.Rows [0] [1, DataRowVersion.Original]);
- AssertEquals ("#B4", (string) src.Rows [0] [1, DataRowVersion.Current], (string) target.Rows [0] [1, DataRowVersion.Current]);
- AssertEquals ("#B5", false, target.Rows [0].HasVersion(DataRowVersion.Proposed));
+ Assert.AreEqual ((string) src.Rows [0] [1], (string) target.Rows [0] [1], "#B1");
+ Assert.AreEqual ((string) src.Rows [0] [1, DataRowVersion.Default], (string) target.Rows [0] [1, DataRowVersion.Default], "#B2");
+ Assert.AreEqual ((string) src.Rows [0] [1, DataRowVersion.Original], (string) target.Rows [0] [1, DataRowVersion.Original], "#B3");
+ Assert.AreEqual ((string) src.Rows [0] [1, DataRowVersion.Current], (string) target.Rows [0] [1, DataRowVersion.Current], "#B4");
+ Assert.IsFalse (target.Rows [0].HasVersion(DataRowVersion.Proposed), "#B5");
// check for deleted row (2nd row)
- AssertEquals ("#C1", (string) src.Rows [1] [1, DataRowVersion.Original], (string) target.Rows [1] [1, DataRowVersion.Original]);
+ Assert.AreEqual ((string) src.Rows [1] [1, DataRowVersion.Original], (string) target.Rows [1] [1, DataRowVersion.Original], "#C1");
// check for unchanged row (3rd row)
- AssertEquals ("#D1", (string) src.Rows [2] [1], (string) target.Rows [2] [1]);
- AssertEquals ("#D2", (string) src.Rows [2] [1, DataRowVersion.Default], (string) target.Rows [2] [1, DataRowVersion.Default]);
- AssertEquals ("#D3", (string) src.Rows [2] [1, DataRowVersion.Original], (string) target.Rows [2] [1, DataRowVersion.Original]);
- AssertEquals ("#D4", (string) src.Rows [2] [1, DataRowVersion.Current], (string) target.Rows [2] [1, DataRowVersion.Current]);
+ Assert.AreEqual ((string) src.Rows [2] [1], (string) target.Rows [2] [1], "#D1");
+ Assert.AreEqual ((string) src.Rows [2] [1, DataRowVersion.Default], (string) target.Rows [2] [1, DataRowVersion.Default], "#D2");
+ Assert.AreEqual ((string) src.Rows [2] [1, DataRowVersion.Original], (string) target.Rows [2] [1, DataRowVersion.Original], "#D3");
+ Assert.AreEqual ((string) src.Rows [2] [1, DataRowVersion.Current], (string) target.Rows [2] [1, DataRowVersion.Current], "#D4");
// check for newly added row (4th row)
- AssertEquals ("#E1", (string) src.Rows [3] [1], (string) target.Rows [3] [1]);
- AssertEquals ("#E2", (string) src.Rows [3] [1, DataRowVersion.Default], (string) target.Rows [3] [1, DataRowVersion.Default]);
- AssertEquals ("#E3", (string) src.Rows [3] [1, DataRowVersion.Current], (string) target.Rows [3] [1, DataRowVersion.Current]);
+ Assert.AreEqual ((string) src.Rows [3] [1], (string) target.Rows [3] [1], "#E1");
+ Assert.AreEqual ((string) src.Rows [3] [1, DataRowVersion.Default], (string) target.Rows [3] [1, DataRowVersion.Default], "#E2");
+ Assert.AreEqual ((string) src.Rows [3] [1, DataRowVersion.Current], (string) target.Rows [3] [1, DataRowVersion.Current], "#E3");
}
[Test]
table.ImportRow (row);
//if RowState is detached, then dont import the row.
- AssertEquals ("#1", 0, table.Rows.Count);
+ Assert.AreEqual (0, table.Rows.Count, "#1");
}
[Test]
// row.
row.Delete ();
table.ImportRow (row);
- AssertEquals ("#1", 2, table.Rows.Count);
+ Assert.AreEqual (2, table.Rows.Count, "#1");
// Both the deleted rows shud be now gone
table.AcceptChanges ();
- AssertEquals ("#2", 0, table.Rows.Count);
+ Assert.AreEqual (0, table.Rows.Count, "#2");
//just add another row
row = table.Rows.Add (new object[] {1,2});
// row and validate only on RejectChanges
row.Delete ();
table.ImportRow (row);
- AssertEquals ("#3", 2, table.Rows.Count);
- AssertEquals ("#4", DataRowState.Deleted, table.Rows[1].RowState);
+ Assert.AreEqual (2, table.Rows.Count, "#3");
+ Assert.AreEqual (DataRowState.Deleted, table.Rows[1].RowState, "#4");
try {
table.RejectChanges ();
- Fail ("#5");
+ Assert.Fail ("#5");
} catch (ConstraintException e) {
}
}
row ["Name"] = "roopa";
table.Rows.Add (row);
- AssertEquals (2, table.Rows.Count);
- AssertEquals (1, table.ChildRelations.Count);
+ Assert.AreEqual (2, table.Rows.Count);
+ Assert.AreEqual (1, table.ChildRelations.Count);
try {
table.Reset ();
- Fail ("#A01, should have thrown ArgumentException");
+ Assert.Fail ("#A01, should have thrown ArgumentException");
}
catch (ArgumentException) {
}
- AssertEquals ("#CT01", 0, table.Rows.Count);
- AssertEquals ("#CT02", 0, table.ChildRelations.Count);
- AssertEquals ("#CT03", 0, table.ParentRelations.Count);
- AssertEquals ("#CT04", 0, table.Constraints.Count);
+ Assert.AreEqual (0, table.Rows.Count, "#CT01");
+ Assert.AreEqual (0, table.ChildRelations.Count, "#CT02");
+ Assert.AreEqual (0, table.ParentRelations.Count, "#CT03");
+ Assert.AreEqual (0, table.Constraints.Count, "#CT04");
table1.Reset ();
- AssertEquals ("#A05", 0, table1.Rows.Count);
- AssertEquals ("#A06", 0, table1.Constraints.Count);
- AssertEquals ("#A07", 0, table1.ParentRelations.Count);
+ Assert.AreEqual (0, table1.Rows.Count, "#A05");
+ Assert.AreEqual (0, table1.Constraints.Count, "#A06");
+ Assert.AreEqual (0, table1.ParentRelations.Count, "#A07");
// clear test
table.Clear ();
- AssertEquals ("#A08", 0, table.Rows.Count);
+ Assert.AreEqual (0, table.Rows.Count, "#A08");
#if NET_1_1
- AssertEquals ("#A09", 0, table.Constraints.Count);
+ Assert.AreEqual (0, table.Constraints.Count, "#A09");
#else
- AssertEquals ("#A09", 1, table.Constraints.Count);
+ Assert.AreEqual (1, table.Constraints.Count, "#A09");
#endif
- AssertEquals ("#A10", 0, table.ChildRelations.Count);
+ Assert.AreEqual (0, table.ChildRelations.Count, "#A10");
}
table.Clear ();
#if NET_2_0
- AssertEquals ("#3 should have fired cleared event", true, _tableClearingEventFired);
- AssertEquals ("#0 should have fired cleared event", true, _tableClearedEventFired);
+ Assert.IsTrue (_tableClearingEventFired, "#3 should have fired cleared event");
+ Assert.IsTrue (_tableClearedEventFired, "#0 should have fired cleared event");
#endif // NET_2_0
DataRow r = table.Rows.Find (1);
- AssertEquals ("#1 should have cleared", true, r == null);
+ Assert.IsTrue (r == null, "#1 should have cleared");
// try adding new row. indexes should have cleared
table.Rows.Add (new object [] { 2, "mono 2" });
- AssertEquals ("#2 should add row", 1, table.Rows.Count);
+ Assert.AreEqual (1, table.Rows.Count, "#2 should add row");
}
#if NET_2_0
private bool _tableClearedEventFired = false;
string TextString = writer.ToString ();
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#01", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
+ 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);
- AssertEquals ("test#02", "<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring);
+ 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");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#03", " <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring);
+ Assert.AreEqual (" <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring, "test#03");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#04", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#05", " <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring);
+ Assert.AreEqual (" <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring, "test#05");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#06", " <xs:element name=\"TestWriteXmlSchema\">", substring);
+ Assert.AreEqual (" <xs:element name=\"TestWriteXmlSchema\">", substring, "test#06");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#07", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#08", " <xs:sequence>", substring);
+ Assert.AreEqual (" <xs:sequence>", substring, "test#08");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#09", " <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring);
+ Assert.AreEqual (" <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#09");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#10", " <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring);
+ Assert.AreEqual (" <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#10");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#11", " </xs:sequence>", substring);
+ Assert.AreEqual (" </xs:sequence>", substring, "test#11");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#12", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#12");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#13", " </xs:element>", substring);
+ Assert.AreEqual (" </xs:element>", substring, "test#13");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#14", " </xs:choice>", substring);
+ Assert.AreEqual (" </xs:choice>", substring, "test#14");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#15", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#15");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#16", " </xs:element>", substring);
- AssertEquals ("test#17", "</xs:schema>", TextString);
+ Assert.AreEqual (" </xs:element>", substring, "test#16");
+ Assert.AreEqual ("</xs:schema>", TextString, "test#17");
}
[Test]
public void TestWriteXmlSchema2()
string TextString = writer.ToString ();
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#01", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
+ 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);
- AssertEquals ("test#02", "<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring);
+ 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");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#03", " <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring);
+ Assert.AreEqual (" <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring, "test#03");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#04", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#05", " <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring);
+ Assert.AreEqual (" <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring, "test#05");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#06", " <xs:element name=\"TestWriteXmlSchema\">", substring);
+ Assert.AreEqual (" <xs:element name=\"TestWriteXmlSchema\">", substring, "test#06");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#07", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#08", " <xs:sequence>", substring);
+ Assert.AreEqual (" <xs:sequence>", substring, "test#08");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#09", " <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring);
+ Assert.AreEqual (" <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#09");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#10", " <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring);
+ Assert.AreEqual (" <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#10");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#11", " </xs:sequence>", substring);
+ Assert.AreEqual (" </xs:sequence>", substring, "test#11");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#12", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#12");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#13", " </xs:element>", substring);
+ Assert.AreEqual (" </xs:element>", substring, "test#13");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#14", " </xs:choice>", substring);
+ Assert.AreEqual (" </xs:choice>", substring, "test#14");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#15", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#15");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#16", " <xs:unique name=\"Constraint1\">", substring);
+ Assert.AreEqual (" <xs:unique name=\"Constraint1\">", substring, "test#16");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#17", " <xs:selector xpath=\".//TestWriteXmlSchema\" />", substring);
+ Assert.AreEqual (" <xs:selector xpath=\".//TestWriteXmlSchema\" />", substring, "test#17");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#18", " <xs:field xpath=\"Col1\" />", substring);
+ Assert.AreEqual (" <xs:field xpath=\"Col1\" />", substring, "test#18");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#19", " </xs:unique>", substring);
+ Assert.AreEqual (" </xs:unique>", substring, "test#19");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#20", " </xs:element>", substring);
- AssertEquals ("test#21", "</xs:schema>", TextString);
+ Assert.AreEqual (" </xs:element>", substring, "test#20");
+ Assert.AreEqual ("</xs:schema>", TextString, "test#21");
}
[Test]
public void TestWriteXmlSchema3()
string TextString = writer.ToString ();
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#01", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
+ 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);
- AssertEquals ("test#02", "<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">", substring);
+ 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");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#03", " <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring);
+ Assert.AreEqual (" <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"TestWriteXmlSchema\" msdata:UseCurrentLocale=\"true\">", substring, "test#03");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#04", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#05", " <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring);
+ Assert.AreEqual (" <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">", substring, "test#05");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#06", " <xs:element name=\"TestWriteXmlSchema\">", substring);
+ Assert.AreEqual (" <xs:element name=\"TestWriteXmlSchema\">", substring, "test#06");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#07", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#08", " <xs:sequence>", substring);
+ Assert.AreEqual (" <xs:sequence>", substring, "test#08");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#09", " <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring);
+ Assert.AreEqual (" <xs:element name=\"Col1\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#09");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#10", " <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring);
+ Assert.AreEqual (" <xs:element name=\"Col2\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#10");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#11", " </xs:sequence>", substring);
+ Assert.AreEqual (" </xs:sequence>", substring, "test#11");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#12", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#12");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#13", " </xs:element>", substring);
+ Assert.AreEqual (" </xs:element>", substring, "test#13");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#14", " <xs:element name=\"HelloWorld\">", substring);
+ Assert.AreEqual (" <xs:element name=\"HelloWorld\">", substring, "test#14");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#15", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#15");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#16", " <xs:sequence>", substring);
+ Assert.AreEqual (" <xs:sequence>", substring, "test#16");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#17", " <xs:element name=\"T1\" type=\"xs:int\" minOccurs=\"0\" />", substring);
+ Assert.AreEqual (" <xs:element name=\"T1\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#17");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#18", " <xs:element name=\"T2\" type=\"xs:int\" minOccurs=\"0\" />", substring);
+ Assert.AreEqual (" <xs:element name=\"T2\" type=\"xs:int\" minOccurs=\"0\" />", substring, "test#18");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#19", " </xs:sequence>", substring);
+ Assert.AreEqual (" </xs:sequence>", substring, "test#19");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#20", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#20");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#21", " </xs:element>", substring);
+ Assert.AreEqual (" </xs:element>", substring, "test#21");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#22", " </xs:choice>", substring);
+ Assert.AreEqual (" </xs:choice>", substring, "test#22");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#23", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#23");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#24", " <xs:unique name=\"Constraint1\">", substring);
+ Assert.AreEqual (" <xs:unique name=\"Constraint1\">", substring, "test#24");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#25", " <xs:selector xpath=\".//TestWriteXmlSchema\" />", substring);
+ Assert.AreEqual (" <xs:selector xpath=\".//TestWriteXmlSchema\" />", substring, "test#25");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#26", " <xs:field xpath=\"Col1\" />", substring);
+ Assert.AreEqual (" <xs:field xpath=\"Col1\" />", substring, "test#26");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#27", " </xs:unique>", substring);
+ Assert.AreEqual (" </xs:unique>", substring, "test#27");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#28", " <xs:keyref name=\"Relation1\" refer=\"Constraint1\">", substring);
+ Assert.AreEqual (" <xs:keyref name=\"Relation1\" refer=\"Constraint1\">", substring, "test#28");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#29", " <xs:selector xpath=\".//HelloWorld\" />", substring);
+ Assert.AreEqual (" <xs:selector xpath=\".//HelloWorld\" />", substring, "test#29");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#30", " <xs:field xpath=\"T1\" />", substring);
+ Assert.AreEqual (" <xs:field xpath=\"T1\" />", substring, "test#30");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#31", " </xs:keyref>", substring);
+ Assert.AreEqual (" </xs:keyref>", substring, "test#31");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("test#32", " </xs:element>", substring);
- AssertEquals ("test#33", "</xs:schema>", TextString);
+ Assert.AreEqual (" </xs:element>", substring, "test#32");
+ Assert.AreEqual ("</xs:schema>", TextString, "test#33");
}
#endif
[Test]
ds.WriteXml(sw);
XmlDocument doc = new XmlDocument ();
doc.LoadXml (sw.ToString ());
- AssertEquals (5, doc.DocumentElement.FirstChild.ChildNodes.Count);
+ Assert.AreEqual (5, doc.DocumentElement.FirstChild.ChildNodes.Count);
}
[Test]
DataColumn col1 = table.Columns.Add ("col1", typeof (int));
DataColumn col2 = table.Columns.Add ("col2", typeof (int));
- AssertEquals ("#1" , true, col1.AllowDBNull);
- AssertEquals ("#2" , true, col2.AllowDBNull);
- AssertEquals ("#3" , false, col2.Unique);
- AssertEquals ("#4" , false, col2.Unique);
+ Assert.IsTrue (col1.AllowDBNull, "#1" );
+ Assert.IsTrue (col2.AllowDBNull, "#2" );
+ Assert.IsFalse (col2.Unique, "#3" );
+ Assert.IsFalse (col2.Unique, "#4" );
table.PrimaryKey = new DataColumn[] {col1,col2};
- AssertEquals ("#5" , false, col1.AllowDBNull);
- AssertEquals ("#6" , false, col2.AllowDBNull);
+ Assert.IsFalse (col1.AllowDBNull, "#5" );
+ Assert.IsFalse (col2.AllowDBNull, "#6" );
// LAMESPEC or bug ??
- AssertEquals ("#7" , false, col1.Unique);
- AssertEquals ("#8" , false, col2.Unique);
+ Assert.IsFalse (col1.Unique, "#7" );
+ Assert.IsFalse (col2.Unique, "#8" );
}
void RowChanging (object o, DataRowChangeEventArgs e)
{
- AssertEquals ("changing.Action", rowChangingExpectedAction, e.Action);
+ Assert.AreEqual (rowChangingExpectedAction, e.Action, "changing.Action");
rowChangingRowChanging = true;
}
void RowChanged (object o, DataRowChangeEventArgs e)
{
- AssertEquals ("changed.Action", rowChangingExpectedAction, e.Action);
+ Assert.AreEqual (rowChangingExpectedAction, e.Action, "changed.Action");
rowChangingRowChanged = true;
}
dt.RowChanged += new DataRowChangeEventHandler (RowChanged);
rowChangingExpectedAction = DataRowAction.Add;
dt.Rows.Add (new object [] {1, 2});
- Assert ("changing,Added", rowChangingRowChanging);
- Assert ("changed,Added", rowChangingRowChanged);
+ Assert.IsTrue (rowChangingRowChanging, "changing,Added");
+ Assert.IsTrue (rowChangingRowChanged, "changed,Added");
rowChangingExpectedAction = DataRowAction.Change;
dt.Rows [0] [0] = 2;
- Assert ("changing,Changed", rowChangingRowChanging);
- Assert ("changed,Changed", rowChangingRowChanged);
+ Assert.IsTrue (rowChangingRowChanging, "changing,Changed");
+ Assert.IsTrue (rowChangingRowChanged, "changed,Changed");
}
[Test]
{
MyDataTable dt1 = new MyDataTable();
MyDataTable dt = (MyDataTable)(dt1.Clone());
- AssertEquals("A#01",2,MyDataTable.count);
+ Assert.AreEqual (2, MyDataTable.count, "A#01");
}
DataRowAction rowActionChanging = DataRowAction.Nothing;
rowActionChanged = rowActionChanging = DataRowAction.Nothing;
dt.AcceptChanges ();
- AssertEquals ("#1 should have fired event and set action to commit",
- DataRowAction.Commit, rowActionChanging);
- AssertEquals ("#2 should have fired event and set action to commit",
- DataRowAction.Commit, rowActionChanged);
+ Assert.AreEqual (DataRowAction.Commit, rowActionChanging,
+ "#1 should have fired event and set action to commit");
+ Assert.AreEqual (DataRowAction.Commit, rowActionChanged,
+ "#2 should have fired event and set action to commit");
} finally {
dt.RowChanged -= new DataRowChangeEventHandler (OnRowChanged);
DataTable dt = new DataTable();
dt.Columns.Add("Series Label", typeof(SqlInt32));
dt.Rows.Add(new object[] {"sss"});
- AssertEquals(1, dt.Rows.Count);
+ Assert.AreEqual (1, dt.Rows.Count);
}
#if NET_2_0
dt.Initialized += new EventHandler (OnTableInitialized);
dt.Columns.Add("Series Label", typeof(SqlInt32));
dt.Rows.Add(new object[] {"sss"});
- AssertEquals("TableInitialized #01", tableInitialized, false);
+ Assert.IsFalse (tableInitialized, "TableInitialized #01");
dt.Initialized -= new EventHandler (OnTableInitialized);
}
[Test]
dt.Rows.Add(new object[] {"sss"});
dt.EndInit ();
dt.Initialized -= new EventHandler (OnTableInitialized);
- AssertEquals("TableInitialized #02", tableInitialized, true);
+ Assert.IsTrue (tableInitialized, "TableInitialized #02");
}
[Test]
public void TableInitializedEventTest3 () {
dt.Initialized += new EventHandler (OnTableInitialized);
dt.Columns.Add("Series Label", typeof(SqlInt32));
dt.Rows.Add(new object[] {"sss"});
- AssertEquals("TableInitialized #03", tableInitialized, dt.IsInitialized);
+ Assert.AreEqual (tableInitialized, dt.IsInitialized, "TableInitialized #03");
dt.Initialized -= new EventHandler (OnTableInitialized);
}
[Test]
public void TableInitializedEventTest4 () {
DataTable dt = new DataTable();
- AssertEquals("TableInitialized #04", true, dt.IsInitialized);
+ Assert.IsTrue (dt.IsInitialized, "TableInitialized #04");
dt.BeginInit ();
tableInitialized = false;
dt.Initialized += new EventHandler (OnTableInitialized);
dt.Columns.Add("Series Label", typeof(SqlInt32));
dt.Rows.Add(new object[] {"sss"});
- AssertEquals("TableInitialized #05", false, dt.IsInitialized);
+ Assert.IsFalse (dt.IsInitialized, "TableInitialized #05");
dt.EndInit ();
NUnit.Framework.Assert.IsTrue (dt.IsInitialized, "TableInitialized #06");
NUnit.Framework.Assert.IsTrue (tableInitialized, "TableInitialized #07");
public void CreateDataReader1 () {
localSetup ();
DataTableReader dtr = dt.CreateDataReader ();
- Assert ("HasRows", dtr.HasRows);
- AssertEquals ("CountCols", dt.Columns.Count, dtr.FieldCount);
+ Assert.IsTrue (dtr.HasRows, "HasRows");
+ Assert.AreEqual (dt.Columns.Count, dtr.FieldCount, "CountCols");
int ri = 0;
while (dtr.Read ()) {
for (int i = 0; i < dtr.FieldCount; i++) {
- AssertEquals ("RowData-" + ri + "-" + i, dt.Rows[ri][i],
- dtr[i]);
+ Assert.AreEqual (dt.Rows[ri][i], dtr[i], "RowData-" + ri + "-" + i);
}
ri++;
}
public void CreateDataReader2 () {
localSetup ();
DataTableReader dtr = dt.CreateDataReader ();
- Assert ("HasRows", dtr.HasRows);
- AssertEquals ("CountCols", dt.Columns.Count, dtr.FieldCount);
+ Assert.IsTrue (dtr.HasRows, "HasRows");
+ Assert.AreEqual (dt.Columns.Count, dtr.FieldCount, "CountCols");
dtr.Read ();
- AssertEquals ("RowData0-0", 1, dtr[0]);
- AssertEquals ("RowData0-1", "mono 1", dtr[1]);
+ Assert.AreEqual (1, dtr[0], "RowData0-0");
+ Assert.AreEqual ("mono 1", dtr[1], "RowData0-1");
dtr.Read ();
- AssertEquals ("RowData1-0", 2, dtr[0]);
- AssertEquals ("RowData1-1", "mono 2", dtr[1]);
+ Assert.AreEqual (2, dtr[0], "RowData1-0");
+ Assert.AreEqual ("mono 2", dtr[1], "RowData1-1");
dtr.Read ();
- AssertEquals ("RowData2-0", 3, dtr[0]);
- AssertEquals ("RowData2-1", "mono 3", dtr[1]);
+ Assert.AreEqual (3, dtr[0], "RowData2-0");
+ Assert.AreEqual ("mono 3", dtr[1], "RowData2-1");
}
#endregion // DataTable.CreateDataReader Tests
dtLoad.AcceptChanges ();
DataTableReader dtr = dt.CreateDataReader ();
dtLoad.Load (dtr);
- AssertEquals ("NColumns", 2, dtLoad.Columns.Count);
- AssertEquals ("NRows", 3, dtLoad.Rows.Count);
- AssertEquals ("RowData0-0", 1, dtLoad.Rows[0][0]);
- AssertEquals ("RowData0-1", "mono 1", dtLoad.Rows[0][1]);
- AssertEquals ("RowData1-0", 2, dtLoad.Rows[1][0]);
- AssertEquals ("RowData1-1", "mono 2", dtLoad.Rows[1][1]);
- AssertEquals ("RowData2-0", 3, dtLoad.Rows[2][0]);
- AssertEquals ("RowData2-1", "mono 3", dtLoad.Rows[2][1]);
+ Assert.AreEqual (2, dtLoad.Columns.Count, "NColumns");
+ Assert.AreEqual (3, dtLoad.Rows.Count, "NRows");
+ Assert.AreEqual (1, dtLoad.Rows[0][0], "RowData0-0");
+ Assert.AreEqual ("mono 1", dtLoad.Rows[0][1], "RowData0-1");
+ Assert.AreEqual (2, dtLoad.Rows[1][0], "RowData1-0");
+ Assert.AreEqual ("mono 2", dtLoad.Rows[1][1], "RowData1-1");
+ Assert.AreEqual (3, dtLoad.Rows[2][0], "RowData2-0");
+ Assert.AreEqual ("mono 3", dtLoad.Rows[2][1], "RowData2-1");
}
[Test]
DataTable dtLoad = new DataTable ("LoadNoSchema");
DataTableReader dtr = dt.CreateDataReader ();
dtLoad.Load (dtr);
- AssertEquals ("NColumns", 2, dtLoad.Columns.Count);
- AssertEquals ("NRows", 3, dtLoad.Rows.Count);
- AssertEquals ("RowData0-0", 1, dtLoad.Rows[0][0]);
- AssertEquals ("RowData0-1", "mono 1", dtLoad.Rows[0][1]);
- AssertEquals ("RowData1-0", 2, dtLoad.Rows[1][0]);
- AssertEquals ("RowData1-1", "mono 2", dtLoad.Rows[1][1]);
- AssertEquals ("RowData2-0", 3, dtLoad.Rows[2][0]);
- AssertEquals ("RowData2-1", "mono 3", dtLoad.Rows[2][1]);
+ Assert.AreEqual (2, dtLoad.Columns.Count, "NColumns");
+ Assert.AreEqual (3, dtLoad.Rows.Count, "NRows");
+ Assert.AreEqual (1, dtLoad.Rows[0][0], "RowData0-0");
+ Assert.AreEqual ("mono 1", dtLoad.Rows[0][1], "RowData0-1");
+ Assert.AreEqual (2, dtLoad.Rows[1][0], "RowData1-0");
+ Assert.AreEqual ("mono 2", dtLoad.Rows[1][1], "RowData1-1");
+ Assert.AreEqual (3, dtLoad.Rows[2][0], "RowData2-0");
+ Assert.AreEqual ("mono 3", dtLoad.Rows[2][1], "RowData2-1");
}
internal struct fillErrorStruct {
private int fillErrCounter;
private void fillErrorHandler (object sender, FillErrorEventArgs e) {
e.Continue = fillErr[fillErrCounter].contFlag;
- AssertEquals ("fillErr-T", fillErr[fillErrCounter].tableName, e.DataTable.TableName);
- //AssertEquals ("fillErr-R", fillErr[fillErrCounter].rowKey, e.Values[0]);
- AssertEquals ("fillErr-C", fillErr[fillErrCounter].contFlag, e.Continue);
- //AssertEquals ("fillErr-E", fillErr[fillErrCounter].error, e.Errors.Message);
+ Assert.AreEqual (fillErr[fillErrCounter].tableName, e.DataTable.TableName, "fillErr-T");
+ //Assert.AreEqual (fillErr[fillErrCounter].rowKey, e.Values[0], "fillErr-R");
+ Assert.AreEqual (fillErr[fillErrCounter].contFlag, e.Continue, "fillErr-C");
+ //Assert.AreEqual (fillErr[fillErrCounter].error, e.Errors.Message, "fillErr-E");
fillErrCounter++;
}
dtLoad.AcceptChanges ();
DataTableReader dtr = dt.CreateDataReader ();
dtLoad.Load (dtr);
- AssertEquals ("NColumns", 2, dtLoad.Columns.Count);
- AssertEquals ("NRows", 3, dtLoad.Rows.Count);
- AssertEquals ("RowData0-0", 1, dtLoad.Rows[0][0]);
- AssertEquals ("RowData0-1", "mono 1", dtLoad.Rows[0][1]);
- AssertEquals ("RowData1-0", 2, dtLoad.Rows[1][0]);
- AssertEquals ("RowData1-1", "mono 2", dtLoad.Rows[1][1]);
- AssertEquals ("RowData2-0", 3, dtLoad.Rows[2][0]);
- AssertEquals ("RowData2-1", "mono 3", dtLoad.Rows[2][1]);
+ Assert.AreEqual (2, dtLoad.Columns.Count, "NColumns");
+ Assert.AreEqual (3, dtLoad.Rows.Count, "NRows");
+ Assert.AreEqual (1, dtLoad.Rows[0][0], "RowData0-0");
+ Assert.AreEqual ("mono 1", dtLoad.Rows[0][1], "RowData0-1");
+ Assert.AreEqual (2, dtLoad.Rows[1][0], "RowData1-0");
+ Assert.AreEqual ("mono 2", dtLoad.Rows[1][1], "RowData1-1");
+ Assert.AreEqual (3, dtLoad.Rows[2][0], "RowData2-0");
+ Assert.AreEqual ("mono 3", dtLoad.Rows[2][1], "RowData2-1");
}
[Test]
dtLoad.AcceptChanges ();
DataTableReader dtr = dt.CreateDataReader ();
dtLoad.Load (dtr);
- AssertEquals ("NColumns", 2, dtLoad.Columns.Count);
- AssertEquals ("NRows", 6, dtLoad.Rows.Count);
- AssertEquals ("RowData0-0", 4, dtLoad.Rows[0][0]);
- AssertEquals ("RowData1-0", 5, dtLoad.Rows[1][0]);
- AssertEquals ("RowData2-0", 6, dtLoad.Rows[2][0]);
- AssertEquals ("RowData3-0", 1, dtLoad.Rows[3][0]);
- AssertEquals ("RowData3-1", "mono 1", dtLoad.Rows[3][1]);
- AssertEquals ("RowData4-0", 2, dtLoad.Rows[4][0]);
- AssertEquals ("RowData4-1", "mono 2", dtLoad.Rows[4][1]);
- AssertEquals ("RowData5-0", 3, dtLoad.Rows[5][0]);
- AssertEquals ("RowData5-1", "mono 3", dtLoad.Rows[5][1]);
+ Assert.AreEqual (2, dtLoad.Columns.Count, "NColumns");
+ Assert.AreEqual (6, dtLoad.Rows.Count, "NRows");
+ Assert.AreEqual (4, dtLoad.Rows[0][0], "RowData0-0");
+ Assert.AreEqual (5, dtLoad.Rows[1][0], "RowData1-0");
+ Assert.AreEqual (6, dtLoad.Rows[2][0], "RowData2-0");
+ Assert.AreEqual (1, dtLoad.Rows[3][0], "RowData3-0");
+ Assert.AreEqual ("mono 1", dtLoad.Rows[3][1], "RowData3-1");
+ Assert.AreEqual (2, dtLoad.Rows[4][0], "RowData4-0");
+ Assert.AreEqual ("mono 2", dtLoad.Rows[4][1], "RowData4-1");
+ Assert.AreEqual (3, dtLoad.Rows[5][0], "RowData5-0");
+ Assert.AreEqual ("mono 3", dtLoad.Rows[5][1], "RowData5-1");
}
[Test]
dtLoad.AcceptChanges ();
DataTableReader dtr = dt.CreateDataReader ();
dtLoad.Load (dtr);
- AssertEquals ("NColumns", 3, dtLoad.Columns.Count);
- AssertEquals ("NRows", 6, dtLoad.Rows.Count);
- AssertEquals ("RowData0-0", 4, dtLoad.Rows[0][0]);
- AssertEquals ("RowData0-1", "mono 4", dtLoad.Rows[0][1]);
- AssertEquals ("RowData0-2", "miss4", dtLoad.Rows[0][2]);
- AssertEquals ("RowData1-0", 5, dtLoad.Rows[1][0]);
- AssertEquals ("RowData1-1", "mono 5", dtLoad.Rows[1][1]);
- AssertEquals ("RowData1-2", "miss5", dtLoad.Rows[1][2]);
- AssertEquals ("RowData2-0", 6, dtLoad.Rows[2][0]);
- AssertEquals ("RowData2-1", "mono 6", dtLoad.Rows[2][1]);
- AssertEquals ("RowData2-2", "miss6", dtLoad.Rows[2][2]);
- AssertEquals ("RowData3-0", 1, dtLoad.Rows[3][0]);
- AssertEquals ("RowData3-1", "mono 1", dtLoad.Rows[3][1]);
- AssertEquals ("RowData3-2", "DefaultValue", dtLoad.Rows[3][2]);
- AssertEquals ("RowData4-0", 2, dtLoad.Rows[4][0]);
- AssertEquals ("RowData4-1", "mono 2", dtLoad.Rows[4][1]);
- AssertEquals ("RowData4-2", "DefaultValue", dtLoad.Rows[4][2]);
- AssertEquals ("RowData5-0", 3, dtLoad.Rows[5][0]);
- AssertEquals ("RowData5-1", "mono 3", dtLoad.Rows[5][1]);
- AssertEquals ("RowData5-2", "DefaultValue", dtLoad.Rows[5][2]);
+ Assert.AreEqual (3, dtLoad.Columns.Count, "NColumns");
+ Assert.AreEqual (6, dtLoad.Rows.Count, "NRows");
+ Assert.AreEqual (4, dtLoad.Rows[0][0], "RowData0-0");
+ Assert.AreEqual ("mono 4", dtLoad.Rows[0][1], "RowData0-1");
+ Assert.AreEqual ("miss4", dtLoad.Rows[0][2], "RowData0-2");
+ Assert.AreEqual (5, dtLoad.Rows[1][0], "RowData1-0");
+ Assert.AreEqual ("mono 5", dtLoad.Rows[1][1], "RowData1-1");
+ Assert.AreEqual ("miss5", dtLoad.Rows[1][2], "RowData1-2");
+ Assert.AreEqual (6, dtLoad.Rows[2][0], "RowData2-0");
+ Assert.AreEqual ("mono 6", dtLoad.Rows[2][1], "RowData2-1");
+ Assert.AreEqual ("miss6", dtLoad.Rows[2][2], "RowData2-2");
+ Assert.AreEqual (1, dtLoad.Rows[3][0], "RowData3-0");
+ Assert.AreEqual ("mono 1", dtLoad.Rows[3][1], "RowData3-1");
+ Assert.AreEqual ("DefaultValue", dtLoad.Rows[3][2], "RowData3-2");
+ Assert.AreEqual (2, dtLoad.Rows[4][0], "RowData4-0");
+ Assert.AreEqual ("mono 2", dtLoad.Rows[4][1], "RowData4-1");
+ Assert.AreEqual ("DefaultValue", dtLoad.Rows[4][2], "RowData4-2");
+ Assert.AreEqual (3, dtLoad.Rows[5][0], "RowData5-0");
+ Assert.AreEqual ("mono 3", dtLoad.Rows[5][1], "RowData5-1");
+ Assert.AreEqual ("DefaultValue", dtLoad.Rows[5][2], "RowData5-2");
}
[Test]
dtLoad.AcceptChanges ();
DataTableReader dtr = dt.CreateDataReader ();
dtLoad.Load (dtr);
- AssertEquals ("NColumns", 3, dtLoad.Columns.Count);
- AssertEquals ("NRows", 6, dtLoad.Rows.Count);
- AssertEquals ("RowData0-0", 4, dtLoad.Rows[0][0]);
- AssertEquals ("RowData0-1", "mono 4", dtLoad.Rows[0][1]);
- AssertEquals ("RowData0-2", "miss4", dtLoad.Rows[0][2]);
- AssertEquals ("RowData1-0", 5, dtLoad.Rows[1][0]);
- AssertEquals ("RowData1-1", "mono 5", dtLoad.Rows[1][1]);
- AssertEquals ("RowData1-2", "miss5", dtLoad.Rows[1][2]);
- AssertEquals ("RowData2-0", 6, dtLoad.Rows[2][0]);
- AssertEquals ("RowData2-1", "mono 6", dtLoad.Rows[2][1]);
- AssertEquals ("RowData2-2", "miss6", dtLoad.Rows[2][2]);
- AssertEquals ("RowData3-0", 1, dtLoad.Rows[3][0]);
- AssertEquals ("RowData3-1", "mono 1", dtLoad.Rows[3][1]);
- //AssertEquals ("RowData3-2", null, dtLoad.Rows[3][2]);
- AssertEquals ("RowData4-0", 2, dtLoad.Rows[4][0]);
- AssertEquals ("RowData4-1", "mono 2", dtLoad.Rows[4][1]);
- //AssertEquals ("RowData4-2", null, dtLoad.Rows[4][2]);
- AssertEquals ("RowData5-0", 3, dtLoad.Rows[5][0]);
- AssertEquals ("RowData5-1", "mono 3", dtLoad.Rows[5][1]);
- //AssertEquals ("RowData5-2", null, dtLoad.Rows[5][2]);
+ Assert.AreEqual (3, dtLoad.Columns.Count, "NColumns");
+ Assert.AreEqual (6, dtLoad.Rows.Count, "NRows");
+ Assert.AreEqual (4, dtLoad.Rows[0][0], "RowData0-0");
+ Assert.AreEqual ("mono 4", dtLoad.Rows[0][1], "RowData0-1");
+ Assert.AreEqual ("miss4", dtLoad.Rows[0][2], "RowData0-2");
+ Assert.AreEqual (5, dtLoad.Rows[1][0], "RowData1-0");
+ Assert.AreEqual ("mono 5", dtLoad.Rows[1][1], "RowData1-1");
+ Assert.AreEqual ("miss5", dtLoad.Rows[1][2], "RowData1-2");
+ Assert.AreEqual (6, dtLoad.Rows[2][0], "RowData2-0");
+ Assert.AreEqual ("mono 6", dtLoad.Rows[2][1], "RowData2-1");
+ Assert.AreEqual ("miss6", dtLoad.Rows[2][2], "RowData2-2");
+ Assert.AreEqual (1, dtLoad.Rows[3][0], "RowData3-0");
+ Assert.AreEqual ("mono 1", dtLoad.Rows[3][1], "RowData3-1");
+ //Assert.IsNull (dtLoad.Rows[3][2], "RowData3-2");
+ Assert.AreEqual (2, dtLoad.Rows[4][0], "RowData4-0");
+ Assert.AreEqual ("mono 2", dtLoad.Rows[4][1], "RowData4-1");
+ //Assert.IsNull (dtLoad.Rows[4][2], "RowData4-2");
+ Assert.AreEqual (3, dtLoad.Rows[5][0], "RowData5-0");
+ Assert.AreEqual ("mono 3", dtLoad.Rows[5][1], "RowData5-1");
+ //Assert.IsNull (dtLoad.Rows[5][2], "RowData5-2");
}
private DataTable setupRowState () {
}
private void dtLoad_RowChanged (object sender, DataRowChangeEventArgs e) {
if (checkAction) {
- AssertEquals ("RowChanged" + rowChagedCounter,
- rowChangeAction[rowChagedCounter], e.Action);
+ Assert.AreEqual (rowChangeAction[rowChagedCounter], e.Action, "RowChanged" + rowChagedCounter);
rowChagedCounter++;
}
}
private void dtLoad_RowChanging (object sender, DataRowChangeEventArgs e) {
if (checkAction) {
- AssertEquals ("RowChanging" + rowChangingCounter,
- rowChangeAction[rowChangingCounter], e.Action);
+ Assert.AreEqual (rowChangeAction[rowChangingCounter], e.Action, "RowChanging" + rowChangingCounter);
rowChangingCounter++;
}
}
dtLoad.Load (dtr);
rowActionEnd ();
// asserting Unchanged Row0
- AssertEquals ("RowData0-C", "mono 1",
- dtLoad.Rows[0][1,DataRowVersion.Current]);
- AssertEquals ("RowData0-O", "mono 1",
- dtLoad.Rows[0][1,DataRowVersion.Original]);
- AssertEquals ("RowState0", DataRowState.Unchanged,
- dtLoad.Rows[0].RowState);
+ Assert.AreEqual ("mono 1", dtLoad.Rows[0][1,DataRowVersion.Current], "RowData0-C");
+ Assert.AreEqual ("mono 1", dtLoad.Rows[0][1,DataRowVersion.Original], "RowData0-O");
+ Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[0].RowState, "RowState0");
// asserting Modified Row1
- AssertEquals ("RowData1-C", "Modify 2",
- dtLoad.Rows[1][1, DataRowVersion.Current]);
- AssertEquals ("RowData1-O", "mono 2",
- dtLoad.Rows[1][1, DataRowVersion.Original]);
- AssertEquals ("RowState1", DataRowState.Modified,
- dtLoad.Rows[1].RowState);
+ Assert.AreEqual ("Modify 2", dtLoad.Rows[1][1, DataRowVersion.Current], "RowData1-C");
+ Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Original], "RowData1-O");
+ Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[1].RowState, "RowState1");
// asserting Deleted Row2
- AssertEquals ("RowData1-O", "mono 3",
- dtLoad.Rows[2][1, DataRowVersion.Original]);
- AssertEquals ("RowState2", DataRowState.Deleted,
- dtLoad.Rows[2].RowState);
+ Assert.AreEqual ("mono 3", dtLoad.Rows[2][1, DataRowVersion.Original], "RowData1-O");
+ Assert.AreEqual (DataRowState.Deleted, dtLoad.Rows[2].RowState, "RowState2");
// asserting Added Row3
- AssertEquals ("RowData3-C", "Add 4",
- dtLoad.Rows[3][1, DataRowVersion.Current]);
- AssertEquals ("RowData3-O", "mono 4",
- dtLoad.Rows[3][1, DataRowVersion.Original]);
- AssertEquals ("RowState3", DataRowState.Modified,
- dtLoad.Rows[3].RowState);
+ Assert.AreEqual ("Add 4", dtLoad.Rows[3][1, DataRowVersion.Current], "RowData3-C");
+ Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
+ Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[3].RowState, "RowState3");
// asserting Unpresent Row4
- AssertEquals ("RowData4-C", "mono 5",
- dtLoad.Rows[4][1, DataRowVersion.Current]);
- AssertEquals ("RowData4-O", "mono 5",
- dtLoad.Rows[4][1, DataRowVersion.Original]);
- AssertEquals ("RowState4", DataRowState.Unchanged,
- dtLoad.Rows[4].RowState);
+ Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Current], "RowData4-C");
+ Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Original], "RowData4-O");
+ Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[4].RowState, "RowState4");
}
[Test]
dtLoad.Rows[2].Delete ();
DataTableReader dtr = dt.CreateDataReader ();
dtLoad.Load (dtr);
- AssertEquals ("RowData2-C", " ",
- dtLoad.Rows[2][1, DataRowVersion.Current]);
+ Assert.AreEqual (" ", dtLoad.Rows[2][1, DataRowVersion.Current], "RowData2-C");
}
[Test]
dtLoad.Load (dtr, LoadOption.PreserveChanges);
rowActionEnd ();
// asserting Unchanged Row0
- AssertEquals ("RowData0-C", "mono 1",
- dtLoad.Rows[0][1, DataRowVersion.Current]);
- AssertEquals ("RowData0-O", "mono 1",
- dtLoad.Rows[0][1, DataRowVersion.Original]);
- AssertEquals ("RowState0", DataRowState.Unchanged,
- dtLoad.Rows[0].RowState);
+ Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Current], "RowData0-C");
+ Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Original], "RowData0-O");
+ Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[0].RowState, "RowState0");
// asserting Modified Row1
- AssertEquals ("RowData1-C", "Modify 2",
- dtLoad.Rows[1][1, DataRowVersion.Current]);
- AssertEquals ("RowData1-O", "mono 2",
- dtLoad.Rows[1][1, DataRowVersion.Original]);
- AssertEquals ("RowState1", DataRowState.Modified,
- dtLoad.Rows[1].RowState);
+ Assert.AreEqual ("Modify 2", dtLoad.Rows[1][1, DataRowVersion.Current], "RowData1-C");
+ Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Original], "RowData1-O");
+ Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[1].RowState, "RowState1");
// asserting Deleted Row2
- AssertEquals ("RowData1-O", "mono 3",
- dtLoad.Rows[2][1, DataRowVersion.Original]);
- AssertEquals ("RowState2", DataRowState.Deleted,
- dtLoad.Rows[2].RowState);
+ Assert.AreEqual ("mono 3", dtLoad.Rows[2][1, DataRowVersion.Original], "RowData1-O");
+ Assert.AreEqual (DataRowState.Deleted, dtLoad.Rows[2].RowState, "RowState2");
// asserting Added Row3
- AssertEquals ("RowData3-C", "Add 4",
- dtLoad.Rows[3][1, DataRowVersion.Current]);
- AssertEquals ("RowData3-O", "mono 4",
- dtLoad.Rows[3][1, DataRowVersion.Original]);
- AssertEquals ("RowState3", DataRowState.Modified,
- dtLoad.Rows[3].RowState);
+ Assert.AreEqual ("Add 4", dtLoad.Rows[3][1, DataRowVersion.Current], "RowData3-C");
+ Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
+ Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[3].RowState, "RowState3");
// asserting Unpresent Row4
- AssertEquals ("RowData4-C", "mono 5",
- dtLoad.Rows[4][1, DataRowVersion.Current]);
- AssertEquals ("RowData4-O", "mono 5",
- dtLoad.Rows[4][1, DataRowVersion.Original]);
- AssertEquals ("RowState4", DataRowState.Unchanged,
- dtLoad.Rows[4].RowState);
+ Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Current], "RowData4-C");
+ Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Original], "RowData4-O");
+ Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[4].RowState, "RowState4");
}
[Test]
dtLoad.Rows[2].Delete ();
DataTableReader dtr = dt.CreateDataReader ();
dtLoad.Load (dtr,LoadOption.PreserveChanges);
- AssertEquals ("RowData2-C", " ",
- dtLoad.Rows[2][1, DataRowVersion.Current]);
+ Assert.AreEqual (" ", dtLoad.Rows[2][1, DataRowVersion.Current], "RowData2-C");
}
[Test]
dtLoad.Load (dtr, LoadOption.OverwriteChanges);
rowActionEnd ();
// asserting Unchanged Row0
- AssertEquals ("RowData0-C", "mono 1",
- dtLoad.Rows[0][1, DataRowVersion.Current]);
- AssertEquals ("RowData0-O", "mono 1",
- dtLoad.Rows[0][1, DataRowVersion.Original]);
- AssertEquals ("RowState0", DataRowState.Unchanged,
- dtLoad.Rows[0].RowState);
+ Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Current], "RowData0-C");
+ Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Original], "RowData0-O");
+ Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[0].RowState, "RowState0");
// asserting Modified Row1
- AssertEquals ("RowData1-C", "mono 2",
- dtLoad.Rows[1][1, DataRowVersion.Current]);
- AssertEquals ("RowData1-O", "mono 2",
- dtLoad.Rows[1][1, DataRowVersion.Original]);
- AssertEquals ("RowState1", DataRowState.Unchanged,
- dtLoad.Rows[1].RowState);
+ Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Current], "RowData1-C");
+ Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Original], "RowData1-O");
+ Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[1].RowState, "RowState1");
// asserting Deleted Row2
- AssertEquals ("RowData1-C", "mono 3",
- dtLoad.Rows[2][1, DataRowVersion.Current]);
- AssertEquals ("RowData1-O", "mono 3",
- dtLoad.Rows[2][1, DataRowVersion.Original]);
- AssertEquals ("RowState2", DataRowState.Unchanged,
- dtLoad.Rows[2].RowState);
+ Assert.AreEqual ("mono 3", dtLoad.Rows[2][1, DataRowVersion.Current], "RowData1-C");
+ Assert.AreEqual ("mono 3", dtLoad.Rows[2][1, DataRowVersion.Original], "RowData1-O");
+ Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[2].RowState, "RowState2");
// asserting Added Row3
- AssertEquals ("RowData3-C", "mono 4",
- dtLoad.Rows[3][1, DataRowVersion.Current]);
- AssertEquals ("RowData3-O", "mono 4",
- dtLoad.Rows[3][1, DataRowVersion.Original]);
- AssertEquals ("RowState3", DataRowState.Unchanged,
- dtLoad.Rows[3].RowState);
+ Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Current], "RowData3-C");
+ Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
+ Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[3].RowState, "RowState3");
// asserting Unpresent Row4
- AssertEquals ("RowData4-C", "mono 5",
- dtLoad.Rows[4][1, DataRowVersion.Current]);
- AssertEquals ("RowData4-O", "mono 5",
- dtLoad.Rows[4][1, DataRowVersion.Original]);
- AssertEquals ("RowState4", DataRowState.Unchanged,
- dtLoad.Rows[4].RowState);
+ Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Current], "RowData4-C");
+ Assert.AreEqual ("mono 5", dtLoad.Rows[4][1, DataRowVersion.Original], "RowData4-O");
+ Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[4].RowState, "RowState4");
}
[Test]
dtLoad.Load (dtr, LoadOption.Upsert);
rowActionEnd ();
// asserting Unchanged Row0
- AssertEquals ("RowData0-C", "mono 1",
- dtLoad.Rows[0][1, DataRowVersion.Current]);
- AssertEquals ("RowData0-O", "RowState 1",
- dtLoad.Rows[0][1, DataRowVersion.Original]);
- AssertEquals ("RowState0", DataRowState.Modified,
- dtLoad.Rows[0].RowState);
+ Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Current], "RowData0-C");
+ Assert.AreEqual ("RowState 1", dtLoad.Rows[0][1, DataRowVersion.Original], "RowData0-O");
+ Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[0].RowState, "RowState0");
// asserting Modified Row1
- AssertEquals ("RowData1-C", "mono 2",
- dtLoad.Rows[1][1, DataRowVersion.Current]);
- AssertEquals ("RowData1-O", "RowState 2",
- dtLoad.Rows[1][1, DataRowVersion.Original]);
- AssertEquals ("RowState1", DataRowState.Modified,
- dtLoad.Rows[1].RowState);
+ Assert.AreEqual ("mono 2", dtLoad.Rows[1][1, DataRowVersion.Current], "RowData1-C");
+ Assert.AreEqual ("RowState 2", dtLoad.Rows[1][1, DataRowVersion.Original], "RowData1-O");
+ Assert.AreEqual (DataRowState.Modified, dtLoad.Rows[1].RowState, "RowState1");
// asserting Deleted Row2 and "Deleted-Added" Row4
- AssertEquals ("RowData2-O", "RowState 3",
- dtLoad.Rows[2][1, DataRowVersion.Original]);
- AssertEquals ("RowState2", DataRowState.Deleted,
- dtLoad.Rows[2].RowState);
- AssertEquals ("RowData4-C", "mono 3",
- dtLoad.Rows[4][1, DataRowVersion.Current]);
- AssertEquals ("RowState4", DataRowState.Added,
- dtLoad.Rows[4].RowState);
+ Assert.AreEqual ("RowState 3", dtLoad.Rows[2][1, DataRowVersion.Original], "RowData2-O");
+ Assert.AreEqual (DataRowState.Deleted, dtLoad.Rows[2].RowState, "RowState2");
+ Assert.AreEqual ("mono 3", dtLoad.Rows[4][1, DataRowVersion.Current], "RowData4-C");
+ Assert.AreEqual (DataRowState.Added, dtLoad.Rows[4].RowState, "RowState4");
// asserting Added Row3
- AssertEquals ("RowData3-C", "mono 4",
- dtLoad.Rows[3][1, DataRowVersion.Current]);
- AssertEquals ("RowState3", DataRowState.Added,
- dtLoad.Rows[3].RowState);
+ Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Current], "RowData3-C");
+ Assert.AreEqual (DataRowState.Added, dtLoad.Rows[3].RowState, "RowState3");
// asserting Unpresent Row5
// Notice row4 is used for added row of deleted row2 and so
// unpresent row4 moves to row5
- AssertEquals ("RowData5-C", "mono 5",
- dtLoad.Rows[5][1, DataRowVersion.Current]);
- AssertEquals ("RowState5", DataRowState.Added,
- dtLoad.Rows[5].RowState);
+ Assert.AreEqual ("mono 5", dtLoad.Rows[5][1, DataRowVersion.Current], "RowData5-C");
+ Assert.AreEqual (DataRowState.Added, dtLoad.Rows[5].RowState, "RowState5");
}
[Test]
DataTableReader dtr = dt.CreateDataReader ();
dtLoad.Load (dtr, LoadOption.Upsert);
dtLoad.Rows[3][1] = "NEWVAL";
- AssertEquals ("A-RowState2", DataRowState.Deleted,
- dtLoad.Rows[2].RowState);
- AssertEquals ("A-RowData2-id", 3,
- dtLoad.Rows[2][0, DataRowVersion.Original]);
- AssertEquals ("A-RowData2-name", "RowState 3",
- dtLoad.Rows[2][1, DataRowVersion.Original]);
- AssertEquals ("A-RowState3", DataRowState.Added,
- dtLoad.Rows[3].RowState);
- AssertEquals ("A-RowData3-id", 3,
- dtLoad.Rows[3][0, DataRowVersion.Current]);
- AssertEquals ("A-RowData3-name", "NEWVAL",
- dtLoad.Rows[3][1, DataRowVersion.Current]);
- AssertEquals ("A-RowState4", DataRowState.Added,
- dtLoad.Rows[4].RowState);
- AssertEquals ("A-RowData4-id", 4,
- dtLoad.Rows[4][0, DataRowVersion.Current]);
- AssertEquals ("A-RowData4-name", "mono 4",
- dtLoad.Rows[4][1, DataRowVersion.Current]);
+ Assert.AreEqual (DataRowState.Deleted, dtLoad.Rows[2].RowState, "A-RowState2");
+ Assert.AreEqual (3, dtLoad.Rows[2][0, DataRowVersion.Original], "A-RowData2-id");
+ Assert.AreEqual ("RowState 3", dtLoad.Rows[2][1, DataRowVersion.Original], "A-RowData2-name");
+ Assert.AreEqual (DataRowState.Added, dtLoad.Rows[3].RowState, "A-RowState3");
+ Assert.AreEqual (3, dtLoad.Rows[3][0, DataRowVersion.Current], "A-RowData3-id");
+ Assert.AreEqual ("NEWVAL", dtLoad.Rows[3][1, DataRowVersion.Current], "A-RowData3-name");
+ Assert.AreEqual (DataRowState.Added, dtLoad.Rows[4].RowState, "A-RowState4");
+ Assert.AreEqual (4, dtLoad.Rows[4][0, DataRowVersion.Current], "A-RowData4-id");
+ Assert.AreEqual ("mono 4", dtLoad.Rows[4][1, DataRowVersion.Current], "A-RowData4-name");
dtLoad.AcceptChanges ();
- AssertEquals ("B-RowState2", DataRowState.Unchanged,
- dtLoad.Rows[2].RowState);
- AssertEquals ("B-RowData2-id", 3,
- dtLoad.Rows[2][0, DataRowVersion.Current]);
- AssertEquals ("B-RowData2-name", "NEWVAL",
- dtLoad.Rows[2][1, DataRowVersion.Current]);
- AssertEquals ("B-RowState3", DataRowState.Unchanged,
- dtLoad.Rows[3].RowState);
- AssertEquals ("B-RowData3-id", 4,
- dtLoad.Rows[3][0, DataRowVersion.Current]);
- AssertEquals ("B-RowData3-name", "mono 4",
- dtLoad.Rows[3][1, DataRowVersion.Current]);
+ Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[2].RowState, "B-RowState2");
+ Assert.AreEqual (3, dtLoad.Rows[2][0, DataRowVersion.Current], "B-RowData2-id");
+ Assert.AreEqual ("NEWVAL", dtLoad.Rows[2][1, DataRowVersion.Current], "B-RowData2-name");
+ Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[3].RowState, "B-RowState3");
+ Assert.AreEqual (4, dtLoad.Rows[3][0, DataRowVersion.Current], "B-RowData3-id");
+ Assert.AreEqual ("mono 4", dtLoad.Rows[3][1, DataRowVersion.Current], "B-RowData3-name");
}
[Test]
DataTableReader dtr = dt.CreateDataReader ();
dtLoad.Load (dtr, LoadOption.Upsert);
dtLoad.AcceptChanges ();
- AssertEquals ("RowData4", " ", dtLoad.Rows[4][1]);
+ Assert.AreEqual (" ", dtLoad.Rows[4][1], "RowData4");
}
[Test]
dtLoad.Rows[2].Delete ();
DataTableReader dtr = dt.CreateDataReader ();
dtLoad.Load (dtr, LoadOption.Upsert);
- AssertEquals ("RowData2-C", " ",
- dtLoad.Rows[2][1, DataRowVersion.Current]);
+ Assert.AreEqual (" ", dtLoad.Rows[2][1, DataRowVersion.Current], "RowData2-C");
}
[Test]
dtLoad.Rows[2].Delete ();
DataTableReader dtr = dt.CreateDataReader ();
dtLoad.Load (dtr, LoadOption.Upsert);
- AssertEquals ("RowData3-O", " ",
- dtLoad.Rows[3][1, DataRowVersion.Original]);
+ Assert.AreEqual (" ", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
}
[Test]
dtLoad.Rows.Add (row);
DataTableReader dtr = dt.CreateDataReader ();
dtLoad.Load (dtr, LoadOption.Upsert);
- AssertEquals ("RowData3-O", " ",
- dtLoad.Rows[3][1, DataRowVersion.Original]);
+ Assert.AreEqual (" ", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
}
[Test]
dtLoad.AcceptChanges ();
DataTableReader dtr = dt.CreateDataReader ();
dtLoad.Load (dtr, LoadOption.Upsert);
- AssertEquals ("RowData3-O", " ",
- dtLoad.Rows[3][1, DataRowVersion.Original]);
+ Assert.AreEqual (" ", dtLoad.Rows[3][1, DataRowVersion.Original], "RowData3-O");
}
[Test]
rowActionInit (dra);
dtLoad.Load (dtr, LoadOption.Upsert);
rowActionEnd ();
- AssertEquals ("RowData0-C", "mono 1",
- dtLoad.Rows[0][1, DataRowVersion.Current]);
- AssertEquals ("RowData0-O", "mono 1",
- dtLoad.Rows[0][1, DataRowVersion.Original]);
- AssertEquals ("RowState0", DataRowState.Unchanged,
- dtLoad.Rows[0].RowState);
+ Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Current], "RowData0-C");
+ Assert.AreEqual ("mono 1", dtLoad.Rows[0][1, DataRowVersion.Original], "RowData0-O");
+ Assert.AreEqual (DataRowState.Unchanged, dtLoad.Rows[0].RowState, "RowState0");
}
[Test]
dt.EndLoadData ();
// LoadDataRow(update1) - check column String2
- AssertEquals ("DT72-C", "Changed",
- dr["String2", DataRowVersion.Current]);
- AssertEquals ("DT72-O", "Changed",
- dr["String2", DataRowVersion.Original]);
+ Assert.AreEqual ("Changed", dr["String2", DataRowVersion.Current], "DT72-C");
+ Assert.AreEqual ("Changed", dr["String2", DataRowVersion.Original], "DT72-O");
// LoadDataRow(update1) - check row state
- AssertEquals ("DT73-LO", DataRowState.Unchanged, dr.RowState);
+ Assert.AreEqual (DataRowState.Unchanged, dr.RowState, "DT73-LO");
//Add New row with LoadOptions = Upsert
dt.BeginLoadData ();
// LoadDataRow(insert1) - check column String2
dr = dt.Select ("ParentId=99")[0];
- AssertEquals ("DT75-C", "Changed",
- dr["String2", DataRowVersion.Current]);
+ Assert.AreEqual ("Changed", dr["String2", DataRowVersion.Current], "DT75-C");
// LoadDataRow(insert1) - check row state
- AssertEquals ("DT76-LO", DataRowState.Added, dr.RowState);
+ Assert.AreEqual (DataRowState.Added, dr.RowState, "DT76-LO");
}
public static DataTable CreateDataTableExample () {
DataTable Table = new DataTable ();
Table.ReadXmlSchema ("Test/System.Data/own_schema1.xsd");
- AssertEquals ("test#02", "test_table", Table.TableName);
- AssertEquals ("test#03", "", Table.Namespace);
- AssertEquals ("test#04", 2, Table.Columns.Count);
- AssertEquals ("test#05", 0, Table.Rows.Count);
- AssertEquals ("test#06", false, Table.CaseSensitive);
- AssertEquals ("test#07", 1, Table.Constraints.Count);
- AssertEquals ("test#08", "", Table.Prefix);
+ 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];
- AssertEquals ("test#09", "Constraint1", cons.ConstraintName.ToString ());
- AssertEquals ("test#10", "Constraint1", cons.ToString ());
+ Assert.AreEqual ("Constraint1", cons.ConstraintName.ToString (), "test#09");
+ Assert.AreEqual ("Constraint1", cons.ToString (), "test#10");
DataColumn column = Table.Columns[0];
- AssertEquals ("test#11", true, column.AllowDBNull);
- AssertEquals ("test#12", false, column.AutoIncrement);
- AssertEquals ("test#13", 0L, column.AutoIncrementSeed);
- AssertEquals ("test#14", 1L, column.AutoIncrementStep);
- AssertEquals ("test#15", "test", column.Caption);
- AssertEquals ("test#16", "Element", column.ColumnMapping.ToString ());
- AssertEquals ("test#17", "first", column.ColumnName);
- AssertEquals ("test#18", "System.String", column.DataType.ToString ());
- AssertEquals ("test#19", "test_default_value", column.DefaultValue.ToString ());
- AssertEquals ("test#20", false, column.DesignMode);
- AssertEquals ("test#21", "", column.Expression);
- AssertEquals ("test#22", 100, column.MaxLength);
- AssertEquals ("test#23", "", column.Namespace);
- AssertEquals ("test#24", 0, column.Ordinal);
- AssertEquals ("test#25", "", column.Prefix);
- AssertEquals ("test#26", false, column.ReadOnly);
- AssertEquals ("test#27", true, column.Unique);
+ 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];
- AssertEquals ("test#28", true, column2.AllowDBNull);
- AssertEquals ("test#29", false, column2.AutoIncrement);
- AssertEquals ("test#30", 0L, column2.AutoIncrementSeed);
- AssertEquals ("test#31", 1L, column2.AutoIncrementStep);
- AssertEquals ("test#32", "second", column2.Caption);
- AssertEquals ("test#33", "Element", column2.ColumnMapping.ToString ());
- AssertEquals ("test#34", "second", column2.ColumnName);
- AssertEquals ("test#35", "System.Data.SqlTypes.SqlGuid", column2.DataType.ToString ());
- AssertEquals ("test#36", "Null", column2.DefaultValue.ToString ());
- AssertEquals ("test#37", false, column2.DesignMode);
- AssertEquals ("test#38", "", column2.Expression);
- AssertEquals ("test#39", -1, column2.MaxLength);
- AssertEquals ("test#40", "", column2.Namespace);
- AssertEquals ("test#41", 1, column2.Ordinal);
- AssertEquals ("test#42", "", column2.Prefix);
- AssertEquals ("test#43", false, column2.ReadOnly);
- AssertEquals ("test#44", false, column2.Unique);
+ 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");
+ Assert.AreEqual ("Null", column2.DefaultValue.ToString (), "test#36");
+ 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 = new DataTable ();
Table2.ReadXmlSchema ("Test/System.Data/own_schema2.xsd");
- AssertEquals ("test#45", "second_test_table", Table2.TableName);
- AssertEquals ("test#46", "", Table2.Namespace);
- AssertEquals ("test#47", 1, Table2.Columns.Count);
- AssertEquals ("test#48", 0, Table2.Rows.Count);
- AssertEquals ("test#49", false, Table2.CaseSensitive);
- AssertEquals ("test#50", 1, Table2.Constraints.Count);
- AssertEquals ("test#51", "", Table2.Prefix);
+ 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];
- AssertEquals ("test#52", true, column3.AllowDBNull);
- AssertEquals ("test#53", false, column3.AutoIncrement);
- AssertEquals ("test#54", 0L, column3.AutoIncrementSeed);
- AssertEquals ("test#55", 1L, column3.AutoIncrementStep);
- AssertEquals ("test#56", "second_first", column3.Caption);
- AssertEquals ("test#57", "Element", column3.ColumnMapping.ToString ());
- AssertEquals ("test#58", "second_first", column3.ColumnName);
- AssertEquals ("test#59", "System.String", column3.DataType.ToString ());
- AssertEquals ("test#60", "default_value", column3.DefaultValue.ToString ());
- AssertEquals ("test#61", false, column3.DesignMode);
- AssertEquals ("test#62", "", column3.Expression);
- AssertEquals ("test#63", 100, column3.MaxLength);
- AssertEquals ("test#64", "", column3.Namespace);
- AssertEquals ("test#65", 0, column3.Ordinal);
- AssertEquals ("test#66", "", column3.Prefix);
- AssertEquals ("test#67", false, column3.ReadOnly);
- AssertEquals ("test#68", true, column3.Unique);
+ 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]
//Assert.AreEqual (ds2.Tables.Count, ds1.Tables.Count, "DS269");
// ReadXmlSchema - Tables 0 Col count
- AssertEquals ("DS270", ds1.Tables[0].Columns.Count, dt1.Columns.Count);
+ Assert.AreEqual (ds1.Tables[0].Columns.Count, dt1.Columns.Count, "DS270");
// ReadXmlSchema - Tables 1 Col count
- AssertEquals ("DS271", ds1.Tables[1].Columns.Count, dt2.Columns.Count);
+ Assert.AreEqual (ds1.Tables[1].Columns.Count, dt2.Columns.Count, "DS271");
//check some colummns types
// ReadXmlSchema - Tables 0 Col type
- AssertEquals ("DS272", ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType ());
+ Assert.AreEqual (ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType (), "DS272");
// ReadXmlSchema - Tables 1 Col type
- AssertEquals ("DS273", ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType ());
+ Assert.AreEqual (ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType (), "DS273");
//check that no data exists
// ReadXmlSchema - Table 1 row count
- AssertEquals ("DS274",0, dt1.Rows.Count);
+ Assert.AreEqual (0, dt1.Rows.Count, "DS274");
// ReadXmlSchema - Table 2 row count
- AssertEquals ("DS275",0, dt2.Rows.Count);
+ Assert.AreEqual (0, dt2.Rows.Count, "DS275");
}
[Test]
dt1.ReadXmlSchema (sTempFileName1);
dt2.ReadXmlSchema (sTempFileName2);
- AssertEquals ("DS277", ds1.Tables[0].Columns.Count, dt1.Columns.Count);
- AssertEquals ("DS278", ds1.Tables[1].Columns.Count, dt2.Columns.Count);
- AssertEquals ("DS279", ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType ());
- AssertEquals ("DS280", ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType ());
- AssertEquals ("DS281", 0, dt1.Rows.Count);
- AssertEquals ("DS282", 0, dt2.Rows.Count);
+ Assert.AreEqual (ds1.Tables[0].Columns.Count, dt1.Columns.Count, "DS277");
+ Assert.AreEqual (ds1.Tables[1].Columns.Count, dt2.Columns.Count, "DS278");
+ Assert.AreEqual (ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType (), "DS279");
+ Assert.AreEqual (ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType (), "DS280");
+ Assert.AreEqual (0, dt1.Rows.Count, "DS281");
+ Assert.AreEqual (0, dt2.Rows.Count, "DS282");
File.Delete (sTempFileName1);
File.Delete (sTempFileName2);
//Assert.AreEqual (ds2.Tables.Count, ds1.Tables.Count, "DS283");
// ReadXmlSchema - Tables 0 Col count
- AssertEquals ("DS284", ds1.Tables[0].Columns.Count, dt1.Columns.Count);
+ Assert.AreEqual (ds1.Tables[0].Columns.Count, dt1.Columns.Count, "DS284");
// ReadXmlSchema - Tables 1 Col count
- AssertEquals ("DS285", ds1.Tables[1].Columns.Count, dt2.Columns.Count);
+ Assert.AreEqual (ds1.Tables[1].Columns.Count, dt2.Columns.Count, "DS285");
//check some colummns types
// ReadXmlSchema - Tables 0 Col type
- AssertEquals ("DS286", ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType ());
+ Assert.AreEqual (ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType (), "DS286");
// ReadXmlSchema - Tables 1 Col type
- AssertEquals ("DS287", ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType ());
+ Assert.AreEqual (ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType (), "DS287");
//check that no data exists
// ReadXmlSchema - Table 1 row count
- AssertEquals ("DS288", 0, dt1.Rows.Count);
+ Assert.AreEqual (0, dt1.Rows.Count, "DS288");
// ReadXmlSchema - Table 2 row count
- AssertEquals ("DS289", 0, dt2.Rows.Count);
+ Assert.AreEqual (0, dt2.Rows.Count, "DS289");
}
[Test]
//Assert.AreEqual (ds2.Tables.Count, ds1.Tables.Count, "DS290");
// ReadXmlSchema - Tables 0 Col count
- AssertEquals ("DS291", ds1.Tables[0].Columns.Count, dt1.Columns.Count);
+ Assert.AreEqual (ds1.Tables[0].Columns.Count, dt1.Columns.Count, "DS291");
// ReadXmlSchema - Tables 1 Col count
- AssertEquals ("DS292", ds1.Tables[1].Columns.Count, dt2.Columns.Count);
+ Assert.AreEqual (ds1.Tables[1].Columns.Count, dt2.Columns.Count, "DS292");
//check some colummns types
// ReadXmlSchema - Tables 0 Col type
- AssertEquals ("DS293", ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType ());
+ Assert.AreEqual (ds1.Tables[0].Columns[0].GetType (), dt1.Columns[0].GetType (), "DS293");
// ReadXmlSchema - Tables 1 Col type
- AssertEquals ("DS294", ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType ());
+ Assert.AreEqual (ds1.Tables[1].Columns[3].GetType (), dt2.Columns[3].GetType (), "DS294");
//check that no data exists
// ReadXmlSchema - Table 1 row count
- AssertEquals ("DS295", 0, dt1.Rows.Count);
+ Assert.AreEqual (0, dt1.Rows.Count, "DS295");
// ReadXmlSchema - Table 2 row count
- AssertEquals ("DS296", 0, dt2.Rows.Count);
+ Assert.AreEqual (0, dt2.Rows.Count, "DS296");
}
[Test]
string substring = TextString.Substring (0, TextString.IndexOf (EOL));
TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
- AssertEquals ("test#01", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", substring);
+ 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);
- AssertEquals ("test#02", "<xs:schema id=\"Root\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\">", substring);
+ 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);
- AssertEquals ("test#03", " <xs:element msdata:IsDataSet=\"true\" msdata:MainDataTable=\"Region\" msdata:UseCurrentLocale=\"true\" name=\"Root\">", substring);
+ Assert.AreEqual (" <xs:element msdata:IsDataSet=\"true\" msdata:MainDataTable=\"Region\" msdata:UseCurrentLocale=\"true\" name=\"Root\">", substring, "test#03");
substring = TextString.Substring (0, TextString.IndexOf (EOL));
TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
- AssertEquals ("test#04", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#04");
substring = TextString.Substring (0, TextString.IndexOf (EOL));
TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
- AssertEquals ("test#05", " <xs:choice maxOccurs=\"unbounded\" minOccurs=\"0\">", substring);
+ 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);
- AssertEquals ("test#06", " <xs:element name=\"Region\">", substring);
+ Assert.AreEqual (" <xs:element name=\"Region\">", substring, "test#06");
substring = TextString.Substring (0, TextString.IndexOf (EOL));
TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
- AssertEquals ("test#07", " <xs:complexType>", substring);
+ Assert.AreEqual (" <xs:complexType>", substring, "test#07");
substring = TextString.Substring (0, TextString.IndexOf (EOL));
TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
- AssertEquals ("test#08", " <xs:sequence>", substring);
+ Assert.AreEqual (" <xs:sequence>", substring, "test#08");
substring = TextString.Substring (0, TextString.IndexOf (EOL));
TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
- AssertEquals ("test#09", " <xs:element minOccurs=\"0\" name=\"RegionID\" type=\"xs:string\" />", substring);
+ 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);
- AssertEquals ("test#10", " <xs:element minOccurs=\"0\" name=\"RegionDescription\" type=\"xs:string\" />", substring);
+ 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);
- AssertEquals ("test#11", " </xs:sequence>", substring);
+ Assert.AreEqual (" </xs:sequence>", substring, "test#11");
substring = TextString.Substring (0, TextString.IndexOf (EOL));
TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
- AssertEquals ("test#12", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#12");
substring = TextString.Substring (0, TextString.IndexOf (EOL));
TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
- AssertEquals ("test#13", " </xs:element>", substring);
+ Assert.AreEqual (" </xs:element>", substring, "test#13");
substring = TextString.Substring (0, TextString.IndexOf (EOL));
TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
- AssertEquals ("test#14", " </xs:choice>", substring);
+ Assert.AreEqual (" </xs:choice>", substring, "test#14");
substring = TextString.Substring (0, TextString.IndexOf (EOL));
TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
- AssertEquals ("test#15", " </xs:complexType>", substring);
+ Assert.AreEqual (" </xs:complexType>", substring, "test#15");
substring = TextString.Substring (0, TextString.IndexOf (EOL));
TextString = TextString.Substring (TextString.IndexOf (EOL) + EOL.Length);
- AssertEquals ("test#16", " </xs:element>", substring);
+ Assert.AreEqual (" </xs:element>", substring, "test#16");
- AssertEquals ("test#17", "</xs:schema>", TextString);
+ Assert.AreEqual ("</xs:schema>", TextString, "test#17");
}
[Test]
OriginalDataSet.WriteXml (xtw);
string result = sw.ToString ();
- AssertEquals (xml, result);
+ Assert.AreEqual (xml, result);
sw = new StringWriter ();
xtw = new XmlTextWriter (sw);
result = sw.ToString ();
result = result.Replace ("\r\n", "\n").Replace ('"', '\'');
- AssertEquals (schema.Replace ("\r\n", "\n"), result);
+ Assert.AreEqual (schema.Replace ("\r\n", "\n"), result);
}
[Test]
string result = sw.ToString ();
- AssertEquals (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
- //AssertEquals (xmlschema, result.Replace ("\r\n", "\n"));
+ Assert.AreEqual (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
+ //Assert.AreEqual (xmlschema, result.Replace ("\r\n", "\n"));
}
[Test]
string result = sw.ToString ();
- AssertEquals (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
+ Assert.AreEqual (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
}
[Test]
StringWriter sw1 = new StringWriter ();
ds.Tables[0].WriteXmlSchema (sw1);
string result1 = sw1.ToString ();
- AssertEquals (xmlschema1.Replace ("\r\n", "\n"), result1.Replace ("\r\n", "\n"));
+ Assert.AreEqual (xmlschema1.Replace ("\r\n", "\n"), result1.Replace ("\r\n", "\n"));
StringWriter sw2 = new StringWriter ();
ds.Tables[1].WriteXmlSchema (sw2);
string result2 = sw2.ToString ();
- AssertEquals (xmlschema2.Replace ("\r\n", "\n"), result2.Replace ("\r\n", "\n"));
+ Assert.AreEqual (xmlschema2.Replace ("\r\n", "\n"), result2.Replace ("\r\n", "\n"));
StringWriter sw3 = new StringWriter ();
ds.Tables[2].WriteXmlSchema (sw3);
string result3 = sw3.ToString ();
- AssertEquals (xmlschema3.Replace ("\r\n", "\n"), result3.Replace ("\r\n", "\n"));
+ Assert.AreEqual (xmlschema3.Replace ("\r\n", "\n"), result3.Replace ("\r\n", "\n"));
}
[Test]
string result = sw.ToString ();
- AssertEquals (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
+ Assert.AreEqual (xmlschema.Replace ("\r\n", "\n"), result.Replace ("\r\n", "\n"));
}
[Test]
dt.Rows.Add (new object[] { "foo", "bar" });
StringWriter sw = new StringWriter ();
ds.Tables[0].WriteXmlSchema (sw);
- Assert (sw.ToString ().IndexOf ("xmlns=\"\"") > 0);
+ Assert.IsTrue (sw.ToString ().IndexOf ("xmlns=\"\"") > 0);
}
[Test]
StringWriter sw1 = new StringWriter ();
ds1.Tables[0].WriteXmlSchema (sw1);
String xml1 = sw1.ToString ();
- Assert ("#1", xml1.IndexOf (@"<xs:unique name=""Constraint1"">") != -1);
+ Assert.IsTrue (xml1.IndexOf (@"<xs:unique name=""Constraint1"">") != -1, "#1");
StringWriter sw2 = new StringWriter ();
ds1.Tables[1].WriteXmlSchema (sw2);
String xml2 = sw2.ToString ();
- Assert ("#2", xml2.IndexOf (@"<xs:unique name=""Constraint1"">") == -1);
+ Assert.IsTrue (xml2.IndexOf (@"<xs:unique name=""Constraint1"">") == -1, "#2");
}
[Test]
DataTable dtB = new DataTable ();
dtB.ReadXmlSchema (msB);
- AssertEquals ("#2", 3, dtA.Constraints.Count);
- AssertEquals ("#3", 2, dtB.Constraints.Count);
+ Assert.AreEqual (3, dtA.Constraints.Count, "#2");
+ Assert.AreEqual (2, dtB.Constraints.Count, "#3");
- Assert ("#5", dtA.Constraints.Contains ("pk 1"));
- Assert ("#6", dtA.Constraints.Contains ("Constraint1"));
- Assert ("#7", dtA.Constraints.Contains ("Constraint2"));
- Assert ("#9", dtB.Constraints.Contains ("pk 2"));
- Assert ("#10", dtB.Constraints.Contains ("Constraint1"));
+ Assert.IsTrue (dtA.Constraints.Contains ("pk 1"), "#5");
+ Assert.IsTrue (dtA.Constraints.Contains ("Constraint1"), "#6");
+ Assert.IsTrue (dtA.Constraints.Contains ("Constraint2"), "#7");
+ Assert.IsTrue (dtB.Constraints.Contains ("pk 2"), "#9");
+ Assert.IsTrue (dtB.Constraints.Contains ("Constraint1"), "#10");
}
[Test]
xw1.QuoteChar = '\'';
ds.Tables[0].WriteXmlSchema (xw1);
string result1 = sw1.ToString ();
- AssertEquals ("#1", schema, result1);
+ Assert.AreEqual (schema, result1, "#1");
StringWriter sw2 = new StringWriter ();
XmlTextWriter xw2 = new XmlTextWriter (sw2);
xw2.QuoteChar = '\'';
ds.Tables[0].WriteXmlSchema (xw2);
string result2 = sw2.ToString ();
- AssertEquals ("#2", schema, result2);
+ Assert.AreEqual (schema, result2, "#2");
}
[Test]
StringWriter writer1 = new StringWriter ();
table1.WriteXmlSchema (writer1, false);
string expected1 = "<?xml version=\"1.0\" encoding=\"utf-16\"?>\n<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">\n <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"Table1\" msdata:UseCurrentLocale=\"true\">\n <xs:complexType>\n <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">\n <xs:element name=\"Table1\">\n <xs:complexType>\n <xs:sequence>\n <xs:element name=\"ID\" type=\"xs:int\" />\n <xs:element name=\"Name\" type=\"xs:string\" minOccurs=\"0\" />\n </xs:sequence>\n </xs:complexType>\n </xs:element>\n </xs:choice>\n </xs:complexType>\n <xs:unique name=\"Constraint1\" msdata:PrimaryKey=\"true\">\n <xs:selector xpath=\".//Table1\" />\n <xs:field xpath=\"ID\" />\n </xs:unique>\n </xs:element>\n</xs:schema>";
- AssertEquals ("#1", expected1, writer1.ToString());
+ Assert.AreEqual (expected1, writer1.ToString(), "#1");
StringWriter writer2 = new StringWriter ();
table1.WriteXmlSchema (writer2, true);
string expected2 = "<?xml version=\"1.0\" encoding=\"utf-16\"?>\n<xs:schema id=\"NewDataSet\" xmlns=\"\" xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">\n <xs:element name=\"NewDataSet\" msdata:IsDataSet=\"true\" msdata:MainDataTable=\"Table1\" msdata:UseCurrentLocale=\"true\">\n <xs:complexType>\n <xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">\n <xs:element name=\"Table1\">\n <xs:complexType>\n <xs:sequence>\n <xs:element name=\"ID\" type=\"xs:int\" />\n <xs:element name=\"Name\" type=\"xs:string\" minOccurs=\"0\" />\n </xs:sequence>\n </xs:complexType>\n </xs:element>\n <xs:element name=\"Table2\">\n <xs:complexType>\n <xs:sequence>\n <xs:element name=\"OrderID\" type=\"xs:int\" />\n <xs:element name=\"CustomerID\" type=\"xs:int\" minOccurs=\"0\" />\n <xs:element name=\"OrderDate\" type=\"xs:dateTime\" minOccurs=\"0\" />\n </xs:sequence>\n </xs:complexType>\n </xs:element>\n </xs:choice>\n </xs:complexType>\n <xs:unique name=\"Constraint1\" msdata:PrimaryKey=\"true\">\n <xs:selector xpath=\".//Table1\" />\n <xs:field xpath=\"ID\" />\n </xs:unique>\n <xs:unique name=\"Table2_Constraint1\" msdata:ConstraintName=\"Constraint1\" msdata:PrimaryKey=\"true\">\n <xs:selector xpath=\".//Table2\" />\n <xs:field xpath=\"OrderID\" />\n </xs:unique>\n <xs:keyref name=\"CustomerOrder\" refer=\"Constraint1\">\n <xs:selector xpath=\".//Table2\" />\n <xs:field xpath=\"CustomerID\" />\n </xs:keyref>\n </xs:element>\n</xs:schema>";
- AssertEquals ("#2", expected2, writer2.ToString ());
+ Assert.AreEqual (expected2, writer2.ToString (), "#2");
}
[Test]
@"</xs:element>" +
@"</xs:schema>";
Console.WriteLine ("{0} - {1}", TextString1, expected1);
- AssertEquals ("#1", expected1, TextString1.Replace ("\r\n", "").Replace (" ", "").Replace ("\n", ""));
+ Assert.AreEqual (expected1, TextString1.Replace ("\r\n", "").Replace (" ", "").Replace ("\n", ""), "#1");
TextWriter writer2 = new StringWriter ();
ds.Tables[1].WriteXmlSchema (writer2, false);
@"</xs:complexType>" +
@"</xs:element>" +
@"</xs:schema>";
- AssertEquals ("#2", expected2, TextString2.Replace ("\r\n", "").Replace (" ", ""));
+ Assert.AreEqual (expected2, TextString2.Replace ("\r\n", "").Replace (" ", ""), "#2");
TextWriter writer3 = new StringWriter ();
ds.Tables[2].WriteXmlSchema (writer3);
@"</xs:complexType>" +
@"</xs:element>" +
@"</xs:schema>";
- AssertEquals ("#3", expected3, TextString3.Replace ("\r\n", "").Replace (" ", ""));
+ Assert.AreEqual (expected3, TextString3.Replace ("\r\n", "").Replace (" ", ""), "#3");
TextWriter writer4 = new StringWriter ();
string expStr = "";
catch (Exception ex) {
expStr = ex.Message;
}
- AssertEquals ("#4", "Cannot find table 3.", expStr);
+ Assert.AreEqual ("Cannot find table 3.", expStr, "#4");
}
[Test]
ds1.Tables[0].ReadXmlSchema (new MemoryStream (ms1.GetBuffer ()));
ds1.Tables[1].ReadXmlSchema (new MemoryStream (ms2.GetBuffer ()));
- AssertEquals ("#1", 0, ds1.Relations.Count);
- AssertEquals ("#2", 1, ds1.Tables[0].Columns.Count);
- AssertEquals ("#3", 1, ds1.Tables[1].Columns.Count);
+ Assert.AreEqual (0, ds1.Relations.Count, "#1");
+ Assert.AreEqual (1, ds1.Tables[0].Columns.Count, "#2");
+ Assert.AreEqual (1, ds1.Tables[1].Columns.Count, "#3");
}
[Test]
public void Remote ()
{
int n = (int) Convert.ChangeType ("5", typeof (int));
- Assertion.AssertEquals ("n", 5, n);
+ Assert.AreEqual (5, n, "n");
}
#if !TARGET_JVM
[Test]
DataView dv = dt.DefaultView;
dv.RowFilter = "StartDate >= '" + DateTime.Now.AddDays (2) + "' and StartDate <= '" + DateTime.Now.AddDays (4) + "'";
- Assertion.AssertEquals ("Table", 10, dt.Rows.Count);
- Assertion.AssertEquals ("View", 2, dv.Count);
+ Assert.AreEqual (10, dt.Rows.Count, "Table");
+ Assert.AreEqual (2, dv.Count, "View");
}
}
}
+2006-12-05 Raja R Harinath <rharinath@novell.com>
+
+ * XmlDataDocumentTest.cs: Modernize.
+
2006-04-19 Senganal T <tsenganal@novell.com>
* XmlDataDocumentTest2.cs : Test if DataSet schema with whitespace
{
XmlDataDocument doc = new XmlDataDocument ();
AssertDataSet ("#1", doc.DataSet, "NewDataSet", 0, 0);
- AssertEquals (false, doc.DataSet.EnforceConstraints);
+ Assert.IsFalse (doc.DataSet.EnforceConstraints);
XmlElement el = doc.CreateElement ("TEST");
AssertDataSet ("#2", doc.DataSet, "NewDataSet", 0, 0);
- AssertNull (doc.GetRowFromElement (el));
+ Assert.IsNull (doc.GetRowFromElement (el));
doc.AppendChild (el);
AssertDataSet ("#3", doc.DataSet, "NewDataSet", 0, 0);
DataSet ds = new DataSet ();
doc = new XmlDataDocument (ds);
- AssertEquals (true, doc.DataSet.EnforceConstraints);
+ Assert.IsTrue (doc.DataSet.EnforceConstraints);
}
[Test]
XmlDataDocument doc2 = (XmlDataDocument)doc.CloneNode (false);
- AssertEquals ("#I01", 0, doc2.ChildNodes.Count);
- AssertEquals ("#I02", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", doc2.DataSet.GetXmlSchema ().Substring (0, 39));
+ Assert.AreEqual (0, doc2.ChildNodes.Count, "#I01");
+ Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", doc2.DataSet.GetXmlSchema ().Substring (0, 39), "#I02");
doc2 = (XmlDataDocument)doc.CloneNode (true);
- AssertEquals ("#I03", 2, doc2.ChildNodes.Count);
- AssertEquals ("#I04", "<?xml version=\"1.0\" encoding=\"utf-16\"?>", doc2.DataSet.GetXmlSchema ().Substring (0, 39));
+ Assert.AreEqual (2, doc2.ChildNodes.Count, "#I03");
+ Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>", doc2.DataSet.GetXmlSchema ().Substring (0, 39), "#I04");
doc.DataSet.Tables [0].Rows [0][0] = "64";
- AssertEquals ("#I05", "1", doc2.DataSet.Tables [0].Rows [0][0].ToString ());
+ Assert.AreEqual ("1", doc2.DataSet.Tables [0].Rows [0][0].ToString (), "#I05");
}
[Test]
XmlElement Element = doc.GetElementFromRow (doc.DataSet.Tables [0].Rows [1]);
Element.FirstChild.InnerText = "64";
- AssertEquals ("test#01", "64", doc.DataSet.Tables [0].Rows [1] [0]);
+ Assert.AreEqual ("64", doc.DataSet.Tables [0].Rows [1] [0], "test#01");
DataSet Set = new DataSet ();
Set.ReadXml ("Test/System.Xml/region.xml");
doc = new XmlDataDocument (Set);
Element = doc.GetElementFromRow (doc.DataSet.Tables [0].Rows [1]);
- AssertNotNull (Element);
+ Assert.IsNotNull (Element);
try {
Element.FirstChild.InnerText = "64";
- Fail ("test#02");
+ Assert.Fail ("test#02");
} catch (InvalidOperationException) {
}
- AssertEquals ("test#05", "2", doc.DataSet.Tables [0].Rows [1] [0]);
+ Assert.AreEqual ("2", doc.DataSet.Tables [0].Rows [1] [0], "test#05");
Set.EnforceConstraints = false;
Element.FirstChild.InnerText = "64";
- AssertEquals ("test#06", "64", doc.DataSet.Tables [0].Rows [1] [0]);
+ Assert.AreEqual ("64", doc.DataSet.Tables [0].Rows [1] [0], "test#06");
}
XmlTextWriter xw = new XmlTextWriter (sw);
Doc.DataSet.WriteXml (xw);
string s = sw.ToString ();
- AssertEquals ("#1", xml, s);
- AssertEquals ("#2", xml, Doc.InnerXml);
- AssertEquals ("test#01", "EndOfFile", Reader.ReadState.ToString ());
+ Assert.AreEqual (xml, s, "#1");
+ Assert.AreEqual (xml, Doc.InnerXml, "#2");
+ Assert.AreEqual ("EndOfFile", Reader.ReadState.ToString (), "test#01");
DataSet Set = Doc.DataSet;
- AssertEquals ("test#01.5", "2", Set.Tables [0].Rows [1] [0]);
+ Assert.AreEqual ("2", Set.Tables [0].Rows [1] [0], "test#01.5");
Set.Tables [0].Rows [1] [0] = "64";
- AssertEquals ("test#02", "64", Doc.FirstChild.FirstChild.NextSibling.FirstChild.InnerText);
+ Assert.AreEqual ("64", Doc.FirstChild.FirstChild.NextSibling.FirstChild.InnerText, "test#02");
}
[Test]
doc.Load ("Test/System.Xml/region.xml");
XmlElement Element = doc.CreateElement ("prefix", "localname", "namespaceURI");
- AssertEquals ("test#01", "prefix", Element.Prefix);
- AssertEquals ("test#02", "localname", Element.LocalName);
- AssertEquals ("test#03", "namespaceURI", Element.NamespaceURI);
+ Assert.AreEqual ("prefix", Element.Prefix, "test#01");
+ Assert.AreEqual ("localname", Element.LocalName, "test#02");
+ Assert.AreEqual ("namespaceURI", Element.NamespaceURI, "test#03");
doc.ImportNode (Element, false);
TextWriter text = new StringWriter ();
substring = TextString.Substring (0, TextString.IndexOf("\n"));
TextString = TextString.Substring (TextString.IndexOf("\n") + 1);
- Assert ("test#05", substring.IndexOf ("<Root>") != -1);
+ Assert.IsTrue (substring.IndexOf ("<Root>") != -1, "test#05");
substring = TextString.Substring (0, TextString.IndexOf("\n"));
TextString = TextString.Substring (TextString.IndexOf("\n") + 1);
- Assert ("test#06", substring.IndexOf (" <Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Region>") != -1, "test#06");
substring = TextString.Substring (0, TextString.IndexOf("\n"));
TextString = TextString.Substring (TextString.IndexOf("\n") + 1);
- Assert ("test#07", substring.IndexOf (" <RegionID>1</RegionID>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionID>1</RegionID>") != -1, "test#07");
for (int i = 0; i < 26; i++) {
substring = TextString.Substring (0, TextString.IndexOf("\n"));
}
substring = TextString.Substring (0, TextString.Length);
- Assert ("test#07", substring.IndexOf ("</Root>") != -1);
+ Assert.IsTrue (substring.IndexOf ("</Root>") != -1, "test#08");
}
[Test]
doc.Load ("Test/System.Xml/region.xml");
XmlElement Element = doc.CreateElement ("ElementName");
- AssertEquals ("test#01", "", Element.Prefix);
- AssertEquals ("test#02", "ElementName", Element.LocalName);
- AssertEquals ("test#03", "", Element.NamespaceURI);
+ Assert.AreEqual ("", Element.Prefix, "test#01");
+ Assert.AreEqual ("ElementName", Element.LocalName, "test#02");
+ Assert.AreEqual ("", Element.NamespaceURI, "test#03");
Element = doc.CreateElement ("prefix:ElementName");
- AssertEquals ("test#04", "prefix", Element.Prefix);
- AssertEquals ("test#05", "ElementName", Element.LocalName);
- AssertEquals ("test#06", "", Element.NamespaceURI);
+ Assert.AreEqual ("prefix", Element.Prefix, "test#04");
+ Assert.AreEqual ("ElementName", Element.LocalName, "test#05");
+ Assert.AreEqual ("", Element.NamespaceURI, "test#06");
}
[Test]
doc.Load ("Test/System.Xml/region.xml");
XmlElement Element = doc.CreateElement ("ElementName", "namespace");
- AssertEquals ("test#01", "", Element.Prefix);
- AssertEquals ("test#02", "ElementName", Element.LocalName);
- AssertEquals ("test#03", "namespace", Element.NamespaceURI);
+ Assert.AreEqual ("", Element.Prefix, "test#01");
+ Assert.AreEqual ("ElementName", Element.LocalName, "test#02");
+ Assert.AreEqual ("namespace", Element.NamespaceURI, "test#03");
Element = doc.CreateElement ("prefix:ElementName", "namespace");
- AssertEquals ("test#04", "prefix", Element.Prefix);
- AssertEquals ("test#05", "ElementName", Element.LocalName);
- AssertEquals ("test#06", "namespace", Element.NamespaceURI);
+ Assert.AreEqual ("prefix", Element.Prefix, "test#04");
+ Assert.AreEqual ("ElementName", Element.LocalName, "test#05");
+ Assert.AreEqual ("namespace", Element.NamespaceURI, "test#06");
}
[Test]
Nav.MoveToRoot ();
Nav.MoveToFirstChild ();
- AssertEquals ("test#01", "Root", Nav.Name.ToString ());
- AssertEquals ("test#02", "", Nav.NamespaceURI.ToString ());
- AssertEquals ("test#03", "False", Nav.IsEmptyElement.ToString ());
- AssertEquals ("test#04", "Element", Nav.NodeType.ToString ());
- AssertEquals ("test#05", "", Nav.Prefix);
+ Assert.AreEqual ("Root", Nav.Name.ToString (), "test#01");
+ Assert.AreEqual ("", Nav.NamespaceURI.ToString (), "test#02");
+ Assert.AreEqual ("False", Nav.IsEmptyElement.ToString (), "test#03");
+ Assert.AreEqual ("Element", Nav.NodeType.ToString (), "test#04");
+ Assert.AreEqual ("", Nav.Prefix, "test#05");
Nav.MoveToFirstChild ();
Nav.MoveToNext ();
- AssertEquals ("test#06", "Region", Nav.Name.ToString ());
+ Assert.AreEqual ("Region", Nav.Name.ToString (), "test#06");
- AssertEquals ("test#07", "2Western", Nav.Value.Substring(0, Nav.Value.IndexOf ("\n") - 1));
+ Assert.AreEqual ("2Western", Nav.Value.Substring(0, Nav.Value.IndexOf ("\n") - 1), "test#07");
Nav.MoveToFirstChild ();
- AssertEquals ("test#08", "2", Nav.Value);
+ Assert.AreEqual ("2", Nav.Value, "test#08");
Nav.MoveToRoot ();
- AssertEquals ("test#09", "Root", Nav.NodeType.ToString ());
+ Assert.AreEqual ("Root", Nav.NodeType.ToString (), "test#09");
}
string TextString = text.ToString ();
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#A01", substring.IndexOf ("<?xml version=\"1.0\" encoding=\"utf-16\"?>") == 0);
+ Assert.IsTrue (substring.IndexOf ("<?xml version=\"1.0\" encoding=\"utf-16\"?>") == 0, "#A01");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#A02", substring.IndexOf ("<!--sample XML fragment-->") != -1);
+ Assert.IsTrue (substring.IndexOf ("<!--sample XML fragment-->") != -1, "#A02");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#A03", substring.IndexOf ("<bookstore>") != -1);
+ Assert.IsTrue (substring.IndexOf ("<bookstore>") != -1, "#A03");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#A04", substring.IndexOf (" <book genre=\"novel\" ISBN=\"10-861003-324\">") != -1);
+ Assert.IsTrue (substring.IndexOf (" <book genre=\"novel\" ISBN=\"10-861003-324\">") != -1, "#A04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#A05", substring.IndexOf (" <title>The Handmaid's Tale</title>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <title>The Handmaid's Tale</title>") != -1, "#A05");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("#A06", " <price>12.95</price>", substring);
+ Assert.AreEqual (" <price>12.95</price>", substring, "#A06");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#A07", substring.IndexOf (" </book>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </book>") != -1, "#A07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#A08", substring.IndexOf (" <book genre=\"novel\" ISBN=\"1-861001-57-5\">") != -1);
+ Assert.IsTrue (substring.IndexOf (" <book genre=\"novel\" ISBN=\"1-861001-57-5\">") != -1, "#A08");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#A09", substring.IndexOf (" <title>Pride And Prejudice</title>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <title>Pride And Prejudice</title>") != -1, "#A09");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#A10", substring.IndexOf (" <price>24.95</price>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <price>24.95</price>") != -1, "#A10");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#A11", substring.IndexOf (" </book>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </book>") != -1, "#A11");
substring = TextString;
- Assert ("#A12", substring.IndexOf ("</bookstore>") != -1);
+ Assert.IsTrue (substring.IndexOf ("</bookstore>") != -1, "#A12");
}
DataSet RegionDS = new DataSet ();
DataRow RegionRow;
RegionDS.ReadXmlSchema ("Test/System.Xml/region.xsd");
- AssertEquals ("Was read correct?", 1, RegionDS.Tables.Count);
+ Assert.AreEqual (1, RegionDS.Tables.Count, "Was read correct?");
XmlDataDocument DataDoc = new XmlDataDocument (RegionDS);
DataDoc.Load("Test/System.Xml/region.xml" );
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- //AssertEquals ("#B01", "<?xml version=\"1.0\" encoding=\"utf-16\" standalone=\"yes\"?>", substring);
+ //Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\" standalone=\"yes\"?>", substring, "#B01");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("#B02", "<Root>", substring);
+ Assert.AreEqual ("<Root>", substring, "#B02");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B03", substring.IndexOf (" <Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Region>") != -1, "#B03");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B04", substring.IndexOf (" <RegionID>1</RegionID>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionID>1</RegionID>") != -1, "#B04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("#B05", " <RegionDescription>Reeeeeaalllly Far East!</RegionDescription>", substring);
+ Assert.AreEqual (" <RegionDescription>Reeeeeaalllly Far East!</RegionDescription>", substring, "#B05");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B06", substring.IndexOf (" </Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </Region>") != -1, "#B06");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B07", substring.IndexOf (" <Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Region>") != -1, "#B07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B08", substring.IndexOf (" <RegionID>2</RegionID>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionID>2</RegionID>") != -1, "#B08");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B09", substring.IndexOf (" <RegionDescription>Western") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionDescription>Western") != -1, "#B09");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B10", substring.IndexOf (" </RegionDescription>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </RegionDescription>") != -1, "#B10");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B11", substring.IndexOf (" </Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </Region>") != -1, "#B11");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B12", substring.IndexOf (" <Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Region>") != -1, "#B12");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B13", substring.IndexOf (" <RegionID>3</RegionID>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionID>3</RegionID>") != -1, "#B13");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B14", substring.IndexOf (" <RegionDescription>Northern") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionDescription>Northern") != -1, "#B14");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B15", substring.IndexOf (" </RegionDescription>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </RegionDescription>") != -1, "#B15");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B16", substring.IndexOf (" </Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </Region>") != -1, "#B16");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B17", substring.IndexOf (" <Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Region>") != -1, "#B17");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B18", substring.IndexOf (" <RegionID>4</RegionID>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionID>4</RegionID>") != -1, "#B18");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B19", substring.IndexOf (" <RegionDescription>Southern") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionDescription>Southern") != -1, "#B19");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B20", substring.IndexOf (" </RegionDescription>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </RegionDescription>") != -1, "#B20");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B21", substring.IndexOf (" </Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </Region>") != -1, "#B21");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B22", substring.IndexOf (" <MoreData>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <MoreData>") != -1, "#B22");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B23", substring.IndexOf (" <Column1>12</Column1>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Column1>12</Column1>") != -1, "#B23");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B24", substring.IndexOf (" <Column2>Hi There</Column2>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Column2>Hi There</Column2>") != -1, "#B24");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B25", substring.IndexOf (" </MoreData>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </MoreData>") != -1, "#B25");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B26", substring.IndexOf (" <MoreData>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <MoreData>") != -1, "#B26");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B27", substring.IndexOf (" <Column1>12</Column1>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Column1>12</Column1>") != -1, "#B27");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B28", substring.IndexOf (" <Column2>Hi There</Column2>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Column2>Hi There</Column2>") != -1, "#B28");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#B29", substring.IndexOf (" </MoreData>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </MoreData>") != -1, "#B29");
}
[Test]
string substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#C01", substring.IndexOf ("<Root>") != -1);
+ Assert.IsTrue (substring.IndexOf ("<Root>") != -1, "#C01");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("#C02", " <Region />", substring);
+ Assert.AreEqual (" <Region />", substring, "#C02");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("#C03", " <Region>", substring);
+ Assert.AreEqual (" <Region>", substring, "#C03");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("#C04", " <RegionID>2</RegionID>", substring);
+ Assert.AreEqual (" <RegionID>2</RegionID>", substring, "#C04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// Regardless of NewLine value, original xml contains CR
// (but in the context of XML spec, it should be normalized)
- AssertEquals ("#C05", " <RegionDescription>Western\r", substring);
+ Assert.AreEqual (" <RegionDescription>Western\r", substring, "#C05");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#C06", substring.IndexOf (" </RegionDescription>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </RegionDescription>") != -1, "#C06");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("#C07", " </Region>", substring);
+ Assert.AreEqual (" </Region>", substring, "#C07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#C08", substring.IndexOf (" <Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Region>") != -1, "#C08");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#C09", substring.IndexOf (" <RegionID>3</RegionID>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionID>3</RegionID>") != -1, "#C09");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// Regardless of NewLine value, original xml contains CR
// (but in the context of XML spec, it should be normalized)
- AssertEquals ("#C10", " <RegionDescription>Northern\r", substring);
+ Assert.AreEqual (" <RegionDescription>Northern\r", substring, "#C10");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#C11", substring.IndexOf (" </RegionDescription>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </RegionDescription>") != -1, "#C11");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#C12", substring.IndexOf (" </Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </Region>") != -1, "#C12");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#C13", substring.IndexOf (" <Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Region>") != -1, "#C13");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#C14", substring.IndexOf (" <RegionID>4</RegionID>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionID>4</RegionID>") != -1, "#C14");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#C15", substring.IndexOf (" <RegionDescription>Southern") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionDescription>Southern") != -1, "#C15");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#C16", substring.IndexOf (" </RegionDescription>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </RegionDescription>") != -1, "#C16");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#C17", substring.IndexOf (" </Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </Region>") != -1, "#C17");
substring = TextString.Substring (0, TextString.Length);
- Assert ("#C18", substring.IndexOf ("</Root>") != -1);
+ Assert.IsTrue (substring.IndexOf ("</Root>") != -1, "#C18");
}
RegionDS.ReadXmlSchema ("Test/System.Xml/region.xsd");
XmlDataDocument DataDoc = new XmlDataDocument (RegionDS);
- DataDoc.Load("Test/System.Xml/region.xml" );
- AssertEquals (true, RegionDS.EnforceConstraints);
+ DataDoc.Load ("Test/System.Xml/region.xml");
+ Assert.IsTrue (RegionDS.EnforceConstraints);
DataTable table = DataDoc.DataSet.Tables ["Region"];
DataRow newRow = table.NewRow ();
newRow [0] = "new row";
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F02", substring.IndexOf ("<Root>") != -1);
+ Assert.IsTrue (substring.IndexOf ("<Root>") != -1, "#F02");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F03", substring.IndexOf (" <Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Region>") != -1, "#F03");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F04", substring.IndexOf (" <RegionID>1</RegionID>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionID>1</RegionID>") != -1, "#F04");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// Regardless of NewLine value, original xml contains CR
// (but in the context of XML spec, it should be normalized)
- AssertEquals ("#F05", " <RegionDescription>Eastern\r", substring);
+ Assert.AreEqual (" <RegionDescription>Eastern\r", substring, "#F05");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- AssertEquals ("#F06", " </RegionDescription>", substring);
+ Assert.AreEqual (" </RegionDescription>", substring, "#F06");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F07", substring.IndexOf (" </Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </Region>") != -1, "#F07");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F08", substring.IndexOf (" <Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Region>") != -1, "#F08");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F09", substring.IndexOf (" <RegionID>2</RegionID>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionID>2</RegionID>") != -1, "#F09");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F10", substring.IndexOf (" <RegionDescription>Western") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionDescription>Western") != -1, "#F10");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F11", substring.IndexOf (" </RegionDescription>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </RegionDescription>") != -1, "#F11");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F12", substring.IndexOf (" </Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </Region>") != -1, "#F12");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F13", substring.IndexOf (" <Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Region>") != -1, "#F13");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F14", substring.IndexOf (" <RegionID>3</RegionID>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionID>3</RegionID>") != -1, "#F14");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F15", substring.IndexOf (" <RegionDescription>Northern") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionDescription>Northern") != -1, "#F15");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F16", substring.IndexOf (" </RegionDescription>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </RegionDescription>") != -1, "#F16");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F17", substring.IndexOf (" </Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </Region>") != -1, "#F17");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F18", substring.IndexOf (" <Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Region>") != -1, "#F18");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F19", substring.IndexOf (" <RegionID>4</RegionID>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionID>4</RegionID>") != -1, "#F19");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
// Regardless of NewLine value, original xml contains CR
// (but in the context of XML spec, it should be normalized)
- AssertEquals ("#F20", " <RegionDescription>Southern\r", substring);
+ Assert.AreEqual (" <RegionDescription>Southern\r", substring, "#F20");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F21", substring.IndexOf (" </RegionDescription>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </RegionDescription>") != -1, "#F21");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F22", substring.IndexOf (" </Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </Region>") != -1, "#F22");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F23", substring.IndexOf (" <MoreData>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <MoreData>") != -1, "#F23");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F24", substring.IndexOf (" <Column1>12</Column1>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Column1>12</Column1>") != -1, "#F24");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F25", substring.IndexOf (" <Column2>Hi There</Column2>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Column2>Hi There</Column2>") != -1, "#F25");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F26", substring.IndexOf (" </MoreData>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </MoreData>") != -1, "#F26");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F27", substring.IndexOf (" <MoreData>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <MoreData>") != -1, "#F27");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F28", substring.IndexOf (" <Column1>12</Column1>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Column1>12</Column1>") != -1, "#F28");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F29", substring.IndexOf (" <Column2>Hi There</Column2>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Column2>Hi There</Column2>") != -1, "#F29");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F30", substring.IndexOf (" </MoreData>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </MoreData>") != -1, "#F30");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F31", substring.IndexOf (" <Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Region>") != -1, "#F31");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F32", substring.IndexOf (" <RegionID>new row</RegionID>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionID>new row</RegionID>") != -1, "#F32");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F33", substring.IndexOf (" <RegionDescription>new description</RegionDescription>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionDescription>new description</RegionDescription>") != -1, "#F33");
substring = TextString.Substring (0, TextString.IndexOf(EOL));
TextString = TextString.Substring (TextString.IndexOf(EOL) + EOL.Length);
- Assert ("#F34", substring.IndexOf (" </Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </Region>") != -1, "#F34");
substring = TextString.Substring (0, TextString.Length);
- Assert ("#F35", substring.IndexOf ("</Root>") != -1);
+ Assert.IsTrue (substring.IndexOf ("</Root>") != -1, "#F35");
}
[Test]
DataDoc.Load("Test/System.Xml/region.xml" );
try {
DataDoc.DocumentElement.AppendChild (DataDoc.DocumentElement.FirstChild);
- Fail ("#G01");
+ Assert.Fail ("#G01");
} catch (Exception e) {
- AssertEquals ("#G02", typeof (InvalidOperationException), e.GetType ());
- AssertEquals ("#G03", "Please set DataSet.EnforceConstraints == false before trying to edit " +
- "XmlDataDocument using XML operations.", e.Message);
+ Assert.AreEqual (typeof (InvalidOperationException), e.GetType (), "#G02");
+ Assert.AreEqual ("Please set DataSet.EnforceConstraints == false before trying to edit " +
+ "XmlDataDocument using XML operations.", e.Message, "#G03");
DataDoc.DataSet.EnforceConstraints = false;
}
XmlElement newNode = DataDoc.CreateElement ("Region");
substring = TextString.Substring (0, TextString.IndexOf("\n"));
TextString = TextString.Substring (TextString.IndexOf("\n") + 1);
}
- Assert ("#G04", substring.IndexOf (" <Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Region>") != -1, "#G04");
substring = TextString.Substring (0, TextString.IndexOf("\n"));
TextString = TextString.Substring (TextString.IndexOf("\n") + 1);
- Assert ("#G05", substring.IndexOf (" <RegionID>64</RegionID>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionID>64</RegionID>") != -1, "#G05");
substring = TextString.Substring (0, TextString.IndexOf("\n"));
TextString = TextString.Substring (TextString.IndexOf("\n") + 1);
- Assert ("#G06", substring.IndexOf (" <RegionDescription>test node</RegionDescription>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionDescription>test node</RegionDescription>") != -1, "#G06");
substring = TextString.Substring (0, TextString.IndexOf("\n"));
TextString = TextString.Substring (TextString.IndexOf("\n") + 1);
- Assert ("#G07", substring.IndexOf (" </Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </Region>") != -1, "#G07");
substring = TextString.Substring (0, TextString.Length);
- Assert ("#G08", substring.IndexOf ("</Root>") != -1);
+ Assert.IsTrue (substring.IndexOf ("</Root>") != -1, "#G08");
}
XmlElement newChildNode2 = null;
try {
newChildNode2 = DataDoc.CreateElement ("something else");
- Fail ("#H01");
+ Assert.Fail ("#H01");
} catch (XmlException) {
}
newChildNode2 = DataDoc.CreateElement ("something_else");
TextString = TextString.Substring (TextString.IndexOf("\n") + 1);
}
- Assert ("#H03", substring.IndexOf (" <Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <Region>") != -1, "#H03");
substring = TextString.Substring (0, TextString.IndexOf("\n"));
TextString = TextString.Substring (TextString.IndexOf("\n") + 1);
- Assert ("#H04", substring.IndexOf (" <RegionID>64</RegionID>") != -1);
+ Assert.IsTrue (substring.IndexOf (" <RegionID>64</RegionID>") != -1, "#H04");
substring = TextString.Substring (0, TextString.IndexOf("\n") );
TextString = TextString.Substring (TextString.IndexOf("\n") + 1);
- Assert ("#H05", substring.IndexOf (" </Region>") != -1);
+ Assert.IsTrue (substring.IndexOf (" </Region>") != -1, "#H05");
substring = TextString.Substring (0, TextString.Length);
- Assert ("#H06", substring.IndexOf ("</Root>") != -1);
+ Assert.IsTrue (substring.IndexOf ("</Root>") != -1, "#H06");
}
DataTable table = doc.DataSet.Tables ["Region"];
XmlElement element = doc.GetElementFromRow (table.Rows [2]);
- AssertEquals ("#D01", "Region", element.Name);
- AssertEquals ("#D02", "3", element ["RegionID"].InnerText);
+ Assert.AreEqual ("Region", element.Name, "#D01");
+ Assert.AreEqual ("3", element ["RegionID"].InnerText, "#D02");
try {
element = doc.GetElementFromRow (table.Rows [4]);
- Fail ("#D03");
+ Assert.Fail ("#D03");
} catch (Exception e) {
- AssertEquals ("#D04", typeof (IndexOutOfRangeException), e.GetType ());
- AssertEquals ("#D05", "There is no row at position 4.", e.Message);
+ Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (), "#D04");
+ Assert.AreEqual ("There is no row at position 4.", e.Message, "#D05");
}
}
DataRow row = doc.GetRowFromElement((XmlElement)root.FirstChild);
- AssertEquals ("#E01", "1", row [0]);
+ Assert.AreEqual ("1", row [0], "#E01");
row = doc.GetRowFromElement((XmlElement)root.ChildNodes [2]);
- AssertEquals ("#E02", "3", row [0]);
+ Assert.AreEqual ("3", row [0], "#E02");
}
}
projects / mono.git / commitdiff