diff options
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
}
|