Welcome to mirror list, hosted at ThFree Co, Russian Federation.

github.com/mono/mono.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/mcs/class/System.Data/Test
diff options
context:
space:
mode:
authorAtsushi Eno <atsushieno@gmail.com>2009-07-13 11:52:51 +0400
committerAtsushi Eno <atsushieno@gmail.com>2009-07-13 11:52:51 +0400
commitf28350170e5ac133c9f3c07f0fe49f0bbcb681e8 (patch)
tree321101440de7470f3d81b7cab2fae1ae1f3ca650 /mcs/class/System.Data/Test
parentbb4cd0d150a8c5e1ae9caffaf5f0b89e93816cf7 (diff)
migration to newer nunit style.
svn path=/trunk/mcs/; revision=137768
Diffstat (limited to 'mcs/class/System.Data/Test')
-rw-r--r--mcs/class/System.Data/Test/System.Data.Common/ChangeLog6
-rw-r--r--mcs/class/System.Data/Test/System.Data.Common/DataColumnMappingCollectionTest.cs198
-rw-r--r--mcs/class/System.Data/Test/System.Data.Common/DataContainerTest.cs2
-rw-r--r--mcs/class/System.Data/Test/System.Data.Common/DataTableMappingCollectionTest.cs196
-rw-r--r--mcs/class/System.Data/Test/System.Data.Odbc/ChangeLog4
-rw-r--r--mcs/class/System.Data/Test/System.Data.Odbc/OdbcDataReaderTest.cs60
-rw-r--r--mcs/class/System.Data/Test/System.Data.SqlTypes/ChangeLog5
-rw-r--r--mcs/class/System.Data/Test/System.Data.SqlTypes/SqlBinaryTest.cs141
-rw-r--r--mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDateTimeTest.cs413
-rw-r--r--mcs/class/System.Data/Test/System.Data.SqlTypes/SqlGuidTest.cs184
10 files changed, 593 insertions, 616 deletions
diff --git a/mcs/class/System.Data/Test/System.Data.Common/ChangeLog b/mcs/class/System.Data/Test/System.Data.Common/ChangeLog
index 1ea95d8564d..f9d2261c8ae 100644
--- a/mcs/class/System.Data/Test/System.Data.Common/ChangeLog
+++ b/mcs/class/System.Data/Test/System.Data.Common/ChangeLog
@@ -1,3 +1,9 @@
+2009-07-13 Atsushi Enomoto <atsushi@ximian.com>
+
+ * DataContainerTest.cs, DataColumnMappingCollectionTest.cs,
+ DataTableMappingCollectionTest.cs :
+ migration to newer nunit style.
+
2009-01-03 Gert Driesen <drieseng@users.sourceforge.net>
* DbCommandBuilderTest.cs: Added test for QuoteIdentifier.
diff --git a/mcs/class/System.Data/Test/System.Data.Common/DataColumnMappingCollectionTest.cs b/mcs/class/System.Data/Test/System.Data.Common/DataColumnMappingCollectionTest.cs
index ce061c744be..d34d6d46076 100644
--- a/mcs/class/System.Data/Test/System.Data.Common/DataColumnMappingCollectionTest.cs
+++ b/mcs/class/System.Data/Test/System.Data.Common/DataColumnMappingCollectionTest.cs
@@ -36,7 +36,7 @@ using System.Data.Common;
namespace MonoTests.System.Data.Common
{
[TestFixture]
- public class DataColumnMappingCollectionTest : Assertion
+ public class DataColumnMappingCollectionTest
{
//DataTableMapping tableMap;
DataColumnMappingCollection columnMapCollection;
@@ -46,11 +46,11 @@ namespace MonoTests.System.Data.Common
public void GetReady()
{
cols=new DataColumnMapping[5];
- cols[0]=new DataColumnMapping("sourceName","dataSetName");
- cols[1]=new DataColumnMapping("sourceID","dataSetID");
- cols[2]=new DataColumnMapping("sourceAddress","dataSetAddress");
- cols[3]=new DataColumnMapping("sourcePhone","dataSetPhone");
- cols[4]=new DataColumnMapping("sourcePIN","dataSetPIN");
+ cols[0]=new DataColumnMapping("sourceName", "dataSetName");
+ cols[1]=new DataColumnMapping("sourceID", "dataSetID");
+ cols[2]=new DataColumnMapping("sourceAddress", "dataSetAddress");
+ cols[3]=new DataColumnMapping("sourcePhone", "dataSetPhone");
+ cols[4]=new DataColumnMapping("sourcePIN", "dataSetPIN");
columnMapCollection=new DataColumnMappingCollection();
}
@@ -63,17 +63,17 @@ namespace MonoTests.System.Data.Common
[Test]
public void Add()
{
- DataColumnMapping col1=new DataColumnMapping("sourceName","dataSetName");
+ DataColumnMapping col1=new DataColumnMapping("sourceName", "dataSetName");
int t=columnMapCollection.Add((Object)col1);
- AssertEquals("test1",0,t);
+ Assert.AreEqual (0, t, "test1");
bool eq1=col1.Equals(columnMapCollection[0]);
- AssertEquals("test2",true,eq1);
- AssertEquals("test3",1,columnMapCollection.Count);
+ Assert.AreEqual (true, eq1, "test2");
+ Assert.AreEqual (1, columnMapCollection.Count, "test3");
DataColumnMapping col2;
- col2=columnMapCollection.Add("sourceID","dataSetID");
+ col2=columnMapCollection.Add("sourceID", "dataSetID");
bool eq2=col2.Equals(columnMapCollection[1]);
- AssertEquals("test4",true,eq2);
- AssertEquals("test5",2,columnMapCollection.Count);
+ Assert.AreEqual (true, eq2, "test4");
+ Assert.AreEqual (2, columnMapCollection.Count, "test5");
}
[Test]
@@ -87,65 +87,65 @@ namespace MonoTests.System.Data.Common
[Test]
public void AddRange()
{
- columnMapCollection.Add(new DataColumnMapping("sourceAge","dataSetAge"));
- AssertEquals("test1",1,columnMapCollection.Count);
+ columnMapCollection.Add(new DataColumnMapping("sourceAge", "dataSetAge"));
+ Assert.AreEqual (1, columnMapCollection.Count, "test1");
columnMapCollection.AddRange(cols);
- AssertEquals("test2",6,columnMapCollection.Count);
+ Assert.AreEqual (6, columnMapCollection.Count, "test2");
bool eq;
eq=cols[0].Equals(columnMapCollection[1]);
- AssertEquals("test3",true,eq);
+ Assert.AreEqual (true, eq, "test3");
eq=cols[1].Equals(columnMapCollection[2]);
- AssertEquals("test4",true,eq);
+ Assert.AreEqual (true, eq, "test4");
eq=cols[0].Equals(columnMapCollection[0]);
- AssertEquals("test5",false,eq);
+ Assert.AreEqual (false, eq, "test5");
eq=cols[1].Equals(columnMapCollection[0]);
- AssertEquals("test6",false,eq);
+ Assert.AreEqual (false, eq, "test6");
}
[Test]
public void Clear()
{
- DataColumnMapping col1=new DataColumnMapping("sourceName","dataSetName");
+ DataColumnMapping col1=new DataColumnMapping("sourceName", "dataSetName");
columnMapCollection.Add((Object)col1);
- AssertEquals("test1",1,columnMapCollection.Count);
+ Assert.AreEqual (1, columnMapCollection.Count, "test1");
columnMapCollection.Clear();
- AssertEquals("test2",0,columnMapCollection.Count);
+ Assert.AreEqual (0, columnMapCollection.Count, "test2");
columnMapCollection.AddRange(cols);
- AssertEquals("test3",5,columnMapCollection.Count);
+ Assert.AreEqual (5, columnMapCollection.Count, "test3");
columnMapCollection.Clear();
- AssertEquals("test4",0,columnMapCollection.Count);
+ Assert.AreEqual (0, columnMapCollection.Count, "test4");
}
[Test]
public void Contains()
{
- DataColumnMapping col1=new DataColumnMapping("sourceName","dataSetName");
+ DataColumnMapping col1=new DataColumnMapping("sourceName", "dataSetName");
columnMapCollection.AddRange(cols);
bool eq;
eq=columnMapCollection.Contains((Object)cols[0]);
- AssertEquals("test1",true,eq);
+ Assert.AreEqual (true, eq, "test1");
eq=columnMapCollection.Contains((Object)cols[1]);
- AssertEquals("test2",true,eq);
+ Assert.AreEqual (true, eq, "test2");
eq=columnMapCollection.Contains((Object)col1);
- AssertEquals("test3",false,eq);
+ Assert.AreEqual (false, eq, "test3");
eq=columnMapCollection.Contains(cols[0].SourceColumn);
- AssertEquals("test4",true,eq);
+ Assert.AreEqual (true, eq, "test4");
eq=columnMapCollection.Contains(cols[1].SourceColumn);
- AssertEquals("test5",true,eq);
+ Assert.AreEqual (true, eq, "test5");
eq=columnMapCollection.Contains(col1.SourceColumn);
- AssertEquals("test6",true,eq);
+ Assert.AreEqual (true, eq, "test6");
eq=columnMapCollection.Contains(cols[0].DataSetColumn);
- AssertEquals("test7",false,eq);
+ Assert.AreEqual (false, eq, "test7");
eq=columnMapCollection.Contains(cols[1].DataSetColumn);
- AssertEquals("test8",false,eq);
+ Assert.AreEqual (false, eq, "test8");
eq=columnMapCollection.Contains(col1.DataSetColumn);
- AssertEquals("test9",false,eq);
+ Assert.AreEqual (false, eq, "test9");
}
[Test]
@@ -161,25 +161,25 @@ namespace MonoTests.System.Data.Common
{
DataColumnMapping [] colcops=new DataColumnMapping[5];
columnMapCollection.AddRange(cols);
- columnMapCollection.CopyTo(colcops,0);
+ columnMapCollection.CopyTo(colcops, 0);
bool eq;
for (int i=0;i<5;i++)
{
eq=columnMapCollection[i].Equals(colcops[i]);
- AssertEquals("test1"+i,true,eq);
+ Assert.AreEqual (true, eq, "test1" + i);
}
colcops=null;
colcops=new DataColumnMapping[7];
- columnMapCollection.CopyTo(colcops,2);
+ columnMapCollection.CopyTo(colcops, 2);
for (int i=0;i<5;i++)
{
eq=columnMapCollection[i].Equals(colcops[i+2]);
- AssertEquals("test2"+i,true,eq);
+ Assert.AreEqual (true, eq, "test2" + i);
}
eq=columnMapCollection[0].Equals(colcops[0]);
- AssertEquals("test31",false,eq);
+ Assert.AreEqual (false, eq, "test31");
eq=columnMapCollection[0].Equals(colcops[1]);
- AssertEquals("test32",false,eq);
+ Assert.AreEqual (false, eq, "test32");
}
[Test]
@@ -191,31 +191,31 @@ namespace MonoTests.System.Data.Common
DataColumnMappingCollection copy1;
copy1=columnMapCollection;
-// AssertEquals("test1",false,columnMapCollection.Equals(collect2));
- AssertEquals("test2",true,columnMapCollection.Equals(copy1));
-// AssertEquals("test3",false,collect2.Equals(columnMapCollection));
- AssertEquals("test4",true,copy1.Equals(columnMapCollection));
-// AssertEquals("test5",false,collect2.Equals(copy1));
- AssertEquals("test6",true,copy1.Equals(columnMapCollection));
- AssertEquals("test7",true,columnMapCollection.Equals(columnMapCollection));
-// AssertEquals("test8",true,collect2.Equals(collect2));
- AssertEquals("test9",true,copy1.Equals(copy1));
+// Assert.AreEqual (false, columnMapCollection.Equals(collect2), "test1");
+ Assert.AreEqual (true, columnMapCollection.Equals(copy1), "test2");
+// Assert.AreEqual (false, collect2.Equals(columnMapCollection), "test3");
+ Assert.AreEqual (true, copy1.Equals(columnMapCollection), "test4");
+// Assert.AreEqual (false, collect2.Equals(copy1), "test5");
+ Assert.AreEqual (true, copy1.Equals(columnMapCollection), "test6");
+ Assert.AreEqual (true, columnMapCollection.Equals(columnMapCollection), "test7");
+// Assert.AreEqual (true, collect2.Equals(collect2), "test8");
+ Assert.AreEqual (true, copy1.Equals(copy1), "test9");
-// AssertEquals("test10",false,Object.Equals(collect2,columnMapCollection));
- AssertEquals("test11",true,Object.Equals(copy1,columnMapCollection));
-// AssertEquals("test12",false,Object.Equals(columnMapCollection,collect2));
- AssertEquals("test13",true,Object.Equals(columnMapCollection,copy1));
-// AssertEquals("test14",false,Object.Equals(copy1,collect2));
- AssertEquals("test15",true,Object.Equals(columnMapCollection,copy1));
- AssertEquals("test16",true,Object.Equals(columnMapCollection,columnMapCollection));
-// AssertEquals("test17",true,Object.Equals(collect2,collect2));
- AssertEquals("test18",true,Object.Equals(copy1,copy1));
-// AssertEquals("test10",false,Object.Equals(columnMapCollection,collect2));
- AssertEquals("test11",true,Object.Equals(columnMapCollection,copy1));
-// AssertEquals("test12",false,Object.Equals(collect2,columnMapCollection));
- AssertEquals("test13",true,Object.Equals(copy1,columnMapCollection));
-// AssertEquals("test14",false,Object.Equals(collect2,copy1));
- AssertEquals("test15",true,Object.Equals(copy1,columnMapCollection));
+// Assert.AreEqual (false, Object.Equals(collect2, columnMapCollection), "test10");
+ Assert.AreEqual (true, Object.Equals(copy1, columnMapCollection), "test11");
+// Assert.AreEqual (false, Object.Equals(columnMapCollection, collect2), "test12");
+ Assert.AreEqual (true, Object.Equals(columnMapCollection, copy1), "test13");
+// Assert.AreEqual (false, Object.Equals(copy1, collect2), "test14");
+ Assert.AreEqual (true, Object.Equals(columnMapCollection, copy1), "test15");
+ Assert.AreEqual (true, Object.Equals(columnMapCollection, columnMapCollection), "test16");
+// Assert.AreEqual (true, Object.Equals(collect2, collect2), "test17");
+ Assert.AreEqual (true, Object.Equals(copy1, copy1), "test18");
+// Assert.AreEqual (false, Object.Equals(columnMapCollection, collect2), "test10");
+ Assert.AreEqual (true, Object.Equals(columnMapCollection, copy1), "test11");
+// Assert.AreEqual (false, Object.Equals(collect2, columnMapCollection), "test12");
+ Assert.AreEqual (true, Object.Equals(copy1, columnMapCollection), "test13");
+// Assert.AreEqual (false, Object.Equals(collect2, copy1), "test14");
+ Assert.AreEqual (true, Object.Equals(copy1, columnMapCollection), "test15");
}
[Test]
@@ -226,17 +226,17 @@ namespace MonoTests.System.Data.Common
DataColumnMapping col1;
col1=columnMapCollection.GetByDataSetColumn("dataSetName");
eq=(col1.DataSetColumn.Equals("dataSetName") && col1.SourceColumn.Equals("sourceName"));
- AssertEquals("test1",true,eq);
+ Assert.AreEqual (true, eq, "test1");
col1=columnMapCollection.GetByDataSetColumn("dataSetID");
eq=(col1.DataSetColumn.Equals("dataSetID") && col1.SourceColumn.Equals("sourceID"));
- AssertEquals("test2",true,eq);
+ Assert.AreEqual (true, eq, "test2");
col1=columnMapCollection.GetByDataSetColumn("datasetname");
eq=(col1.DataSetColumn.Equals("dataSetName") && col1.SourceColumn.Equals("sourceName"));
- AssertEquals("test3",true,eq);
+ Assert.AreEqual (true, eq, "test3");
col1=columnMapCollection.GetByDataSetColumn("datasetid");
eq=(col1.DataSetColumn.Equals("dataSetID") && col1.SourceColumn.Equals("sourceID"));
- AssertEquals("test4",true,eq);
+ Assert.AreEqual (true, eq, "test4");
}
[Test]
@@ -245,27 +245,27 @@ namespace MonoTests.System.Data.Common
columnMapCollection.AddRange(cols);
bool eq;
DataColumnMapping col1;
- col1=DataColumnMappingCollection.GetColumnMappingBySchemaAction(columnMapCollection,"sourceName",MissingMappingAction.Passthrough);
+ col1=DataColumnMappingCollection.GetColumnMappingBySchemaAction(columnMapCollection, "sourceName", MissingMappingAction.Passthrough);
eq=(col1.DataSetColumn.Equals("dataSetName") && col1.SourceColumn.Equals("sourceName"));
- AssertEquals("test1",true,eq);
- col1=DataColumnMappingCollection.GetColumnMappingBySchemaAction(columnMapCollection,"sourceID",MissingMappingAction.Passthrough);
+ Assert.AreEqual (true, eq, "test1");
+ col1=DataColumnMappingCollection.GetColumnMappingBySchemaAction(columnMapCollection, "sourceID", MissingMappingAction.Passthrough);
eq=(col1.DataSetColumn.Equals("dataSetID") && col1.SourceColumn.Equals("sourceID"));
- AssertEquals("test2",true,eq);
+ Assert.AreEqual (true, eq, "test2");
- col1=DataColumnMappingCollection.GetColumnMappingBySchemaAction(columnMapCollection,"sourceData",MissingMappingAction.Passthrough);
+ col1=DataColumnMappingCollection.GetColumnMappingBySchemaAction(columnMapCollection, "sourceData", MissingMappingAction.Passthrough);
eq=(col1.DataSetColumn.Equals("sourceData") && col1.SourceColumn.Equals("sourceData"));
- AssertEquals("test3",true,eq);
+ Assert.AreEqual (true, eq, "test3");
eq=columnMapCollection.Contains(col1);
- AssertEquals("test4",false,eq);
- col1=DataColumnMappingCollection.GetColumnMappingBySchemaAction(columnMapCollection,"sourceData",MissingMappingAction.Ignore);
- AssertEquals("test5",null,col1);
+ Assert.AreEqual (false, eq, "test4");
+ col1=DataColumnMappingCollection.GetColumnMappingBySchemaAction(columnMapCollection, "sourceData", MissingMappingAction.Ignore);
+ Assert.AreEqual (null, col1, "test5");
}
[Test]
[ExpectedException(typeof(InvalidOperationException))]
public void GetColumnMappingBySchemaActionException1()
{
- DataColumnMappingCollection.GetColumnMappingBySchemaAction(columnMapCollection,"sourceName",MissingMappingAction.Error);
+ DataColumnMappingCollection.GetColumnMappingBySchemaAction(columnMapCollection, "sourceName", MissingMappingAction.Error);
}
[Test]
@@ -274,14 +274,14 @@ namespace MonoTests.System.Data.Common
columnMapCollection.AddRange(cols);
int ind;
ind=columnMapCollection.IndexOf(cols[0]);
- AssertEquals("test1",0,ind);
+ Assert.AreEqual (0, ind, "test1");
ind=columnMapCollection.IndexOf(cols[1]);
- AssertEquals("test2",1,ind);
+ Assert.AreEqual (1, ind, "test2");
ind=columnMapCollection.IndexOf(cols[0].SourceColumn);
- AssertEquals("test3",0,ind);
+ Assert.AreEqual (0, ind, "test3");
ind=columnMapCollection.IndexOf(cols[1].SourceColumn);
- AssertEquals("test4",1,ind);
+ Assert.AreEqual (1, ind, "test4");
}
[Test]
@@ -290,27 +290,27 @@ namespace MonoTests.System.Data.Common
columnMapCollection.AddRange(cols);
int ind;
ind=columnMapCollection.IndexOfDataSetColumn(cols[0].DataSetColumn);
- AssertEquals("test1",0,ind);
+ Assert.AreEqual (0, ind, "test1");
ind=columnMapCollection.IndexOfDataSetColumn(cols[1].DataSetColumn);
- AssertEquals("test2",1,ind);
+ Assert.AreEqual (1, ind, "test2");
ind=columnMapCollection.IndexOfDataSetColumn("datasetname");
- AssertEquals("test3",0,ind);
+ Assert.AreEqual (0, ind, "test3");
ind=columnMapCollection.IndexOfDataSetColumn("datasetid");
- AssertEquals("test4",1,ind);
+ Assert.AreEqual (1, ind, "test4");
ind=columnMapCollection.IndexOfDataSetColumn("sourcedeter");
- AssertEquals("test5",-1,ind);
+ Assert.AreEqual (-1, ind, "test5");
}
[Test]
public void Insert()
{
columnMapCollection.AddRange(cols);
- DataColumnMapping mymap=new DataColumnMapping("sourceAge","dataSetAge");
- columnMapCollection.Insert(3,mymap);
+ DataColumnMapping mymap=new DataColumnMapping("sourceAge", "dataSetAge");
+ columnMapCollection.Insert(3, mymap);
int ind=columnMapCollection.IndexOfDataSetColumn("dataSetAge");
- AssertEquals("test1",3,ind);
+ Assert.AreEqual (3, ind, "test1");
}
[Test]
@@ -318,11 +318,11 @@ namespace MonoTests.System.Data.Common
public void Remove()
{
columnMapCollection.AddRange(cols);
- DataColumnMapping mymap=new DataColumnMapping("sourceName","dataSetName");
+ DataColumnMapping mymap=new DataColumnMapping("sourceName", "dataSetName");
columnMapCollection.Add(mymap);
columnMapCollection.Remove((Object)mymap);
bool eq=columnMapCollection.Contains((Object)mymap);
- AssertEquals("test1",false,eq);
+ Assert.AreEqual (false, eq, "test1");
}
[Test]
@@ -339,7 +339,7 @@ namespace MonoTests.System.Data.Common
public void RemoveException2()
{
columnMapCollection.AddRange(cols);
- DataColumnMapping mymap=new DataColumnMapping("sourceAge","dataSetAge");
+ DataColumnMapping mymap=new DataColumnMapping("sourceAge", "dataSetAge");
columnMapCollection.Remove(mymap);
}
@@ -350,15 +350,15 @@ namespace MonoTests.System.Data.Common
bool eq;
columnMapCollection.RemoveAt(0);
eq=columnMapCollection.Contains(cols[0]);
- AssertEquals("test1",false,eq);
+ Assert.AreEqual (false, eq, "test1");
eq=columnMapCollection.Contains(cols[1]);
- AssertEquals("test2",true,eq);
+ Assert.AreEqual (true, eq, "test2");
columnMapCollection.RemoveAt("sourceID");
eq=columnMapCollection.Contains(cols[1]);
- AssertEquals("test3",false,eq);
+ Assert.AreEqual (false, eq, "test3");
eq=columnMapCollection.Contains(cols[2]);
- AssertEquals("test4",true,eq);
+ Assert.AreEqual (true, eq, "test4");
}
[Test]
@@ -381,7 +381,7 @@ namespace MonoTests.System.Data.Common
#endif
public void ToStringTest()
{
- AssertEquals("test1","System.Data.Common.DataColumnMappingCollection",columnMapCollection.ToString());
+ Assert.AreEqual ("System.Data.Common.DataColumnMappingCollection", columnMapCollection.ToString(), "test1");
}
}
}
diff --git a/mcs/class/System.Data/Test/System.Data.Common/DataContainerTest.cs b/mcs/class/System.Data/Test/System.Data.Common/DataContainerTest.cs
index 353b099d905..cf0ec82d7e3 100644
--- a/mcs/class/System.Data/Test/System.Data.Common/DataContainerTest.cs
+++ b/mcs/class/System.Data/Test/System.Data.Common/DataContainerTest.cs
@@ -61,7 +61,7 @@ namespace MonoTests.System.Data.Common
DataTable dt = new DataTable ();
myadapter.Fill (dt);
- Assertion.AssertEquals ("Row count must be three", 3, dt.Rows.Count);
+ Assert.AreEqual (3, dt.Rows.Count, "Row count must be three");
} finally {
CleanTestSetup ();
CloseConnection ();
diff --git a/mcs/class/System.Data/Test/System.Data.Common/DataTableMappingCollectionTest.cs b/mcs/class/System.Data/Test/System.Data.Common/DataTableMappingCollectionTest.cs
index e9b2be98fe6..a14c3f85ab3 100644
--- a/mcs/class/System.Data/Test/System.Data.Common/DataTableMappingCollectionTest.cs
+++ b/mcs/class/System.Data/Test/System.Data.Common/DataTableMappingCollectionTest.cs
@@ -36,7 +36,7 @@ using System.Data.Common;
namespace MonoTests.System.Data.Common
{
[TestFixture]
- public class DataTableMappingCollectionTest : Assertion
+ public class DataTableMappingCollectionTest
{
DataTableMappingCollection tableMapCollection;
DataTableMapping [] tabs;
@@ -44,11 +44,11 @@ namespace MonoTests.System.Data.Common
public void GetReady()
{
tabs=new DataTableMapping[5];
- tabs[0]=new DataTableMapping("sourceCustomers","dataSetCustomers");
- tabs[1]=new DataTableMapping("sourceEmployees","dataSetEmployees");
- tabs[2]=new DataTableMapping("sourceBooks","dataSetBooks");
- tabs[3]=new DataTableMapping("sourceStore","dataSetStore");
- tabs[4]=new DataTableMapping("sourceInventory","dataSetInventory");
+ tabs[0]=new DataTableMapping("sourceCustomers", "dataSetCustomers");
+ tabs[1]=new DataTableMapping("sourceEmployees", "dataSetEmployees");
+ tabs[2]=new DataTableMapping("sourceBooks", "dataSetBooks");
+ tabs[3]=new DataTableMapping("sourceStore", "dataSetStore");
+ tabs[4]=new DataTableMapping("sourceInventory", "dataSetInventory");
tableMapCollection=new DataTableMappingCollection();
}
@@ -62,15 +62,15 @@ namespace MonoTests.System.Data.Common
public void Add()
{
int t=tableMapCollection.Add((Object)tabs[0]);
- AssertEquals("test1",0,t);
+ Assert.AreEqual(0, t, "test1");
bool eq1=tabs[0].Equals(tableMapCollection[0]);
- AssertEquals("test2",true,eq1);
- AssertEquals("test3",1,tableMapCollection.Count);
+ Assert.AreEqual(true, eq1, "test2");
+ Assert.AreEqual(1, tableMapCollection.Count, "test3");
DataTableMapping tab2;
- tab2=tableMapCollection.Add("sourceEmployees","dataSetEmployees");
+ tab2=tableMapCollection.Add("sourceEmployees", "dataSetEmployees");
bool eq2=tab2.Equals(tableMapCollection[1]);
- AssertEquals("test4",true,eq2);
- AssertEquals("test5",2,tableMapCollection.Count);
+ Assert.AreEqual(true, eq2, "test4");
+ Assert.AreEqual(2, tableMapCollection.Count, "test5");
}
[Test]
@@ -84,59 +84,59 @@ namespace MonoTests.System.Data.Common
[Test]
public void AddRange()
{
- tableMapCollection.Add(new DataTableMapping("sourceFactory","dataSetFactory"));
- AssertEquals("test1",1,tableMapCollection.Count);
+ tableMapCollection.Add(new DataTableMapping("sourceFactory", "dataSetFactory"));
+ Assert.AreEqual(1, tableMapCollection.Count, "test1");
tableMapCollection.AddRange(tabs);
- AssertEquals("test2",6,tableMapCollection.Count);
+ Assert.AreEqual(6, tableMapCollection.Count, "test2");
bool eq;
eq=tabs[0].Equals(tableMapCollection[1]);
- AssertEquals("test3",true,eq);
+ Assert.AreEqual(true, eq, "test3");
eq=tabs[1].Equals(tableMapCollection[2]);
- AssertEquals("test4",true,eq);
+ Assert.AreEqual(true, eq, "test4");
eq=tabs[0].Equals(tableMapCollection[0]);
- AssertEquals("test5",false,eq);
+ Assert.AreEqual(false, eq, "test5");
eq=tabs[1].Equals(tableMapCollection[0]);
- AssertEquals("test6",false,eq);
+ Assert.AreEqual(false, eq, "test6");
}
[Test]
public void Clear()
{
- DataTableMapping tab1=new DataTableMapping("sourceSuppliers","dataSetSuppliers");
+ DataTableMapping tab1=new DataTableMapping("sourceSuppliers", "dataSetSuppliers");
tableMapCollection.Add((Object)tab1);
- AssertEquals("test1",1,tableMapCollection.Count);
+ Assert.AreEqual(1, tableMapCollection.Count, "test1");
tableMapCollection.Clear();
- AssertEquals("test2",0,tableMapCollection.Count);
+ Assert.AreEqual(0, tableMapCollection.Count, "test2");
tableMapCollection.AddRange(tabs);
- AssertEquals("test3",5,tableMapCollection.Count);
+ Assert.AreEqual(5, tableMapCollection.Count, "test3");
tableMapCollection.Clear();
- AssertEquals("test4",0,tableMapCollection.Count);
+ Assert.AreEqual(0, tableMapCollection.Count, "test4");
}
[Test]
public void Contains()
{
- DataTableMapping tab1=new DataTableMapping("sourceCustomers","dataSetCustomers");
+ DataTableMapping tab1=new DataTableMapping("sourceCustomers", "dataSetCustomers");
tableMapCollection.AddRange(tabs);
bool eq;
eq=tableMapCollection.Contains((Object)tabs[0]);
- AssertEquals("test1",true,eq);
+ Assert.AreEqual(true, eq, "test1");
eq=tableMapCollection.Contains((Object)tabs[1]);
- AssertEquals("test2",true,eq);
+ Assert.AreEqual(true, eq, "test2");
eq=tableMapCollection.Contains((Object)tab1);
- AssertEquals("test3",false,eq);
+ Assert.AreEqual(false, eq, "test3");
eq=tableMapCollection.Contains(tabs[0].SourceTable);
- AssertEquals("test4",true,eq);
+ Assert.AreEqual(true, eq, "test4");
eq=tableMapCollection.Contains(tabs[1].SourceTable);
- AssertEquals("test5",true,eq);
+ Assert.AreEqual(true, eq, "test5");
eq=tableMapCollection.Contains(tab1.SourceTable);
- AssertEquals("test6",true,eq);
+ Assert.AreEqual(true, eq, "test6");
eq=tableMapCollection.Contains(tabs[0].DataSetTable);
- AssertEquals("test7",false,eq);
+ Assert.AreEqual(false, eq, "test7");
eq=tableMapCollection.Contains(tabs[1].DataSetTable);
- AssertEquals("test8",false,eq);
+ Assert.AreEqual(false, eq, "test8");
eq=tableMapCollection.Contains(tab1.DataSetTable);
- AssertEquals("test9",false,eq);
+ Assert.AreEqual(false, eq, "test9");
}
[Test]
@@ -144,25 +144,25 @@ namespace MonoTests.System.Data.Common
{
DataTableMapping [] tabcops=new DataTableMapping[5];
tableMapCollection.AddRange(tabs);
- tableMapCollection.CopyTo(tabcops,0);
+ tableMapCollection.CopyTo(tabcops, 0);
bool eq;
for (int i=0;i<5;i++)
{
eq=tableMapCollection[i].Equals(tabcops[i]);
- AssertEquals("test1"+i,true,eq);
+ Assert.AreEqual (true, eq, "test1" + i);
}
tabcops=null;
tabcops=new DataTableMapping[7];
- tableMapCollection.CopyTo(tabcops,2);
+ tableMapCollection.CopyTo(tabcops, 2);
for (int i=0;i<5;i++)
{
eq=tableMapCollection[i].Equals(tabcops[i+2]);
- AssertEquals("test2"+i,true,eq);
+ Assert.AreEqual (true, eq, "test2" + i);
}
eq=tableMapCollection[0].Equals(tabcops[0]);
- AssertEquals("test31",false,eq);
+ Assert.AreEqual (false, eq, "test31");
eq=tableMapCollection[0].Equals(tabcops[1]);
- AssertEquals("test32",false,eq);
+ Assert.AreEqual (false, eq, "test32");
}
[Test]
@@ -174,31 +174,31 @@ namespace MonoTests.System.Data.Common
DataTableMappingCollection copy1;
copy1=tableMapCollection;
-// AssertEquals("test1",false,tableMapCollection.Equals(collect2));
- AssertEquals("test2",true,tableMapCollection.Equals(copy1));
-// AssertEquals("test3",false,collect2.Equals(tableMapCollection));
- AssertEquals("test4",true,copy1.Equals(tableMapCollection));
-// AssertEquals("test5",false,collect2.Equals(copy1));
- AssertEquals("test6",true,copy1.Equals(tableMapCollection));
- AssertEquals("test7",true,tableMapCollection.Equals(tableMapCollection));
-// AssertEquals("test8",true,collect2.Equals(collect2));
- AssertEquals("test9",true,copy1.Equals(copy1));
+// Assert.AreEqual(false, tableMapCollection.Equals(collect2), "test1");
+ Assert.AreEqual(true, tableMapCollection.Equals(copy1), "test2");
+// Assert.AreEqual(false, collect2.Equals(tableMapCollection), "test3");
+ Assert.AreEqual(true, copy1.Equals(tableMapCollection), "test4");
+// Assert.AreEqual(false, collect2.Equals(copy1), "test5");
+ Assert.AreEqual(true, copy1.Equals(tableMapCollection), "test6");
+ Assert.AreEqual(true, tableMapCollection.Equals(tableMapCollection), "test7");
+// Assert.AreEqual(true, collect2.Equals(collect2), "test8");
+ Assert.AreEqual(true, copy1.Equals(copy1), "test9");
-// AssertEquals("test10",false,Object.Equals(collect2,tableMapCollection));
- AssertEquals("test11",true,Object.Equals(copy1,tableMapCollection));
-// AssertEquals("test12",false,Object.Equals(tableMapCollection,collect2));
- AssertEquals("test13",true,Object.Equals(tableMapCollection,copy1));
-// AssertEquals("test14",false,Object.Equals(copy1,collect2));
- AssertEquals("test15",true,Object.Equals(tableMapCollection,copy1));
- AssertEquals("test16",true,Object.Equals(tableMapCollection,tableMapCollection));
-// AssertEquals("test17",true,Object.Equals(collect2,collect2));
- AssertEquals("test18",true,Object.Equals(copy1,copy1));
-// AssertEquals("test10",false,Object.Equals(tableMapCollection,collect2));
- AssertEquals("test11",true,Object.Equals(tableMapCollection,copy1));
-// AssertEquals("test12",false,Object.Equals(collect2,tableMapCollection));
- AssertEquals("test13",true,Object.Equals(copy1,tableMapCollection));
-// AssertEquals("test14",false,Object.Equals(collect2,copy1));
- AssertEquals("test15",true,Object.Equals(copy1,tableMapCollection));
+// Assert.AreEqual(false, Object.Equals(collect2, tableMapCollection), "test10");
+ Assert.AreEqual(true, Object.Equals(copy1, tableMapCollection), "test11");
+// Assert.AreEqual(false, Object.Equals(tableMapCollection, collect2), "test12");
+ Assert.AreEqual(true, Object.Equals(tableMapCollection, copy1), "test13");
+// Assert.AreEqual(false, Object.Equals(copy1, collect2), "test14");
+ Assert.AreEqual(true, Object.Equals(tableMapCollection, copy1), "test15");
+ Assert.AreEqual(true, Object.Equals(tableMapCollection, tableMapCollection), "test16");
+// Assert.AreEqual(true, Object.Equals(collect2, collect2), "test17");
+ Assert.AreEqual(true, Object.Equals(copy1, copy1), "test18");
+// Assert.AreEqual(false, Object.Equals(tableMapCollection, collect2), "test10");
+ Assert.AreEqual(true, Object.Equals(tableMapCollection, copy1), "test11");
+// Assert.AreEqual(false, Object.Equals(collect2, tableMapCollection), "test12");
+ Assert.AreEqual(true, Object.Equals(copy1, tableMapCollection), "test13");
+// Assert.AreEqual(false, Object.Equals(collect2, copy1), "test14");
+ Assert.AreEqual(true, Object.Equals(copy1, tableMapCollection), "test15");
}
[Test]
@@ -209,17 +209,17 @@ namespace MonoTests.System.Data.Common
DataTableMapping tab1;
tab1=tableMapCollection.GetByDataSetTable("dataSetCustomers");
eq=(tab1.DataSetTable.Equals("dataSetCustomers") && tab1.SourceTable.Equals("sourceCustomers"));
- AssertEquals("test1",true,eq);
+ Assert.AreEqual(true, eq, "test1");
tab1=tableMapCollection.GetByDataSetTable("dataSetEmployees");
eq=(tab1.DataSetTable.Equals("dataSetEmployees") && tab1.SourceTable.Equals("sourceEmployees"));
- AssertEquals("test2",true,eq);
+ Assert.AreEqual(true, eq, "test2");
tab1=tableMapCollection.GetByDataSetTable("datasetcustomers");
eq=(tab1.DataSetTable.Equals("dataSetCustomers") && tab1.SourceTable.Equals("sourceCustomers"));
- AssertEquals("test3",true,eq);
+ Assert.AreEqual(true, eq, "test3");
tab1=tableMapCollection.GetByDataSetTable("datasetemployees");
eq=(tab1.DataSetTable.Equals("dataSetEmployees") && tab1.SourceTable.Equals("sourceEmployees"));
- AssertEquals("test4",true,eq);
+ Assert.AreEqual(true, eq, "test4");
}
@@ -229,27 +229,27 @@ namespace MonoTests.System.Data.Common
tableMapCollection.AddRange(tabs);
bool eq;
DataTableMapping tab1;
- tab1=DataTableMappingCollection.GetTableMappingBySchemaAction(tableMapCollection,"sourceCustomers","dataSetCustomers",MissingMappingAction.Passthrough);
+ tab1=DataTableMappingCollection.GetTableMappingBySchemaAction(tableMapCollection, "sourceCustomers", "dataSetCustomers", MissingMappingAction.Passthrough);
eq=(tab1.DataSetTable.Equals("dataSetCustomers") && tab1.SourceTable.Equals("sourceCustomers"));
- AssertEquals("test1",true,eq);
- tab1=DataTableMappingCollection.GetTableMappingBySchemaAction(tableMapCollection,"sourceEmployees","dataSetEmployees",MissingMappingAction.Passthrough);
+ Assert.AreEqual(true, eq, "test1");
+ tab1=DataTableMappingCollection.GetTableMappingBySchemaAction(tableMapCollection, "sourceEmployees", "dataSetEmployees", MissingMappingAction.Passthrough);
eq=(tab1.DataSetTable.Equals("dataSetEmployees") && tab1.SourceTable.Equals("sourceEmployees"));
- AssertEquals("test2",true,eq);
+ Assert.AreEqual(true, eq, "test2");
- tab1=DataTableMappingCollection.GetTableMappingBySchemaAction(tableMapCollection,"sourceData","dataSetData",MissingMappingAction.Passthrough);
+ tab1=DataTableMappingCollection.GetTableMappingBySchemaAction(tableMapCollection, "sourceData", "dataSetData", MissingMappingAction.Passthrough);
eq=(tab1.DataSetTable.Equals("sourceData") && tab1.SourceTable.Equals("dataSetData"));
- AssertEquals("test3",false, eq);
+ Assert.AreEqual(false, eq, "test3");
eq=tableMapCollection.Contains(tab1);
- AssertEquals("test4",false,eq);
- tab1=DataTableMappingCollection.GetTableMappingBySchemaAction(tableMapCollection,"sourceData","dataSetData",MissingMappingAction.Ignore);
- AssertEquals("test5",null,tab1);
+ Assert.AreEqual(false, eq, "test4");
+ tab1=DataTableMappingCollection.GetTableMappingBySchemaAction(tableMapCollection, "sourceData", "dataSetData", MissingMappingAction.Ignore);
+ Assert.AreEqual(null, tab1, "test5");
}
[Test]
[ExpectedException(typeof(InvalidOperationException))]
public void GetTableMappingBySchemaActionException1()
{
- DataTableMappingCollection.GetTableMappingBySchemaAction(tableMapCollection,"sourceCustomers","dataSetCustomers",MissingMappingAction.Error);
+ DataTableMappingCollection.GetTableMappingBySchemaAction(tableMapCollection, "sourceCustomers", "dataSetCustomers", MissingMappingAction.Error);
}
[Test]
@@ -258,14 +258,14 @@ namespace MonoTests.System.Data.Common
tableMapCollection.AddRange(tabs);
int ind;
ind=tableMapCollection.IndexOf(tabs[0]);
- AssertEquals("test1",0,ind);
+ Assert.AreEqual(0, ind, "test1");
ind=tableMapCollection.IndexOf(tabs[1]);
- AssertEquals("test2",1,ind);
+ Assert.AreEqual(1, ind, "test2");
ind=tableMapCollection.IndexOf(tabs[0].SourceTable);
- AssertEquals("test3",0,ind);
+ Assert.AreEqual(0, ind, "test3");
ind=tableMapCollection.IndexOf(tabs[1].SourceTable);
- AssertEquals("test4",1,ind);
+ Assert.AreEqual(1, ind, "test4");
}
[Test]
@@ -274,27 +274,27 @@ namespace MonoTests.System.Data.Common
tableMapCollection.AddRange(tabs);
int ind;
ind=tableMapCollection.IndexOfDataSetTable(tabs[0].DataSetTable);
- AssertEquals("test1",0,ind);
+ Assert.AreEqual(0, ind, "test1");
ind=tableMapCollection.IndexOfDataSetTable(tabs[1].DataSetTable);
- AssertEquals("test2",1,ind);
+ Assert.AreEqual(1, ind, "test2");
ind=tableMapCollection.IndexOfDataSetTable("datasetcustomers");
- AssertEquals("test3",0,ind);
+ Assert.AreEqual(0, ind, "test3");
ind=tableMapCollection.IndexOfDataSetTable("datasetemployees");
- AssertEquals("test4",1,ind);
+ Assert.AreEqual(1, ind, "test4");
ind=tableMapCollection.IndexOfDataSetTable("sourcedeter");
- AssertEquals("test5",-1,ind);
+ Assert.AreEqual(-1, ind, "test5");
}
[Test]
public void Insert()
{
tableMapCollection.AddRange(tabs);
- DataTableMapping mymap=new DataTableMapping("sourceTestAge","datatestSetAge");
- tableMapCollection.Insert(3,mymap);
+ DataTableMapping mymap=new DataTableMapping("sourceTestAge", "datatestSetAge");
+ tableMapCollection.Insert(3, mymap);
int ind=tableMapCollection.IndexOfDataSetTable("datatestSetAge");
- AssertEquals("test1",3,ind);
+ Assert.AreEqual(3, ind, "test1");
}
[Test]
@@ -302,11 +302,11 @@ namespace MonoTests.System.Data.Common
public void Remove()
{
tableMapCollection.AddRange(tabs);
- DataTableMapping mymap=new DataTableMapping("sourceCustomers","dataSetCustomers");
+ DataTableMapping mymap=new DataTableMapping("sourceCustomers", "dataSetCustomers");
tableMapCollection.Add(mymap);
tableMapCollection.Remove((Object)mymap);
bool eq=tableMapCollection.Contains((Object)mymap);
- AssertEquals("test1",false,eq);
+ Assert.AreEqual(false, eq, "test1");
}
[Test]
@@ -323,7 +323,7 @@ namespace MonoTests.System.Data.Common
public void RemoveException2()
{
tableMapCollection.AddRange(tabs);
- DataTableMapping mymap=new DataTableMapping("sourceAge","dataSetAge");
+ DataTableMapping mymap=new DataTableMapping("sourceAge", "dataSetAge");
tableMapCollection.Remove(mymap);
}
@@ -334,15 +334,15 @@ namespace MonoTests.System.Data.Common
bool eq;
tableMapCollection.RemoveAt(0);
eq=tableMapCollection.Contains(tabs[0]);
- AssertEquals("test1",false,eq);
+ Assert.AreEqual(false, eq, "test1");
eq=tableMapCollection.Contains(tabs[1]);
- AssertEquals("test2",true,eq);
+ Assert.AreEqual(true, eq, "test2");
tableMapCollection.RemoveAt("sourceEmployees");
eq=tableMapCollection.Contains(tabs[1]);
- AssertEquals("test3",false,eq);
+ Assert.AreEqual(false, eq, "test3");
eq=tableMapCollection.Contains(tabs[2]);
- AssertEquals("test4",true,eq);
+ Assert.AreEqual(true, eq, "test4");
}
[Test]
@@ -365,7 +365,7 @@ namespace MonoTests.System.Data.Common
#endif
public void ToStringTest()
{
- AssertEquals("test1","System.Data.Common.DataTableMappingCollection",tableMapCollection.ToString());
+ Assert.AreEqual("System.Data.Common.DataTableMappingCollection", tableMapCollection.ToString(), "test1");
}
}
}
diff --git a/mcs/class/System.Data/Test/System.Data.Odbc/ChangeLog b/mcs/class/System.Data/Test/System.Data.Odbc/ChangeLog
index 6f5abb686b7..8adc133735c 100644
--- a/mcs/class/System.Data/Test/System.Data.Odbc/ChangeLog
+++ b/mcs/class/System.Data/Test/System.Data.Odbc/ChangeLog
@@ -1,3 +1,7 @@
+2009-07-13 Atsushi Enomoto <atsushi@ximian.com>
+
+ * OdbcDataReaderTest.cs : migration to newer nunit style.
+
2009-01-18 Gert Driesen <drieseng@users.sourceforge.net>
* OdbcCommandTest.cs: Added tests for CommandTimeout,
diff --git a/mcs/class/System.Data/Test/System.Data.Odbc/OdbcDataReaderTest.cs b/mcs/class/System.Data/Test/System.Data.Odbc/OdbcDataReaderTest.cs
index 15de3722cc1..5899043c34b 100644
--- a/mcs/class/System.Data/Test/System.Data.Odbc/OdbcDataReaderTest.cs
+++ b/mcs/class/System.Data/Test/System.Data.Odbc/OdbcDataReaderTest.cs
@@ -73,9 +73,9 @@ namespace MonoTests.System.Data.Odbc
reader = cmd.ExecuteReader ();
if (reader.Read ()) {
byte b = reader.GetByte (0);
- Assertion.AssertEquals ("GetByte returns wrong result!", 0xff, b);
+ Assert.AreEqual (0xff, b, "GetByte returns wrong result!");
} else // This should not happen while testing
- Assertion.AssertEquals ("test table doens not have a test data!", true, true);
+ Assert.AreEqual (true, true, "test table doens not have a test data!");
} finally { // try/catch is necessary to gracefully close connections
if (reader != null && reader.IsClosed)
reader.Close ();
@@ -96,23 +96,17 @@ namespace MonoTests.System.Data.Odbc
dbcmd.CommandText = sql;
IDataReader reader = dbcmd.ExecuteReader ();
try {
- Assertion.AssertEquals ("GetDataTypeName returns invalid Type for column #1",
- "TinyInt", reader.GetDataTypeName (0));
- Assertion.AssertEquals ("GetDataTypeName returns invalid Type for column #2",
- "VarChar", reader.GetDataTypeName (1));
+ Assert.AreEqual ("TinyInt", reader.GetDataTypeName (0), "GetDataTypeName returns invalid Type for column #1");
+ Assert.AreEqual ("VarChar", reader.GetDataTypeName (1), "GetDataTypeName returns invalid Type for column #2");
// Test via method GetFieldType.ToString
- Assertion.AssertEquals ("GetFieldType returns invalid Type for column #1",
- "System.Byte", reader.GetFieldType (0).ToString ());
- Assertion.AssertEquals ("GetFieldType returns invalid Type for column #2",
- "System.String", reader.GetFieldType (1).ToString ());
+ Assert.AreEqual ("System.Byte", reader.GetFieldType (0).ToString (), "GetFieldType returns invalid Type for column #1");
+ Assert.AreEqual ("System.String", reader.GetFieldType (1).ToString (), "GetFieldType returns invalid Type for column #2");
// Test via method GetSchemaTable
reader = dbcmd.ExecuteReader ();
DataTable schemaTable = reader.GetSchemaTable ();
- Assertion.AssertEquals ("GetSchemaTable.ColumnDataType failes for column #1",
- typeof (Byte), schemaTable.Rows [0]["DataType"]);
- Assertion.AssertEquals ("GetSchemaTable.ColumnDataType failes for column #1",
- typeof (String), schemaTable.Rows [1]["DataType"]);
+ Assert.AreEqual (typeof (Byte), schemaTable.Rows [0]["DataType"], "GetSchemaTable.ColumnDataType failes for column #1");
+ Assert.AreEqual (typeof (String), schemaTable.Rows [1]["DataType"], "GetSchemaTable.ColumnDataType failes for column #1");
} finally {
// clean up
if (reader != null && !reader.IsClosed)
@@ -131,7 +125,7 @@ namespace MonoTests.System.Data.Odbc
dbcmd.CommandText = sql;
OdbcDataReader reader = dbcmd.ExecuteReader ();
try {
- Assertion.AssertEquals ("GetName failes ", "pk_tint", reader.GetName (0));
+ Assert.AreEqual ("pk_tint", reader.GetName (0), "GetName failes ");
} finally {
// clean up
if (reader != null && !reader.IsClosed)
@@ -169,8 +163,7 @@ namespace MonoTests.System.Data.Odbc
// assemble here.
string col = Encoding.Default.GetString (val, 0, buffstart);
- Assertion.AssertEquals ("The assembled value length does not match",
- 39, col.Length);
+ Assert.AreEqual (39, col.Length, "The assembled value length does not match");
}
} finally {
// clean up
@@ -191,15 +184,12 @@ namespace MonoTests.System.Data.Odbc
OdbcDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess);
try {
if (reader.Read ()) {
- Assertion.AssertEquals ("GetBytes on a fixed length column does not work!",
- 11, reader.GetBytes (1,0,null,0,0));
- Assertion.AssertEquals ("GetBytes with non null column does not work!",
- 39, reader.GetBytes (3,0,null,0,0));
+ Assert.AreEqual (11, reader.GetBytes (1,0,null,0,0), "GetBytes on a fixed length column does not work!");
+ Assert.AreEqual (39, reader.GetBytes (3,0,null,0,0), "GetBytes with non null column does not work!");
}
// for null value, length in bytes should return 0
if (reader.Read ())
- Assertion.AssertEquals ("GetBytes with null column does not return -1" ,
- -1, reader.GetBytes (3,0,null,0,0));
+ AssertEquals ("GetBytes with null column does not return -1" , -1, reader.GetBytes (3,0,null,0,0));
} finally {
// clean up
if (reader != null && !reader.IsClosed )
@@ -220,8 +210,7 @@ namespace MonoTests.System.Data.Odbc
try {
if (reader.Read ()) {
object ob = reader.GetValue (3);
- Assertion.AssertEquals ("Type of binary column is wrong!",
- "System.Byte[]", ob.GetType ().ToString () );
+ Assert.AreEqual ("System.Byte[]", ob.GetType ().ToString () , "Type of binary column is wrong!");
}
} finally {
// clean up
@@ -243,23 +232,20 @@ namespace MonoTests.System.Data.Odbc
try {
if (reader.Read ()) {
object ob = reader["col_datetime"];
- Assertion.AssertEquals ("Type of datetime column is wrong!",
- "System.DateTime", ob.GetType ().ToString () );
+ Assert.AreEqual ("System.DateTime", ob.GetType ().ToString () , "Type of datetime column is wrong!");
ob = reader["col_date"];
- Assertion.AssertEquals ("Type of date column is wrong!",
- "System.DateTime", ob.GetType ().ToString () );
+ Assert.AreEqual ("System.DateTime", ob.GetType ().ToString () , "Type of date column is wrong!");
// FIXME : Once TIME data type is fixed, enable this check
//ob = reader["col_time"];
- //Assertion.AssertEquals ("Type of time column is wrong!",
- //"System.DateTime", ob.GetType ().ToString () );
+ //Assert.AreEqual ("System.DateTime", ob.GetType ().ToString () , "Type of time column is wrong!");
DateTime dt = reader.GetDateTime (4);
- Assertion.AssertEquals ("DateValue (SQL_TIMESTAMP) is wrong", new DateTime (2004, 8, 22, 0, 0, 0), dt);
+ Assert.AreEqual (new DateTime (2004, 8, 22, 0, 0, 0), dt, "DateValue (SQL_TIMESTAMP) is wrong");
dt = reader.GetDateTime (5);
- Assertion.AssertEquals ("DateValue (SQL_DATE) is wrong", new DateTime (2004, 8, 22, 0, 0, 0), dt);
+ Assert.AreEqual (new DateTime (2004, 8, 22, 0, 0, 0), dt, "DateValue (SQL_DATE) is wrong");
// FIXME : Once TIME data type is fixed, enable this check
//dt = reader.GetDateTime (7);
- //Assertion.AssertEquals ("DateValue is wrong", "2004-08-22", dt.ToString ());
+ //Assert.AreEqual ("2004-08-22", dt.ToString (), "DateValue is wrong");
}
} finally {
// clean up
@@ -320,10 +306,8 @@ namespace MonoTests.System.Data.Odbc
try {
if (reader.Read ()) {
object ob = reader.GetValue (0);
- Assertion.AssertEquals ("Type of tinyInt column is wrong!",
- "System.Byte", ob.GetType ().ToString () );
- Assertion.AssertEquals ("Value of tinyInt column is wrong!",
- 1, Convert.ToInt16(ob) );
+ Assert.AreEqual ("System.Byte", ob.GetType ().ToString () , "Type of tinyInt column is wrong!");
+ Assert.AreEqual (1, Convert.ToInt16(ob) , "Value of tinyInt column is wrong!");
}
} finally {
// clean up
diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/ChangeLog b/mcs/class/System.Data/Test/System.Data.SqlTypes/ChangeLog
index 533a963d73d..1eca37d3e38 100644
--- a/mcs/class/System.Data/Test/System.Data.SqlTypes/ChangeLog
+++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/ChangeLog
@@ -1,3 +1,8 @@
+2009-07-13 Atsushi Enomoto <atsushi@ximian.com>
+
+ * SqlGuidTest.cs, SqlDateTimeTest.cs, SqlBinaryTest.cs :
+ migration to newer nunit style.
+
2008-12-30 Gert Driesen <drieseng@users.sourceforge.net>
* SqlXmlTest.cs: Minor improvements to tests. Marked tests as
diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlBinaryTest.cs b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlBinaryTest.cs
index f8327b674dd..04e8d7ef788 100644
--- a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlBinaryTest.cs
+++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlBinaryTest.cs
@@ -40,7 +40,7 @@ using System.Data.SqlTypes;
namespace MonoTests.System.Data.SqlTypes
{
[TestFixture]
- public class SqlBinaryTest : Assertion {
+ public class SqlBinaryTest {
SqlBinary Test1;
SqlBinary Test2;
@@ -72,14 +72,14 @@ namespace MonoTests.System.Data.SqlTypes
{
byte [] b = new byte [3];
SqlBinary Test = new SqlBinary (b);
- Assert ("#A01", !(Test.IsNull));
+ Assert.IsTrue (!(Test.IsNull) , "#A01");
}
// Test public fields
[Test]
public void PublicFields()
{
- Assert ("#B01", SqlBinary.Null.IsNull);
+ Assert.IsTrue (SqlBinary.Null.IsNull, "#B01");
}
// Test properties
@@ -93,51 +93,47 @@ namespace MonoTests.System.Data.SqlTypes
SqlBinary TestBinary = new SqlBinary (b);
// IsNull
- Assert ("#C01", SqlBinary.Null.IsNull);
+ Assert.IsTrue (SqlBinary.Null.IsNull, "#C01");
// Item
- AssertEquals ("#C02", (byte)128, TestBinary [1]);
- AssertEquals ("#C03", (byte)64, TestBinary [0]);
+ Assert.AreEqual ((byte)128, TestBinary [1], "#C02");
+ Assert.AreEqual ((byte)64, TestBinary [0], "#C03");
// FIXME: MSDN says that should throw SqlNullValueException
// but throws IndexOutOfRangeException
try {
byte test = TestBinary [TestBinary.Length];
- Fail ("#C04");
+ Assert.Fail ("#C04");
} catch (Exception e) {
- AssertEquals ("#C05", typeof (IndexOutOfRangeException),
- e.GetType ());
+ Assert.AreEqual (typeof (IndexOutOfRangeException), e.GetType (), "#C05");
}
try {
byte test = SqlBinary.Null [2];
- Fail ("#C06");
+ Assert.Fail ("#C06");
} catch (Exception e) {
- AssertEquals ("#C07", typeof (SqlNullValueException),
- e.GetType ());
+ Assert.AreEqual (typeof (SqlNullValueException), e.GetType (), "#C07");
}
// Length
- AssertEquals ("#C08", 2, TestBinary.Length);
+ Assert.AreEqual (2, TestBinary.Length, "#C08");
try {
int test = SqlBinary.Null.Length;
- Fail ("#C09");
+ Assert.Fail ("#C09");
} catch (Exception e) {
- AssertEquals ("#C10", typeof (SqlNullValueException),
- e.GetType ());
+ Assert.AreEqual (typeof (SqlNullValueException), e.GetType (), "#C10");
}
// Value
- AssertEquals ("#C11", (byte)128, TestBinary [1]);
- AssertEquals ("#C12", (byte)64, TestBinary [0]);
+ Assert.AreEqual ((byte)128, TestBinary [1], "#C11");
+ Assert.AreEqual ((byte)64, TestBinary [0], "#C12");
try {
Byte [] test = SqlBinary.Null.Value;
- Fail ("#C13");
+ Assert.Fail ("#C13");
} catch (Exception e) {
- AssertEquals ("#C14", typeof (SqlNullValueException),
- e.GetType ());
+ Assert.AreEqual (typeof (SqlNullValueException), e.GetType (), "#C14");
}
}
@@ -146,34 +142,34 @@ namespace MonoTests.System.Data.SqlTypes
public void ComparisonMethods()
{
// GreaterThan
- Assert ("#D01", SqlBinary.GreaterThan (Test1, Test2).Value);
- Assert ("#D02", SqlBinary.GreaterThan (Test3, Test2).Value);
- Assert ("#D03", !SqlBinary.GreaterThan (Test2, Test1).Value);
+ Assert.IsTrue (SqlBinary.GreaterThan (Test1, Test2).Value, "#D01");
+ Assert.IsTrue (SqlBinary.GreaterThan (Test3, Test2).Value, "#D02");
+ Assert.IsTrue (!SqlBinary.GreaterThan (Test2, Test1).Value, "#D03");
// GreaterThanOrEqual
- Assert ("#D04", SqlBinary.GreaterThanOrEqual (Test1, Test2).Value);
- Assert ("#D05", SqlBinary.GreaterThanOrEqual (Test1, Test2).Value);
- Assert ("#D06", !SqlBinary.GreaterThanOrEqual (Test2, Test1).Value);
+ Assert.IsTrue (SqlBinary.GreaterThanOrEqual (Test1, Test2).Value, "#D04");
+ Assert.IsTrue (SqlBinary.GreaterThanOrEqual (Test1, Test2).Value, "#D05");
+ Assert.IsTrue (!SqlBinary.GreaterThanOrEqual (Test2, Test1).Value, "#D06");
// LessThan
- Assert ("#D07", !SqlBinary.LessThan (Test1, Test2).Value);
- Assert ("#D08", !SqlBinary.LessThan (Test3, Test2).Value);
- Assert ("#D09", SqlBinary.LessThan (Test2, Test1).Value);
+ Assert.IsTrue (!SqlBinary.LessThan (Test1, Test2).Value, "#D07");
+ Assert.IsTrue (!SqlBinary.LessThan (Test3, Test2).Value, "#D08");
+ Assert.IsTrue (SqlBinary.LessThan (Test2, Test1).Value, "#D09");
// LessThanOrEqual
- Assert ("#D10", !SqlBinary.LessThanOrEqual (Test1, Test2).Value);
- Assert ("#D11", SqlBinary.LessThanOrEqual (Test3, Test1).Value);
- Assert ("#D12", SqlBinary.LessThanOrEqual (Test2, Test1).Value);
+ Assert.IsTrue (!SqlBinary.LessThanOrEqual (Test1, Test2).Value, "#D10");
+ Assert.IsTrue (SqlBinary.LessThanOrEqual (Test3, Test1).Value, "#D11");
+ Assert.IsTrue (SqlBinary.LessThanOrEqual (Test2, Test1).Value, "#D12");
// Equals
- Assert ("#D13", !Test1.Equals (Test2));
- Assert ("#D14", !Test3.Equals (Test2));
- Assert ("#D15", Test3.Equals (Test1));
+ Assert.IsTrue (!Test1.Equals (Test2), "#D13");
+ Assert.IsTrue (!Test3.Equals (Test2), "#D14");
+ Assert.IsTrue (Test3.Equals (Test1), "#D15");
// NotEquals
- Assert ("#D16", SqlBinary.NotEquals (Test1, Test2).Value);
- Assert ("#D17", !SqlBinary.NotEquals (Test3, Test1).Value);
- Assert ("#D18", SqlBinary.NotEquals (Test2, Test1).Value);
+ Assert.IsTrue (SqlBinary.NotEquals (Test1, Test2).Value, "#D16");
+ Assert.IsTrue (!SqlBinary.NotEquals (Test3, Test1).Value, "#D17");
+ Assert.IsTrue (SqlBinary.NotEquals (Test2, Test1).Value, "#D18");
}
[Test]
@@ -181,30 +177,29 @@ namespace MonoTests.System.Data.SqlTypes
{
SqlString TestString = new SqlString ("This is a test");
- Assert ("#E01", Test1.CompareTo(Test2) > 0);
- Assert ("#E02", Test2.CompareTo(Test1) < 0);
- Assert ("#E03", Test1.CompareTo(Test3) == 0);
+ Assert.IsTrue (Test1.CompareTo(Test2) > 0, "#E01");
+ Assert.IsTrue (Test2.CompareTo(Test1) < 0, "#E02");
+ Assert.IsTrue (Test1.CompareTo(Test3) == 0, "#E03");
try {
Test1.CompareTo (TestString);
- Fail ("#E04");
+ Assert.Fail ("#E04");
} catch(Exception e) {
- AssertEquals ("#E05", typeof (ArgumentException), e.GetType ());
- }
+ Assert.AreEqual (typeof (ArgumentException), e.GetType (), "#E05");
+ }
}
[Test]
public void GetHashCodeTest()
{
- AssertEquals ("#F01", Test1.GetHashCode (), Test1.GetHashCode ());
- Assert ("#F02", Test2.GetHashCode () != Test1.GetHashCode ());
+ Assert.AreEqual (Test1.GetHashCode (), Test1.GetHashCode (), "#F01");
+ Assert.IsTrue (Test2.GetHashCode () != Test1.GetHashCode (), "#F02");
}
[Test]
public void GetTypeTest()
{
- AssertEquals("#G01", "System.Data.SqlTypes.SqlBinary",
- Test1.GetType().ToString());
+ Assert.AreEqual ("System.Data.SqlTypes.SqlBinary", Test1.GetType().ToString(), "#G01");
}
[Test]
@@ -213,11 +208,11 @@ namespace MonoTests.System.Data.SqlTypes
SqlBinary TestBinary;
TestBinary = SqlBinary.Concat (Test2, Test3);
- AssertEquals ("H01", (byte)15, TestBinary [4]);
+ Assert.AreEqual ((byte)15, TestBinary [4], "H01");
TestBinary = SqlBinary.Concat (Test1, Test2);
- AssertEquals ("#H02", (byte)240, TestBinary [0]);
- AssertEquals ("#H03", (byte)15, TestBinary [1]);
+ Assert.AreEqual ((byte)240, TestBinary [0], "#H02");
+ Assert.AreEqual ((byte)15, TestBinary [1], "#H03");
}
[Test]
@@ -225,14 +220,14 @@ namespace MonoTests.System.Data.SqlTypes
{
SqlBinary TestBinary = new SqlBinary (new byte [16]);
SqlGuid TestGuid = TestBinary.ToSqlGuid ();
- Assert ("#I01", !TestGuid.IsNull);
+ Assert.IsTrue (!TestGuid.IsNull, "#I01");
}
[Test]
public void ToStringTest()
{
- AssertEquals ("#J01", "SqlBinary(3)", Test2.ToString ());
- AssertEquals ("#J02", "SqlBinary(2)", Test1.ToString ());
+ Assert.AreEqual ("SqlBinary(3)", Test2.ToString (), "#J01");
+ Assert.AreEqual ("SqlBinary(2)", Test1.ToString (), "#J02");
}
// OPERATORS
@@ -240,43 +235,43 @@ namespace MonoTests.System.Data.SqlTypes
public void AdditionOperator()
{
SqlBinary TestBinary = Test1 + Test2;
- AssertEquals ("#K01", (byte)240, TestBinary [0]);
- AssertEquals ("#K02", (byte)15, TestBinary [1]);
+ Assert.AreEqual ((byte)240, TestBinary [0], "#K01");
+ Assert.AreEqual ((byte)15, TestBinary [1], "#K02");
}
[Test]
public void ComparisonOperators()
{
// Equality
- Assert ("#L01", !(Test1 == Test2).Value);
- Assert ("#L02", (Test3 == Test1).Value);
+ Assert.IsTrue (!(Test1 == Test2).Value, "#L01");
+ Assert.IsTrue ((Test3 == Test1).Value, "#L02");
// Greater than
- Assert ("#L03", (Test1 > Test2).Value);
- Assert ("#L04", !(Test3 > Test1).Value);
+ Assert.IsTrue ((Test1 > Test2).Value, "#L03");
+ Assert.IsTrue (!(Test3 > Test1).Value, "#L04");
// Greater than or equal
- Assert ("#L05", (Test1 >= Test2).Value);
- Assert ("#L06", (Test3 >= Test2).Value);
+ Assert.IsTrue ((Test1 >= Test2).Value, "#L05");
+ Assert.IsTrue ((Test3 >= Test2).Value, "#L06");
// Inequality
- Assert ("#L07", (Test1 != Test2).Value);
- Assert ("#L08", !(Test3 != Test1).Value);
+ Assert.IsTrue ((Test1 != Test2).Value, "#L07");
+ Assert.IsTrue (!(Test3 != Test1).Value, "#L08");
// Less than
- Assert ("#L09", !(Test1 < Test2).Value);
- Assert ("#L10", !(Test3 < Test2).Value);
+ Assert.IsTrue (!(Test1 < Test2).Value, "#L09");
+ Assert.IsTrue (!(Test3 < Test2).Value, "#L10");
// Less than or equal
- Assert ("#L11", !(Test1 <= Test2).Value);
- Assert ("#L12", (Test3 <= Test1).Value);
+ Assert.IsTrue (!(Test1 <= Test2).Value, "#L11");
+ Assert.IsTrue ((Test3 <= Test1).Value, "#L12");
}
[Test]
public void SqlBinaryToByteArray()
{
byte [] TestByteArray = (Byte[])Test1;
- AssertEquals ("#M01", (byte)240, TestByteArray[0]);
+ Assert.AreEqual ((byte)240, TestByteArray[0], "#M01");
}
[Test]
@@ -288,7 +283,7 @@ namespace MonoTests.System.Data.SqlTypes
SqlGuid TestGuid = new SqlGuid (TestByteArray);
SqlBinary TestBinary = (SqlBinary)TestGuid;
- AssertEquals ("#N01", (byte)15, TestBinary [0]);
+ Assert.AreEqual ((byte)15, TestBinary [0], "#N01");
}
[Test]
@@ -298,14 +293,14 @@ namespace MonoTests.System.Data.SqlTypes
TestByteArray [0] = 15;
TestByteArray [1] = 200;
SqlBinary TestBinary = (SqlBinary)TestByteArray;
- AssertEquals ("#O1", (byte)15, TestBinary [0]);
+ Assert.AreEqual ((byte)15, TestBinary [0], "#O1");
}
#if NET_2_0
[Test]
public void GetXsdTypeTest ()
{
XmlQualifiedName qualifiedName = SqlBinary.GetXsdType (null);
- NUnit.Framework.Assert.AreEqual ("base64Binary", qualifiedName.Name, "#A01");
+ Assert.AreEqual ("base64Binary", qualifiedName.Name, "#A01");
}
#endif
}
diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDateTimeTest.cs b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDateTimeTest.cs
index e7bcb5eda05..8d157f3ef02 100644
--- a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDateTimeTest.cs
+++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlDateTimeTest.cs
@@ -42,7 +42,7 @@ using System.Globalization;
namespace MonoTests.System.Data.SqlTypes
{
[TestFixture]
- public class SqlDateTimeTest : Assertion {
+ public class SqlDateTimeTest {
private long[] myTicks = {
631501920000000000L, // 25 Feb 2002 - 00:00:00
@@ -74,49 +74,48 @@ namespace MonoTests.System.Data.SqlTypes
// SqlDateTime (DateTime)
SqlDateTime CTest = new SqlDateTime (
new DateTime (2002, 5, 19, 3, 34, 0));
- AssertEquals ("#A01", 2002, CTest.Value.Year);
+ Assert.AreEqual (2002, CTest.Value.Year, "#A01");
// SqlDateTime (int, int)
CTest = new SqlDateTime (0, 0);
// SqlDateTime (int, int, int)
- AssertEquals ("#A02", 1900, CTest.Value.Year);
- AssertEquals ("#A03", 1, CTest.Value.Month);
- AssertEquals ("#A04", 1, CTest.Value.Day);
- AssertEquals ("#A05", 0, CTest.Value.Hour);
+ Assert.AreEqual (1900, CTest.Value.Year, "#A02");
+ Assert.AreEqual (1, CTest.Value.Month, "#A03");
+ Assert.AreEqual (1, CTest.Value.Day, "#A04");
+ Assert.AreEqual (0, CTest.Value.Hour, "#A05");
// SqlDateTime (int, int, int, int, int, int)
CTest = new SqlDateTime (5000, 12, 31);
- AssertEquals ("#A06", 5000, CTest.Value.Year);
- AssertEquals ("#A07", 12, CTest.Value.Month);
- AssertEquals ("#A08", 31, CTest.Value.Day);
+ Assert.AreEqual (5000, CTest.Value.Year, "#A06");
+ Assert.AreEqual (12, CTest.Value.Month, "#A07");
+ Assert.AreEqual (31, CTest.Value.Day, "#A08");
// SqlDateTime (int, int, int, int, int, int, double)
CTest = new SqlDateTime (1978, 5, 19, 3, 34, 0);
- AssertEquals ("#A09", 1978, CTest.Value.Year);
- AssertEquals ("#A10", 5, CTest.Value.Month);
- AssertEquals ("#A11", 19, CTest.Value.Day);
- AssertEquals ("#A12", 3, CTest.Value.Hour);
- AssertEquals ("#A13", 34, CTest.Value.Minute);
- AssertEquals ("#A14", 0, CTest.Value.Second);
+ Assert.AreEqual (1978, CTest.Value.Year, "#A09");
+ Assert.AreEqual (5, CTest.Value.Month, "#A10");
+ Assert.AreEqual (19, CTest.Value.Day, "#A11");
+ Assert.AreEqual (3, CTest.Value.Hour, "#A12");
+ Assert.AreEqual (34, CTest.Value.Minute, "#A13");
+ Assert.AreEqual (0, CTest.Value.Second, "#A14");
try {
CTest = new SqlDateTime (10000, 12, 31);
- Fail ("#A15");
+ Assert.Fail ("#A15");
} catch (Exception e) {
- AssertEquals ("#A16", typeof (SqlTypeException),
- e.GetType ());
+ Assert.AreEqual (typeof (SqlTypeException), e.GetType (), "#A16");
}
// SqlDateTime (int, int, int, int, int, int, int)
CTest = new SqlDateTime (1978, 5, 19, 3, 34, 0, 12);
- AssertEquals ("#A17", 1978, CTest.Value.Year);
- AssertEquals ("#A18", 5, CTest.Value.Month);
- AssertEquals ("#A19", 19, CTest.Value.Day);
- AssertEquals ("#A20", 3, CTest.Value.Hour);
- AssertEquals ("#A21", 34, CTest.Value.Minute);
- AssertEquals ("#A22", 0, CTest.Value.Second);
- AssertEquals ("#A23", 0, CTest.Value.Millisecond);
+ Assert.AreEqual (1978, CTest.Value.Year, "#A17");
+ Assert.AreEqual (5, CTest.Value.Month, "#A18");
+ Assert.AreEqual (19, CTest.Value.Day, "#A19");
+ Assert.AreEqual (3, CTest.Value.Hour, "#A20");
+ Assert.AreEqual (34, CTest.Value.Minute, "#A21");
+ Assert.AreEqual (0, CTest.Value.Second, "#A22");
+ Assert.AreEqual (0, CTest.Value.Millisecond, "#A23");
}
// Test public fields
@@ -124,32 +123,32 @@ namespace MonoTests.System.Data.SqlTypes
public void PublicFields()
{
// MaxValue
- AssertEquals ("#B01", 9999, SqlDateTime.MaxValue.Value.Year);
- AssertEquals ("#B02", 12, SqlDateTime.MaxValue.Value.Month);
- AssertEquals ("#B03", 31, SqlDateTime.MaxValue.Value.Day);
- AssertEquals ("#B04", 23, SqlDateTime.MaxValue.Value.Hour);
- AssertEquals ("#B05", 59, SqlDateTime.MaxValue.Value.Minute);
- AssertEquals ("#B06", 59, SqlDateTime.MaxValue.Value.Second);
+ Assert.AreEqual (9999, SqlDateTime.MaxValue.Value.Year, "#B01");
+ Assert.AreEqual (12, SqlDateTime.MaxValue.Value.Month, "#B02");
+ Assert.AreEqual (31, SqlDateTime.MaxValue.Value.Day, "#B03");
+ Assert.AreEqual (23, SqlDateTime.MaxValue.Value.Hour, "#B04");
+ Assert.AreEqual (59, SqlDateTime.MaxValue.Value.Minute, "#B05");
+ Assert.AreEqual (59, SqlDateTime.MaxValue.Value.Second, "#B06");
// MinValue
- AssertEquals ("#B07", 1753, SqlDateTime.MinValue.Value.Year);
- AssertEquals ("#B08", 1, SqlDateTime.MinValue.Value.Month);
- AssertEquals ("#B09", 1, SqlDateTime.MinValue.Value.Day);
- AssertEquals ("#B10", 0, SqlDateTime.MinValue.Value.Hour);
- AssertEquals ("#B11", 0, SqlDateTime.MinValue.Value.Minute);
- AssertEquals ("#B12", 0, SqlDateTime.MinValue.Value.Second);
+ Assert.AreEqual (1753, SqlDateTime.MinValue.Value.Year, "#B07");
+ Assert.AreEqual (1, SqlDateTime.MinValue.Value.Month, "#B08");
+ Assert.AreEqual (1, SqlDateTime.MinValue.Value.Day, "#B09");
+ Assert.AreEqual (0, SqlDateTime.MinValue.Value.Hour, "#B10");
+ Assert.AreEqual (0, SqlDateTime.MinValue.Value.Minute, "#B11");
+ Assert.AreEqual (0, SqlDateTime.MinValue.Value.Second, "#B12");
// Null
- Assert ("#B13", SqlDateTime.Null.IsNull);
+ Assert.IsTrue (SqlDateTime.Null.IsNull, "#B13");
// SQLTicksPerHour
- AssertEquals ("#B14", 1080000, SqlDateTime.SQLTicksPerHour);
+ Assert.AreEqual (1080000, SqlDateTime.SQLTicksPerHour, "#B14");
// SQLTicksPerMinute
- AssertEquals ("#B15", 18000, SqlDateTime.SQLTicksPerMinute);
+ Assert.AreEqual (18000, SqlDateTime.SQLTicksPerMinute, "#B15");
// SQLTicksPerSecond
- AssertEquals ("#B16", 300, SqlDateTime.SQLTicksPerSecond);
+ Assert.AreEqual (300, SqlDateTime.SQLTicksPerSecond, "#B16");
}
// Test properties
@@ -157,34 +156,32 @@ namespace MonoTests.System.Data.SqlTypes
public void Properties()
{
// DayTicks
- AssertEquals ("#C01", 37546, Test1.DayTicks);
+ Assert.AreEqual (37546, Test1.DayTicks, "#C01");
try {
int test = SqlDateTime.Null.DayTicks;
- Fail ("#C02");
+ Assert.Fail ("#C02");
} catch (Exception e) {
- AssertEquals ("#C03", typeof (SqlNullValueException),
- e.GetType ());
+ Assert.AreEqual (typeof (SqlNullValueException), e.GetType (), "#C03");
}
// IsNull
- Assert ("#C04", SqlDateTime.Null.IsNull);
- Assert ("#C05", !Test2.IsNull);
+ Assert.IsTrue (SqlDateTime.Null.IsNull, "#C04");
+ Assert.IsTrue (!Test2.IsNull, "#C05");
// TimeTicks
- AssertEquals ("#C06", 10440000, Test1.TimeTicks);
+ Assert.AreEqual (10440000, Test1.TimeTicks, "#C06");
try {
int test = SqlDateTime.Null.TimeTicks;
- Fail ("#C07");
+ Assert.Fail ("#C07");
} catch (Exception e) {
- AssertEquals ("#C08", typeof (SqlNullValueException),
- e.GetType ());
+ Assert.AreEqual (typeof (SqlNullValueException), e.GetType (), "#C08");
}
// Value
- AssertEquals ("#C09", 2003, Test2.Value.Year);
- AssertEquals ("#C10", 2002, Test1.Value.Year);
+ Assert.AreEqual (2003, Test2.Value.Year, "#C09");
+ Assert.AreEqual (2002, Test1.Value.Year, "#C10");
}
// PUBLIC METHODS
@@ -194,84 +191,82 @@ namespace MonoTests.System.Data.SqlTypes
{
SqlString TestString = new SqlString ("This is a test");
- Assert ("#D01", Test1.CompareTo (Test3) < 0);
- Assert ("#D02", Test2.CompareTo (Test1) > 0);
- Assert ("#D03", Test2.CompareTo (Test3) == 0);
- Assert ("#D04", Test1.CompareTo (SqlDateTime.Null) > 0);
+ Assert.IsTrue (Test1.CompareTo (Test3) < 0, "#D01");
+ Assert.IsTrue (Test2.CompareTo (Test1) > 0, "#D02");
+ Assert.IsTrue (Test2.CompareTo (Test3) == 0, "#D03");
+ Assert.IsTrue (Test1.CompareTo (SqlDateTime.Null) > 0, "#D04");
try {
Test1.CompareTo (TestString);
- Fail("#D05");
+ Assert.Fail("#D05");
} catch(Exception e) {
- AssertEquals ("#D06", typeof (ArgumentException), e.GetType ());
+ Assert.AreEqual (typeof (ArgumentException), e.GetType (), "#D06");
}
}
[Test]
public void EqualsMethods()
{
- Assert ("#E01", !Test1.Equals (Test2));
- Assert ("#E03", !Test2.Equals (new SqlString ("TEST")));
- Assert ("#E04", Test2.Equals (Test3));
+ Assert.IsTrue (!Test1.Equals (Test2), "#E01");
+ Assert.IsTrue (!Test2.Equals (new SqlString ("TEST")), "#E03");
+ Assert.IsTrue (Test2.Equals (Test3), "#E04");
// Static Equals()-method
- Assert ("#E05", SqlDateTime.Equals (Test2, Test3).Value);
- Assert ("#E06", !SqlDateTime.Equals (Test1, Test2).Value);
+ Assert.IsTrue (SqlDateTime.Equals (Test2, Test3).Value, "#E05");
+ Assert.IsTrue (!SqlDateTime.Equals (Test1, Test2).Value, "#E06");
}
[Test]
public void GetHashCodeTest()
{
// FIXME: Better way to test HashCode
- AssertEquals ("#F01", Test1.GetHashCode (), Test1.GetHashCode ());
- Assert ("#F02", Test2.GetHashCode () != Test1.GetHashCode ());
+ Assert.AreEqual (Test1.GetHashCode (), Test1.GetHashCode (), "#F01");
+ Assert.IsTrue (Test2.GetHashCode () != Test1.GetHashCode (), "#F02");
}
[Test]
public void GetTypeTest()
{
- AssertEquals ("#G01", "System.Data.SqlTypes.SqlDateTime",
- Test1.GetType ().ToString ());
- AssertEquals ("#G02", "System.DateTime",
- Test1.Value.GetType ().ToString ());
+ Assert.AreEqual ("System.Data.SqlTypes.SqlDateTime", Test1.GetType ().ToString (), "#G01");
+ Assert.AreEqual ("System.DateTime", Test1.Value.GetType ().ToString (), "#G02");
}
[Test]
public void Greaters()
{
// GreateThan ()
- Assert ("#H01", !SqlDateTime.GreaterThan (Test1, Test2).Value);
- Assert ("#H02", SqlDateTime.GreaterThan (Test2, Test1).Value);
- Assert ("#H03", !SqlDateTime.GreaterThan (Test2, Test3).Value);
+ Assert.IsTrue (!SqlDateTime.GreaterThan (Test1, Test2).Value, "#H01");
+ Assert.IsTrue (SqlDateTime.GreaterThan (Test2, Test1).Value, "#H02");
+ Assert.IsTrue (!SqlDateTime.GreaterThan (Test2, Test3).Value, "#H03");
// GreaterTharOrEqual ()
- Assert ("#H04", !SqlDateTime.GreaterThanOrEqual (Test1, Test2).Value);
- Assert ("#H05", SqlDateTime.GreaterThanOrEqual (Test2, Test1).Value);
- Assert ("#H06", SqlDateTime.GreaterThanOrEqual (Test2, Test3).Value);
+ Assert.IsTrue (!SqlDateTime.GreaterThanOrEqual (Test1, Test2).Value, "#H04");
+ Assert.IsTrue (SqlDateTime.GreaterThanOrEqual (Test2, Test1).Value, "#H05");
+ Assert.IsTrue (SqlDateTime.GreaterThanOrEqual (Test2, Test3).Value, "#H06");
}
[Test]
public void Lessers()
{
// LessThan()
- Assert ("#I01", !SqlDateTime.LessThan (Test2, Test3).Value);
- Assert ("#I02", !SqlDateTime.LessThan (Test2, Test1).Value);
- Assert ("#I03", SqlDateTime.LessThan (Test1, Test3).Value);
+ Assert.IsTrue (!SqlDateTime.LessThan (Test2, Test3).Value, "#I01");
+ Assert.IsTrue (!SqlDateTime.LessThan (Test2, Test1).Value, "#I02");
+ Assert.IsTrue (SqlDateTime.LessThan (Test1, Test3).Value, "#I03");
// LessThanOrEqual ()
- Assert ("#I04", SqlDateTime.LessThanOrEqual (Test1, Test2).Value);
- Assert ("#I05", !SqlDateTime.LessThanOrEqual (Test2, Test1).Value);
- Assert ("#I06", SqlDateTime.LessThanOrEqual (Test3, Test2).Value);
- Assert ("#I07", SqlDateTime.LessThanOrEqual (Test1, SqlDateTime.Null).IsNull);
+ Assert.IsTrue (SqlDateTime.LessThanOrEqual (Test1, Test2).Value, "#I04");
+ Assert.IsTrue (!SqlDateTime.LessThanOrEqual (Test2, Test1).Value, "#I05");
+ Assert.IsTrue (SqlDateTime.LessThanOrEqual (Test3, Test2).Value, "#I06");
+ Assert.IsTrue (SqlDateTime.LessThanOrEqual (Test1, SqlDateTime.Null).IsNull, "#I07");
}
[Test]
public void NotEquals()
{
- Assert ("#J01", SqlDateTime.NotEquals (Test1, Test2).Value);
- Assert ("#J02", SqlDateTime.NotEquals (Test3, Test1).Value);
- Assert ("#J03", !SqlDateTime.NotEquals (Test2, Test3).Value);
- Assert ("#J04", SqlDateTime.NotEquals (SqlDateTime.Null, Test2).IsNull);
+ Assert.IsTrue (SqlDateTime.NotEquals (Test1, Test2).Value, "#J01");
+ Assert.IsTrue (SqlDateTime.NotEquals (Test3, Test1).Value, "#J02");
+ Assert.IsTrue (!SqlDateTime.NotEquals (Test2, Test3).Value, "#J03");
+ Assert.IsTrue (SqlDateTime.NotEquals (SqlDateTime.Null, Test2).IsNull, "#J04");
}
[Test]
@@ -279,90 +274,88 @@ namespace MonoTests.System.Data.SqlTypes
{
try {
SqlDateTime.Parse (null);
- Fail ("#K01");
+ Assert.Fail ("#K01");
} catch (Exception e) {
- AssertEquals ("#K02", typeof (ArgumentNullException),
- e.GetType ());
+ Assert.AreEqual (typeof (ArgumentNullException), e.GetType (), "#K02");
}
try {
SqlDateTime.Parse ("not-a-number");
- Fail ("#K03");
+ Assert.Fail ("#K03");
} catch (Exception e) {
- AssertEquals ("#K04", typeof (FormatException),
- e.GetType ());
+ Assert.AreEqual (typeof (FormatException), e.GetType (), "#K04");
}
SqlDateTime t1 = SqlDateTime.Parse ("02/25/2002");
- AssertEquals ("#K05", myTicks[0], t1.Value.Ticks);
+ Assert.AreEqual (myTicks[0], t1.Value.Ticks, "#K05");
try {
t1 = SqlDateTime.Parse ("2002-02-25");
} catch (Exception e) {
- Fail ("#K06 " + e);
+ Assert.Fail ("#K06 " + e);
}
// Thanks for Martin Baulig for these (DateTimeTest.cs)
- AssertEquals ("#K07", myTicks[0], t1.Value.Ticks);
+ Assert.AreEqual (myTicks[0], t1.Value.Ticks, "#K07");
t1 = SqlDateTime.Parse ("Monday, 25 February 2002");
- AssertEquals ("#K08", myTicks[0], t1.Value.Ticks);
+ Assert.AreEqual (myTicks[0], t1.Value.Ticks, "#K08");
t1 = SqlDateTime.Parse ("Monday, 25 February 2002 05:25");
- AssertEquals ("#K09", myTicks[3], t1.Value.Ticks);
+ Assert.AreEqual (myTicks[3], t1.Value.Ticks, "#K09");
t1 = SqlDateTime.Parse ("Monday, 25 February 2002 05:25:13");
- AssertEquals ("#K10", myTicks[4], t1.Value.Ticks);
+ Assert.AreEqual (myTicks[4], t1.Value.Ticks, "#K10");
t1 = SqlDateTime.Parse ("02/25/2002 05:25");
- AssertEquals ("#K11", myTicks[3], t1.Value.Ticks);
+ Assert.AreEqual (myTicks[3], t1.Value.Ticks, "#K11");
t1 = SqlDateTime.Parse ("02/25/2002 05:25:13");
- AssertEquals ("#K12", myTicks[4], t1.Value.Ticks);
+ Assert.AreEqual (myTicks[4], t1.Value.Ticks, "#K12");
t1 = SqlDateTime.Parse ("2002-02-25 04:25:13Z");
t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1.Value);
- AssertEquals ("#K13", 2002, t1.Value.Year);
- AssertEquals ("#K14", 02, t1.Value.Month);
- AssertEquals ("#K15", 25, t1.Value.Day);
- AssertEquals ("#K16", 04, t1.Value.Hour);
- AssertEquals ("#K17", 25, t1.Value.Minute);
- AssertEquals ("#K18", 13, t1.Value.Second);
+ Assert.AreEqual (2002, t1.Value.Year, "#K13");
+ Assert.AreEqual (02, t1.Value.Month, "#K14");
+ Assert.AreEqual (25, t1.Value.Day, "#K15");
+ Assert.AreEqual (04, t1.Value.Hour, "#K16");
+ Assert.AreEqual (25, t1.Value.Minute, "#K17");
+ Assert.AreEqual (13, t1.Value.Second, "#K18");
SqlDateTime t2 = new SqlDateTime (DateTime.Today.Year, 2, 25);
t1 = SqlDateTime.Parse ("February 25");
- AssertEquals ("#K19", t2.Value.Ticks, t1.Value.Ticks);
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#K19");
t2 = new SqlDateTime (DateTime.Today.Year, 2, 8);
t1 = SqlDateTime.Parse ("February 08");
- AssertEquals ("#K20", t2.Value.Ticks, t1.Value.Ticks);
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#K20");
t1 = SqlDateTime.Parse ("Mon, 25 Feb 2002 04:25:13 GMT");
t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1.Value);
- AssertEquals ("#K21", 2002, t1.Value.Year);
- AssertEquals ("#K22", 02, t1.Value.Month);
- AssertEquals ("#K23", 25, t1.Value.Day);
- AssertEquals ("#K24", 04, t1.Value.Hour);
- AssertEquals ("#K25", 25, t1.Value.Minute);
- AssertEquals ("#K26", 13, t1.Value.Second);
+ Assert.AreEqual (2002, t1.Value.Year, "#K21");
+ Assert.AreEqual (02, t1.Value.Month, "#K22");
+ Assert.AreEqual (25, t1.Value.Day, "#K23");
+ Assert.AreEqual (04, t1.Value.Hour, "#K24");
+ Assert.AreEqual (25, t1.Value.Minute, "#K25");
+ Assert.AreEqual (13, t1.Value.Second, "#K26");
t1 = SqlDateTime.Parse ("2002-02-25T05:25:13");
- AssertEquals ("#K27", myTicks[4], t1.Value.Ticks);
+ Assert.AreEqual (myTicks[4], t1.Value.Ticks, "#K27");
t2 = DateTime.Today + new TimeSpan (5,25,0);
t1 = SqlDateTime.Parse ("05:25");
- AssertEquals("#K28", t2.Value.Ticks, t1.Value.Ticks);
+ Assert.AreEqual(t2.Value.Ticks, t1.Value.Ticks, "#K28");
t2 = DateTime.Today + new TimeSpan (5,25,13);
t1 = SqlDateTime.Parse ("05:25:13");
- AssertEquals("#K29", t2.Value.Ticks, t1.Value.Ticks);
+ Assert.AreEqual(t2.Value.Ticks, t1.Value.Ticks, "#K29");
t2 = new SqlDateTime (2002, 2, 1);
t1 = SqlDateTime.Parse ("2002 February");
- AssertEquals ("#K30", t2.Value.Ticks, t1.Value.Ticks);
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#K30");
t2 = new SqlDateTime (2002, 2, 1);
t1 = SqlDateTime.Parse ("2002 February");
- AssertEquals ("#K31", t2.Value.Ticks, t1.Value.Ticks);
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#K31");
t2 = new SqlDateTime (DateTime.Today.Year, 2, 8);
t1 = SqlDateTime.Parse ("February 8");
- AssertEquals ("#K32", t2.Value.Ticks, t1.Value.Ticks);
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#K32");
}
[Test]
@@ -377,8 +370,8 @@ namespace MonoTests.System.Data.SqlTypes
SqlDateTime t2 = new SqlDateTime (2002, 2, 25, 15, 25, 13);
// Standard patterns
- AssertEquals("L01", "2/25/2002 5:25:13 AM", t1.ToString ());
- AssertEquals("L02", (SqlString)"2/25/2002 5:25:13 AM", t1.ToSqlString ());
+ Assert.AreEqual("2/25/2002 5:25:13 AM", t1.ToString (), "L01");
+ Assert.AreEqual((SqlString)"2/25/2002 5:25:13 AM", t1.ToSqlString (), "L02");
}
// OPERATORS
@@ -390,34 +383,34 @@ namespace MonoTests.System.Data.SqlTypes
// "+"-operator
ResultDateTime = Test1 + TestSpan;
- AssertEquals ("#M01", 2002, ResultDateTime.Value.Year);
- AssertEquals ("#M02", 8, ResultDateTime.Value.Day);
- AssertEquals ("#M03", 11, ResultDateTime.Value.Hour);
- AssertEquals ("#M04", 0, ResultDateTime.Value.Minute);
- AssertEquals ("#M05", 20, ResultDateTime.Value.Second);
- Assert ("#M06", (SqlDateTime.Null + TestSpan).IsNull);
+ Assert.AreEqual (2002, ResultDateTime.Value.Year, "#M01");
+ Assert.AreEqual (8, ResultDateTime.Value.Day, "#M02");
+ Assert.AreEqual (11, ResultDateTime.Value.Hour, "#M03");
+ Assert.AreEqual (0, ResultDateTime.Value.Minute, "#M04");
+ Assert.AreEqual (20, ResultDateTime.Value.Second, "#M05");
+ Assert.IsTrue ((SqlDateTime.Null + TestSpan).IsNull, "#M06");
try {
ResultDateTime = SqlDateTime.MaxValue + TestSpan;
- Fail ("#M07");
+ Assert.Fail ("#M07");
} catch (Exception e) {
- AssertEquals ("#M08", typeof (ArgumentOutOfRangeException), e.GetType ());
+ Assert.AreEqual (typeof (ArgumentOutOfRangeException), e.GetType (), "#M08");
}
// "-"-operator
ResultDateTime = Test1 - TestSpan;
- AssertEquals ("#M09", 2002, ResultDateTime.Value.Year);
- AssertEquals ("#M10", 29, ResultDateTime.Value.Day);
- AssertEquals ("#M11", 8, ResultDateTime.Value.Hour);
- AssertEquals ("#M12", 19, ResultDateTime.Value.Minute);
- AssertEquals ("#M13", 40, ResultDateTime.Value.Second);
- Assert ("#M14", (SqlDateTime.Null - TestSpan).IsNull);
+ Assert.AreEqual (2002, ResultDateTime.Value.Year, "#M09");
+ Assert.AreEqual (29, ResultDateTime.Value.Day, "#M10");
+ Assert.AreEqual (8, ResultDateTime.Value.Hour, "#M11");
+ Assert.AreEqual (19, ResultDateTime.Value.Minute, "#M12");
+ Assert.AreEqual (40, ResultDateTime.Value.Second, "#M13");
+ Assert.IsTrue ((SqlDateTime.Null - TestSpan).IsNull, "#M14");
try {
ResultDateTime = SqlDateTime.MinValue - TestSpan;
- Fail ("#M15");
+ Assert.Fail ("#M15");
} catch (Exception e) {
- AssertEquals ("#M16", typeof (SqlTypeException), e.GetType ());
+ Assert.AreEqual (typeof (SqlTypeException), e.GetType (), "#M16");
}
}
@@ -425,49 +418,49 @@ namespace MonoTests.System.Data.SqlTypes
public void ThanOrEqualOperators()
{
// == -operator
- Assert ("#N01", (Test2 == Test3).Value);
- Assert ("#N02", !(Test1 == Test2).Value);
- Assert ("#N03", (Test1 == SqlDateTime.Null).IsNull);
+ Assert.IsTrue ((Test2 == Test3).Value, "#N01");
+ Assert.IsTrue (!(Test1 == Test2).Value, "#N02");
+ Assert.IsTrue ((Test1 == SqlDateTime.Null).IsNull, "#N03");
// != -operator
- Assert ("#N04", !(Test2 != Test3).Value);
- Assert ("#N05", (Test1 != Test3).Value);
- Assert ("#N06", (Test1 != SqlDateTime.Null).IsNull);
+ Assert.IsTrue (!(Test2 != Test3).Value, "#N04");
+ Assert.IsTrue ((Test1 != Test3).Value, "#N05");
+ Assert.IsTrue ((Test1 != SqlDateTime.Null).IsNull, "#N06");
// > -operator
- Assert ("#N07", (Test2 > Test1).Value);
- Assert ("#N08", !(Test3 > Test2).Value);
- Assert ("#N09", (Test1 > SqlDateTime.Null).IsNull);
+ Assert.IsTrue ((Test2 > Test1).Value, "#N07");
+ Assert.IsTrue (!(Test3 > Test2).Value, "#N08");
+ Assert.IsTrue ((Test1 > SqlDateTime.Null).IsNull, "#N09");
// >= -operator
- Assert ("#N10", !(Test1 >= Test3).Value);
- Assert ("#N11", (Test3 >= Test1).Value);
- Assert ("#N12", (Test2 >= Test3).Value);
- Assert ("#N13", (Test1 >= SqlDateTime.Null).IsNull);
+ Assert.IsTrue (!(Test1 >= Test3).Value, "#N10");
+ Assert.IsTrue ((Test3 >= Test1).Value, "#N11");
+ Assert.IsTrue ((Test2 >= Test3).Value, "#N12");
+ Assert.IsTrue ((Test1 >= SqlDateTime.Null).IsNull, "#N13");
// < -operator
- Assert ("#N14", !(Test2 < Test1).Value);
- Assert ("#N15", (Test1 < Test3).Value);
- Assert ("#N16", !(Test2 < Test3).Value);
- Assert ("#N17", (Test1 < SqlDateTime.Null).IsNull);
+ Assert.IsTrue (!(Test2 < Test1).Value, "#N14");
+ Assert.IsTrue ((Test1 < Test3).Value, "#N15");
+ Assert.IsTrue (!(Test2 < Test3).Value, "#N16");
+ Assert.IsTrue ((Test1 < SqlDateTime.Null).IsNull, "#N17");
// <= -operator
- Assert ("#N18", (Test1 <= Test3).Value);
- Assert ("#N19", !(Test3 <= Test1).Value);
- Assert ("#N20", (Test2 <= Test3).Value);
- Assert ("#N21", (Test1 <= SqlDateTime.Null).IsNull);
+ Assert.IsTrue ((Test1 <= Test3).Value, "#N18");
+ Assert.IsTrue (!(Test3 <= Test1).Value, "#N19");
+ Assert.IsTrue ((Test2 <= Test3).Value, "#N20");
+ Assert.IsTrue ((Test1 <= SqlDateTime.Null).IsNull, "#N21");
}
[Test]
public void SqlDateTimeToDateTime()
{
- AssertEquals ("O01", 2002, ((DateTime)Test1).Year);
- AssertEquals ("O03", 2003, ((DateTime)Test2).Year);
- AssertEquals ("O04", 10, ((DateTime)Test1).Month);
- AssertEquals ("O05", 19, ((DateTime)Test1).Day);
- AssertEquals ("O06", 9, ((DateTime)Test1).Hour);
- AssertEquals ("O07", 40, ((DateTime)Test1).Minute);
- AssertEquals ("O08", 0, ((DateTime)Test1).Second);
+ Assert.AreEqual (2002, ((DateTime)Test1).Year, "O01");
+ Assert.AreEqual (2003, ((DateTime)Test2).Year, "O03");
+ Assert.AreEqual (10, ((DateTime)Test1).Month, "O04");
+ Assert.AreEqual (19, ((DateTime)Test1).Day, "O05");
+ Assert.AreEqual (9, ((DateTime)Test1).Hour, "O06");
+ Assert.AreEqual (40, ((DateTime)Test1).Minute, "O07");
+ Assert.AreEqual (0, ((DateTime)Test1).Second, "O08");
}
[Test]
@@ -477,69 +470,69 @@ namespace MonoTests.System.Data.SqlTypes
SqlString TestString = new SqlString ("02/25/2002");
SqlDateTime t1 = (SqlDateTime)TestString;
- AssertEquals ("#P01", myTicks[0], t1.Value.Ticks);
+ Assert.AreEqual (myTicks[0], t1.Value.Ticks, "#P01");
// Thanks for Martin Baulig for these (DateTimeTest.cs)
- AssertEquals ("#P02", myTicks[0], t1.Value.Ticks);
+ Assert.AreEqual (myTicks[0], t1.Value.Ticks, "#P02");
t1 = (SqlDateTime) new SqlString ("Monday, 25 February 2002");
- AssertEquals ("#P04", myTicks[0], t1.Value.Ticks);
+ Assert.AreEqual (myTicks[0], t1.Value.Ticks, "#P04");
t1 = (SqlDateTime) new SqlString ("Monday, 25 February 2002 05:25");
- AssertEquals ("#P05", myTicks[3], t1.Value.Ticks);
+ Assert.AreEqual (myTicks[3], t1.Value.Ticks, "#P05");
t1 = (SqlDateTime) new SqlString ("Monday, 25 February 2002 05:25:13");
- AssertEquals ("#P05", myTicks[4], t1.Value.Ticks);
+ Assert.AreEqual (myTicks[4], t1.Value.Ticks, "#P05");
t1 = (SqlDateTime) new SqlString ("02/25/2002 05:25");
- AssertEquals ("#P06", myTicks[3], t1.Value.Ticks);
+ Assert.AreEqual (myTicks[3], t1.Value.Ticks, "#P06");
t1 = (SqlDateTime) new SqlString ("02/25/2002 05:25:13");
- AssertEquals ("#P07", myTicks[4], t1.Value.Ticks);
+ Assert.AreEqual (myTicks[4], t1.Value.Ticks, "#P07");
t1 = (SqlDateTime) new SqlString ("2002-02-25 04:25:13Z");
t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1.Value);
- AssertEquals ("#P08", 2002, t1.Value.Year);
- AssertEquals ("#P09", 02, t1.Value.Month);
- AssertEquals ("#P10", 25, t1.Value.Day);
- AssertEquals ("#P11", 04, t1.Value.Hour);
- AssertEquals ("#P12", 25, t1.Value.Minute);
- AssertEquals ("#P13", 13, t1.Value.Second);
+ Assert.AreEqual (2002, t1.Value.Year, "#P08");
+ Assert.AreEqual (02, t1.Value.Month, "#P09");
+ Assert.AreEqual (25, t1.Value.Day, "#P10");
+ Assert.AreEqual (04, t1.Value.Hour, "#P11");
+ Assert.AreEqual (25, t1.Value.Minute, "#P12");
+ Assert.AreEqual (13, t1.Value.Second, "#P13");
SqlDateTime t2 = new SqlDateTime (DateTime.Today.Year, 2, 25);
t1 = (SqlDateTime) new SqlString ("February 25");
- AssertEquals ("#P14", t2.Value.Ticks, t1.Value.Ticks);
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#P14");
t2 = new SqlDateTime (DateTime.Today.Year, 2, 8);
t1 = (SqlDateTime) new SqlString ("February 08");
- AssertEquals ("#P15", t2.Value.Ticks, t1.Value.Ticks);
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#P15");
t1 = (SqlDateTime) new SqlString ("Mon, 25 Feb 2002 04:25:13 GMT");
t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1.Value);
- AssertEquals ("#P16", 2002, t1.Value.Year);
- AssertEquals ("#P17", 02, t1.Value.Month);
- AssertEquals ("#P18", 25, t1.Value.Day);
- AssertEquals ("#P19", 04, t1.Value.Hour);
- AssertEquals ("#P20", 25, t1.Value.Minute);
- AssertEquals ("#P21", 13, t1.Value.Second);
+ Assert.AreEqual (2002, t1.Value.Year, "#P16");
+ Assert.AreEqual (02, t1.Value.Month, "#P17");
+ Assert.AreEqual (25, t1.Value.Day, "#P18");
+ Assert.AreEqual (04, t1.Value.Hour, "#P19");
+ Assert.AreEqual (25, t1.Value.Minute, "#P20");
+ Assert.AreEqual (13, t1.Value.Second, "#P21");
t1 = (SqlDateTime) new SqlString ("2002-02-25T05:25:13");
- AssertEquals ("#P22", myTicks[4], t1.Value.Ticks);
+ Assert.AreEqual (myTicks[4], t1.Value.Ticks, "#P22");
t2 = DateTime.Today + new TimeSpan (5,25,0);
t1 = (SqlDateTime) new SqlString ("05:25");
- AssertEquals("#P23", t2.Value.Ticks, t1.Value.Ticks);
+ Assert.AreEqual(t2.Value.Ticks, t1.Value.Ticks, "#P23");
t2 = DateTime.Today + new TimeSpan (5,25,13);
t1 = (SqlDateTime) new SqlString ("05:25:13");
- AssertEquals("#P24", t2.Value.Ticks, t1.Value.Ticks);
+ Assert.AreEqual(t2.Value.Ticks, t1.Value.Ticks, "#P24");
t2 = new SqlDateTime (2002, 2, 1);
t1 = (SqlDateTime) new SqlString ("2002 February");
- AssertEquals ("#P25", t2.Value.Ticks, t1.Value.Ticks);
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#P25");
t2 = new SqlDateTime (2002, 2, 1);
t1 = (SqlDateTime) new SqlString ("2002 February");
- AssertEquals ("#P26", t2.Value.Ticks, t1.Value.Ticks);
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#P26");
t2 = new SqlDateTime (DateTime.Today.Year, 2, 8);
t1 = (SqlDateTime) new SqlString ("February 8");
- AssertEquals ("#P27", t2.Value.Ticks, t1.Value.Ticks);
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#P27");
}
[Test]
@@ -547,12 +540,12 @@ namespace MonoTests.System.Data.SqlTypes
{
DateTime DateTimeTest = new DateTime (2002, 10, 19, 11, 53, 4);
SqlDateTime Result = (SqlDateTime)DateTimeTest;
- AssertEquals ("#Q01", 2002, Result.Value.Year);
- AssertEquals ("#Q02", 10, Result.Value.Month);
- AssertEquals ("#Q03", 19, Result.Value.Day);
- AssertEquals ("#Q04", 11, Result.Value.Hour);
- AssertEquals ("#Q05", 53, Result.Value.Minute);
- AssertEquals ("#Q06", 4, Result.Value.Second);
+ Assert.AreEqual (2002, Result.Value.Year, "#Q01");
+ Assert.AreEqual (10, Result.Value.Month, "#Q02");
+ Assert.AreEqual (19, Result.Value.Day, "#Q03");
+ Assert.AreEqual (11, Result.Value.Hour, "#Q04");
+ Assert.AreEqual (53, Result.Value.Minute, "#Q05");
+ Assert.AreEqual (4, Result.Value.Second, "#Q06");
}
[Test]
@@ -561,13 +554,13 @@ namespace MonoTests.System.Data.SqlTypes
SqlDateTime d1 = new SqlDateTime (2007, 05, 04, 18, 02, 40, 398.25);
SqlDateTime d2 = new SqlDateTime (d1.DayTicks, d1.TimeTicks);
- AssertEquals ("#R01", 39204, d1.DayTicks);
- AssertEquals ("#R02", 19488119, d1.TimeTicks);
- AssertEquals ("#R03", 633138985603970000, d1.Value.Ticks);
- AssertEquals ("#R04", d1.DayTicks, d2.DayTicks);
- AssertEquals ("#R05", d1.TimeTicks, d2.TimeTicks);
- AssertEquals ("#R06", d1.Value.Ticks, d2.Value.Ticks);
- AssertEquals ("#R07", d1, d2);
+ Assert.AreEqual (39204, d1.DayTicks, "#R01");
+ Assert.AreEqual (19488119, d1.TimeTicks, "#R02");
+ Assert.AreEqual (633138985603970000, d1.Value.Ticks, "#R03");
+ Assert.AreEqual (d1.DayTicks, d2.DayTicks, "#R04");
+ Assert.AreEqual (d1.TimeTicks, d2.TimeTicks, "#R05");
+ Assert.AreEqual (d1.Value.Ticks, d2.Value.Ticks, "#R06");
+ Assert.AreEqual (d1, d2, "#R07");
}
[Test]
@@ -575,9 +568,9 @@ namespace MonoTests.System.Data.SqlTypes
{
SqlDateTime d1 = new SqlDateTime (2007, 05, 04, 18, 02, 40, 398252);
- AssertEquals ("#S01", 39204, d1.DayTicks);
- AssertEquals ("#S02", 19488119, d1.TimeTicks);
- AssertEquals ("#R03", 633138985603970000, d1.Value.Ticks);
+ Assert.AreEqual (39204, d1.DayTicks, "#S01");
+ Assert.AreEqual (19488119, d1.TimeTicks, "#S02");
+ Assert.AreEqual (633138985603970000, d1.Value.Ticks, "#R03");
}
#if NET_2_0
diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlGuidTest.cs b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlGuidTest.cs
index ed1085e81ab..a2986aa534d 100644
--- a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlGuidTest.cs
+++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlGuidTest.cs
@@ -40,7 +40,7 @@ using System.Data.SqlTypes;
namespace MonoTests.System.Data.SqlTypes
{
[TestFixture]
- public class SqlGuidTest : Assertion {
+ public class SqlGuidTest {
// 00000a01-0000-0000-0000-000000000000
private SqlGuid Test1;
@@ -98,7 +98,7 @@ namespace MonoTests.System.Data.SqlTypes
Test = new SqlGuid (10, 1, 2, 13, 14, 15, 16, 17, 19, 20 ,21);
} catch (Exception e) {
- Fail ("#A01 " + e);
+ Assert.Fail ("#A01 " + e);
}
}
@@ -106,7 +106,7 @@ namespace MonoTests.System.Data.SqlTypes
[Test]
public void PublicFields()
{
- Assert ("#B01", SqlGuid.Null.IsNull);
+ Assert.IsTrue (SqlGuid.Null.IsNull, "#B01");
}
// Test properties
@@ -114,9 +114,9 @@ namespace MonoTests.System.Data.SqlTypes
public void Properties()
{
Guid ResultGuid = new Guid ("00000f64-0000-0000-0000-000000000000");
- Assert ("#C01", !Test1.IsNull);
- Assert ("#C02", SqlGuid.Null.IsNull);
- AssertEquals ("#C03", ResultGuid, Test2.Value);
+ Assert.IsTrue (!Test1.IsNull, "#C01");
+ Assert.IsTrue (SqlGuid.Null.IsNull, "#C02");
+ Assert.AreEqual (ResultGuid, Test2.Value, "#C03");
}
// PUBLIC METHODS
@@ -127,85 +127,85 @@ namespace MonoTests.System.Data.SqlTypes
SqlGuid test1 = new SqlGuid("1AAAAAAA-BBBB-CCCC-DDDD-3EEEEEEEEEEE");
SqlGuid test2 = new SqlGuid("1AAAAAAA-BBBB-CCCC-DDDD-2EEEEEEEEEEE");
SqlGuid test3 = new SqlGuid("1AAAAAAA-BBBB-CCCC-DDDD-1EEEEEEEEEEE");
- Assert ("#D01", Test1.CompareTo (Test3) < 0);
- Assert ("#D02", Test4.CompareTo (Test1) > 0);
- Assert ("#D03", Test3.CompareTo (Test2) == 0);
- Assert ("#D04", Test4.CompareTo (SqlGuid.Null) > 0);
- Assert ("#D05", test1.CompareTo (test2) > 0);
- Assert ("#D06", test3.CompareTo (test2) < 0);
+ Assert.IsTrue (Test1.CompareTo (Test3) < 0, "#D01");
+ Assert.IsTrue (Test4.CompareTo (Test1) > 0, "#D02");
+ Assert.IsTrue (Test3.CompareTo (Test2) == 0, "#D03");
+ Assert.IsTrue (Test4.CompareTo (SqlGuid.Null) > 0, "#D04");
+ Assert.IsTrue (test1.CompareTo (test2) > 0, "#D05");
+ Assert.IsTrue (test3.CompareTo (test2) < 0, "#D06");
try {
Test1.CompareTo (TestString);
- Fail("#D05");
+ Assert.Fail("#D05");
} catch(Exception e) {
- AssertEquals ("#D06", typeof (ArgumentException), e.GetType ());
+ Assert.AreEqual (typeof (ArgumentException), e.GetType (), "#D06");
}
}
[Test]
public void EqualsMethods()
{
- Assert ("#E01", !Test1.Equals (Test2));
- Assert ("#E02", !Test2.Equals (Test4));
- Assert ("#E03", !Test2.Equals (new SqlString ("TEST")));
- Assert ("#E04", Test2.Equals (Test3));
+ Assert.IsTrue (!Test1.Equals (Test2), "#E01");
+ Assert.IsTrue (!Test2.Equals (Test4), "#E02");
+ Assert.IsTrue (!Test2.Equals (new SqlString ("TEST")), "#E03");
+ Assert.IsTrue (Test2.Equals (Test3), "#E04");
// Static Equals()-method
- Assert ("#E05", SqlGuid.Equals (Test2, Test3).Value);
- Assert ("#E06", !SqlGuid.Equals (Test1, Test2).Value);
+ Assert.IsTrue (SqlGuid.Equals (Test2, Test3).Value, "#E05");
+ Assert.IsTrue (!SqlGuid.Equals (Test1, Test2).Value, "#E06");
}
[Test]
public void GetHashCodeTest()
{
- AssertEquals ("#F01", Test1.GetHashCode (), Test1.GetHashCode ());
- Assert ("#F02", Test1.GetHashCode () != Test2.GetHashCode ());
- AssertEquals ("#F02", Test3.GetHashCode (), Test2.GetHashCode ());
+ Assert.AreEqual (Test1.GetHashCode (), Test1.GetHashCode (), "#F01");
+ Assert.IsTrue (Test1.GetHashCode () != Test2.GetHashCode (), "#F02");
+ Assert.AreEqual (Test3.GetHashCode (), Test2.GetHashCode (), "#F02");
}
[Test]
public void GetTypeTest()
{
- AssertEquals ("#G01", "System.Data.SqlTypes.SqlGuid", Test1.GetType ().ToString ());
- AssertEquals ("#G02", "System.Guid", Test3.Value.GetType ().ToString ());
+ Assert.AreEqual ("System.Data.SqlTypes.SqlGuid", Test1.GetType ().ToString (), "#G01");
+ Assert.AreEqual ("System.Guid", Test3.Value.GetType ().ToString (), "#G02");
}
[Test]
public void Greaters()
{
// GreateThan ()
- Assert ("#H01", !SqlGuid.GreaterThan (Test1, Test2).Value);
- Assert ("#H02", SqlGuid.GreaterThan (Test2, Test1).Value);
- Assert ("#H03", !SqlGuid.GreaterThan (Test2, Test3).Value);
+ Assert.IsTrue (!SqlGuid.GreaterThan (Test1, Test2).Value, "#H01");
+ Assert.IsTrue (SqlGuid.GreaterThan (Test2, Test1).Value, "#H02");
+ Assert.IsTrue (!SqlGuid.GreaterThan (Test2, Test3).Value, "#H03");
// GreaterTharOrEqual ()
- Assert ("#H04", !SqlGuid.GreaterThanOrEqual (Test1, Test2).Value);
- Assert ("#H05", SqlGuid.GreaterThanOrEqual (Test2, Test1).Value);
- Assert ("#H06", SqlGuid.GreaterThanOrEqual (Test2, Test3).Value);
+ Assert.IsTrue (!SqlGuid.GreaterThanOrEqual (Test1, Test2).Value, "#H04");
+ Assert.IsTrue (SqlGuid.GreaterThanOrEqual (Test2, Test1).Value, "#H05");
+ Assert.IsTrue (SqlGuid.GreaterThanOrEqual (Test2, Test3).Value, "#H06");
}
[Test]
public void Lessers()
{
// LessThan()
- Assert ("#I01", !SqlGuid.LessThan (Test2, Test3).Value);
- Assert ("#I02", !SqlGuid.LessThan (Test2, Test1).Value);
- Assert ("#I03", SqlGuid.LessThan (Test1, Test2).Value);
+ Assert.IsTrue (!SqlGuid.LessThan (Test2, Test3).Value, "#I01");
+ Assert.IsTrue (!SqlGuid.LessThan (Test2, Test1).Value, "#I02");
+ Assert.IsTrue (SqlGuid.LessThan (Test1, Test2).Value, "#I03");
// LessThanOrEqual ()
- Assert ("#I04", SqlGuid.LessThanOrEqual (Test1, Test2).Value);
- Assert ("#I05", !SqlGuid.LessThanOrEqual (Test2, Test1).Value);
- Assert ("#I06", SqlGuid.LessThanOrEqual (Test2, Test3).Value);
- Assert ("#I07", SqlGuid.LessThanOrEqual (Test4, SqlGuid.Null).IsNull);
+ Assert.IsTrue (SqlGuid.LessThanOrEqual (Test1, Test2).Value, "#I04");
+ Assert.IsTrue (!SqlGuid.LessThanOrEqual (Test2, Test1).Value, "#I05");
+ Assert.IsTrue (SqlGuid.LessThanOrEqual (Test2, Test3).Value, "#I06");
+ Assert.IsTrue (SqlGuid.LessThanOrEqual (Test4, SqlGuid.Null).IsNull, "#I07");
}
[Test]
public void NotEquals()
{
- Assert ("#J01", SqlGuid.NotEquals (Test1, Test2).Value);
- Assert ("#J02", SqlGuid.NotEquals (Test2, Test1).Value);
- Assert ("#J03", SqlGuid.NotEquals (Test3, Test1).Value);
- Assert ("#J04", !SqlGuid.NotEquals (Test3, Test2).Value);
- Assert ("#J05", SqlGuid.NotEquals (SqlGuid.Null, Test2).IsNull);
+ Assert.IsTrue (SqlGuid.NotEquals (Test1, Test2).Value, "#J01");
+ Assert.IsTrue (SqlGuid.NotEquals (Test2, Test1).Value, "#J02");
+ Assert.IsTrue (SqlGuid.NotEquals (Test3, Test1).Value, "#J03");
+ Assert.IsTrue (!SqlGuid.NotEquals (Test3, Test2).Value, "#J04");
+ Assert.IsTrue (SqlGuid.NotEquals (SqlGuid.Null, Test2).IsNull, "#J05");
}
[Test]
@@ -213,54 +213,49 @@ namespace MonoTests.System.Data.SqlTypes
{
try {
SqlGuid.Parse (null);
- Fail ("#K01");
+ Assert.Fail ("#K01");
} catch (Exception e) {
- AssertEquals ("#K02", typeof (ArgumentNullException), e.GetType ());
+ Assert.AreEqual (typeof (ArgumentNullException), e.GetType (), "#K02");
}
try {
SqlGuid.Parse ("not-a-number");
- Fail ("#K03");
+ Assert.Fail ("#K03");
} catch (Exception e) {
- AssertEquals ("#K04", typeof (FormatException), e.GetType ());
+ Assert.AreEqual (typeof (FormatException), e.GetType (), "#K04");
}
try {
SqlGuid.Parse ("9e400");
- Fail ("#K05");
+ Assert.Fail ("#K05");
} catch (Exception e) {
- AssertEquals ("#K06", typeof (FormatException), e.GetType ());
+ Assert.AreEqual (typeof (FormatException), e.GetType (), "#K06");
}
- AssertEquals("#K07", new Guid("87654321-0000-0000-0000-000000000000"),
- SqlGuid.Parse ("87654321-0000-0000-0000-000000000000").Value);
+ Assert.AreEqual(new Guid("87654321-0000-0000-0000-000000000000"), SqlGuid.Parse ("87654321-0000-0000-0000-000000000000").Value, "#K07");
}
[Test]
public void Conversions()
{
// ToByteArray ()
- AssertEquals ("#L01", (byte)1, Test1.ToByteArray () [0]);
- AssertEquals ("#L02", (byte)15, Test2.ToByteArray () [1]);
+ Assert.AreEqual ((byte)1, Test1.ToByteArray () [0], "#L01");
+ Assert.AreEqual ((byte)15, Test2.ToByteArray () [1], "#L02");
// ToSqlBinary ()
byte [] b = new byte [2];
b [0] = 100;
b [1] = 15;
- AssertEquals ("#L03", new SqlBinary (b), Test3.ToSqlBinary ());
+ Assert.AreEqual (new SqlBinary (b), Test3.ToSqlBinary (), "#L03");
// ToSqlString ()
- AssertEquals ("#L04", "00000a01-0000-0000-0000-000000000000",
- Test1.ToSqlString ().Value);
- AssertEquals ("#L05", "0000fafa-0000-0000-0000-000000000000",
- Test4.ToSqlString ().Value);
+ Assert.AreEqual ("00000a01-0000-0000-0000-000000000000", Test1.ToSqlString ().Value, "#L04");
+ Assert.AreEqual ("0000fafa-0000-0000-0000-000000000000", Test4.ToSqlString ().Value, "#L05");
// ToString ()
- AssertEquals ("#L06", "00000a01-0000-0000-0000-000000000000",
- Test1.ToString ());
- AssertEquals ("#L07", "0000fafa-0000-0000-0000-000000000000",
- Test4.ToString ());
+ Assert.AreEqual ("00000a01-0000-0000-0000-000000000000", Test1.ToString (), "#L06");
+ Assert.AreEqual ("0000fafa-0000-0000-0000-000000000000", Test4.ToString (), "#L07");
}
// OPERATORS
@@ -269,38 +264,38 @@ namespace MonoTests.System.Data.SqlTypes
public void ThanOrEqualOperators()
{
// == -operator
- Assert ("#M01", (Test3 == Test2).Value);
- Assert ("#M02", !(Test1 == Test2).Value);
- Assert ("#M03", (Test1 == SqlGuid.Null).IsNull);
+ Assert.IsTrue ((Test3 == Test2).Value, "#M01");
+ Assert.IsTrue (!(Test1 == Test2).Value, "#M02");
+ Assert.IsTrue ((Test1 == SqlGuid.Null).IsNull, "#M03");
// != -operator
- Assert ("#M04", !(Test2 != Test3).Value);
- Assert ("#M05", (Test1 != Test3).Value);
- Assert ("#M06", (Test1 != SqlGuid.Null).IsNull);
+ Assert.IsTrue (!(Test2 != Test3).Value, "#M04");
+ Assert.IsTrue ((Test1 != Test3).Value, "#M05");
+ Assert.IsTrue ((Test1 != SqlGuid.Null).IsNull, "#M06");
// > -operator
- Assert ("#M07", (Test2 > Test1).Value);
- Assert ("#M08", !(Test1 > Test3).Value);
- Assert ("#M09", !(Test3 > Test2).Value);
- Assert ("#M10", (Test1 > SqlGuid.Null).IsNull);
+ Assert.IsTrue ((Test2 > Test1).Value, "#M07");
+ Assert.IsTrue (!(Test1 > Test3).Value, "#M08");
+ Assert.IsTrue (!(Test3 > Test2).Value, "#M09");
+ Assert.IsTrue ((Test1 > SqlGuid.Null).IsNull, "#M10");
// >= -operator
- Assert ("#M12", !(Test1 >= Test3).Value);
- Assert ("#M13", (Test3 >= Test1).Value);
- Assert ("#M14", (Test3 >= Test2).Value);
- Assert ("#M15", (Test1 >= SqlGuid.Null).IsNull);
+ Assert.IsTrue (!(Test1 >= Test3).Value, "#M12");
+ Assert.IsTrue ((Test3 >= Test1).Value, "#M13");
+ Assert.IsTrue ((Test3 >= Test2).Value, "#M14");
+ Assert.IsTrue ((Test1 >= SqlGuid.Null).IsNull, "#M15");
// < -operator
- Assert ("#M16", !(Test2 < Test1).Value);
- Assert ("#M17", (Test1 < Test3).Value);
- Assert ("#M18", !(Test2 < Test3).Value);
- Assert ("#M19", (Test1 < SqlGuid.Null).IsNull);
+ Assert.IsTrue (!(Test2 < Test1).Value, "#M16");
+ Assert.IsTrue ((Test1 < Test3).Value, "#M17");
+ Assert.IsTrue (!(Test2 < Test3).Value, "#M18");
+ Assert.IsTrue ((Test1 < SqlGuid.Null).IsNull, "#M19");
// <= -operator
- Assert ("#M20", (Test1 <= Test3).Value);
- Assert ("#M21", !(Test3 <= Test1).Value);
- Assert ("#M22", (Test2 <= Test3).Value);
- Assert ("#M23", (Test1 <= SqlGuid.Null).IsNull);
+ Assert.IsTrue ((Test1 <= Test3).Value, "#M20");
+ Assert.IsTrue (!(Test3 <= Test1).Value, "#M21");
+ Assert.IsTrue ((Test2 <= Test3).Value, "#M22");
+ Assert.IsTrue ((Test1 <= SqlGuid.Null).IsNull, "#M23");
}
[Test]
@@ -311,17 +306,14 @@ namespace MonoTests.System.Data.SqlTypes
b [1] = 200;
SqlBinary TestBinary = new SqlBinary (b);
- AssertEquals ("#N01", new Guid("0000c864-0000-0000-0000-000000000000"),
- ((SqlGuid)TestBinary).Value);
+ Assert.AreEqual (new Guid("0000c864-0000-0000-0000-000000000000"), ((SqlGuid)TestBinary).Value, "#N01");
}
[Test]
public void SqlGuidToGuid()
{
- AssertEquals ("#O01", new Guid("00000a01-0000-0000-0000-000000000000"),
- (Guid)Test1);
- AssertEquals ("#O02", new Guid("00000f64-0000-0000-0000-000000000000"),
- (Guid)Test2);
+ Assert.AreEqual (new Guid("00000a01-0000-0000-0000-000000000000"), (Guid)Test1, "#O01");
+ Assert.AreEqual (new Guid("00000f64-0000-0000-0000-000000000000"), (Guid)Test2, "#O02");
}
[Test]
@@ -330,14 +322,13 @@ namespace MonoTests.System.Data.SqlTypes
SqlString TestString = new SqlString ("Test string");
SqlString TestString100 = new SqlString ("0000c864-0000-0000-0000-000000000000");
- AssertEquals ("#P01", new Guid("0000c864-0000-0000-0000-000000000000"),
- ((SqlGuid)TestString100).Value);
+ Assert.AreEqual (new Guid("0000c864-0000-0000-0000-000000000000"), ((SqlGuid)TestString100).Value, "#P01");
try {
SqlGuid test = (SqlGuid)TestString;
- Fail ("#P02");
+ Assert.Fail ("#P02");
} catch(Exception e) {
- AssertEquals ("#P03", typeof (FormatException), e.GetType ());
+ Assert.AreEqual (typeof (FormatException), e.GetType (), "#P03");
}
}
@@ -345,15 +336,14 @@ namespace MonoTests.System.Data.SqlTypes
public void GuidToSqlGuid()
{
Guid TestGuid = new Guid("0000c864-0000-0000-0000-000007650000");
- AssertEquals ("#Q01", new SqlGuid("0000c864-0000-0000-0000-000007650000"),
- (SqlGuid)TestGuid);
+ Assert.AreEqual (new SqlGuid("0000c864-0000-0000-0000-000007650000"), (SqlGuid)TestGuid, "#Q01");
}
#if NET_2_0
[Test]
public void GetXsdTypeTest ()
{
XmlQualifiedName qualifiedName = SqlGuid.GetXsdType (null);
- NUnit.Framework.Assert.AreEqual ("string", qualifiedName.Name, "#A01");
+ Assert.AreEqual ("string", qualifiedName.Name, "#A01");
}
#endif
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-29 19:44:56 +0300