+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.
namespace MonoTests.System.Data.Common
{
[TestFixture]
- public class DataColumnMappingCollectionTest : Assertion
+ public class DataColumnMappingCollectionTest
{
//DataTableMapping tableMap;
DataColumnMappingCollection columnMapCollection;
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();
}
[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]
[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]
{
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]
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]
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]
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]
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]
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]
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]
public void RemoveException2()
{
columnMapCollection.AddRange(cols);
- DataColumnMapping mymap=new DataColumnMapping("sourceAge","dataSetAge");
+ DataColumnMapping mymap=new DataColumnMapping("sourceAge", "dataSetAge");
columnMapCollection.Remove(mymap);
}
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]
#endif
public void ToStringTest()
{
- AssertEquals("test1","System.Data.Common.DataColumnMappingCollection",columnMapCollection.ToString());
+ Assert.AreEqual ("System.Data.Common.DataColumnMappingCollection", columnMapCollection.ToString(), "test1");
}
}
}
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 ();
namespace MonoTests.System.Data.Common
{
[TestFixture]
- public class DataTableMappingCollectionTest : Assertion
+ public class DataTableMappingCollectionTest
{
DataTableMappingCollection tableMapCollection;
DataTableMapping [] tabs;
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();
}
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]
[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]
{
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]
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]
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");
}
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]
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]
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]
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]
public void RemoveException2()
{
tableMapCollection.AddRange(tabs);
- DataTableMapping mymap=new DataTableMapping("sourceAge","dataSetAge");
+ DataTableMapping mymap=new DataTableMapping("sourceAge", "dataSetAge");
tableMapCollection.Remove(mymap);
}
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]
#endif
public void ToStringTest()
{
- AssertEquals("test1","System.Data.Common.DataTableMappingCollection",tableMapCollection.ToString());
+ Assert.AreEqual("System.Data.Common.DataTableMappingCollection", tableMapCollection.ToString(), "test1");
}
}
}
+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,
reader = cmd.ExecuteReader ();\r
if (reader.Read ()) {\r
byte b = reader.GetByte (0); \r
- Assertion.AssertEquals ("GetByte returns wrong result!", 0xff, b);\r
+ Assert.AreEqual (0xff, b, "GetByte returns wrong result!");\r
} else // This should not happen while testing\r
- Assertion.AssertEquals ("test table doens not have a test data!", true, true);\r
+ Assert.AreEqual (true, true, "test table doens not have a test data!");\r
} finally { // try/catch is necessary to gracefully close connections\r
if (reader != null && reader.IsClosed)\r
reader.Close ();\r
dbcmd.CommandText = sql;\r
IDataReader reader = dbcmd.ExecuteReader ();\r
try {\r
- Assertion.AssertEquals ("GetDataTypeName returns invalid Type for column #1", \r
- "TinyInt", reader.GetDataTypeName (0));\r
- Assertion.AssertEquals ("GetDataTypeName returns invalid Type for column #2", \r
- "VarChar", reader.GetDataTypeName (1));\r
+ Assert.AreEqual ("TinyInt", reader.GetDataTypeName (0), "GetDataTypeName returns invalid Type for column #1");\r
+ Assert.AreEqual ("VarChar", reader.GetDataTypeName (1), "GetDataTypeName returns invalid Type for column #2");\r
// Test via method GetFieldType.ToString\r
- Assertion.AssertEquals ("GetFieldType returns invalid Type for column #1", \r
- "System.Byte", reader.GetFieldType (0).ToString ());\r
- Assertion.AssertEquals ("GetFieldType returns invalid Type for column #2", \r
- "System.String", reader.GetFieldType (1).ToString ());\r
+ Assert.AreEqual ("System.Byte", reader.GetFieldType (0).ToString (), "GetFieldType returns invalid Type for column #1");\r
+ Assert.AreEqual ("System.String", reader.GetFieldType (1).ToString (), "GetFieldType returns invalid Type for column #2");\r
\r
// Test via method GetSchemaTable\r
reader = dbcmd.ExecuteReader ();\r
DataTable schemaTable = reader.GetSchemaTable ();\r
- Assertion.AssertEquals ("GetSchemaTable.ColumnDataType failes for column #1", \r
- typeof (Byte), schemaTable.Rows [0]["DataType"]);\r
- Assertion.AssertEquals ("GetSchemaTable.ColumnDataType failes for column #1", \r
- typeof (String), schemaTable.Rows [1]["DataType"]);\r
+ Assert.AreEqual (typeof (Byte), schemaTable.Rows [0]["DataType"], "GetSchemaTable.ColumnDataType failes for column #1");\r
+ Assert.AreEqual (typeof (String), schemaTable.Rows [1]["DataType"], "GetSchemaTable.ColumnDataType failes for column #1");\r
} finally {\r
// clean up\r
if (reader != null && !reader.IsClosed)\r
dbcmd.CommandText = sql;\r
OdbcDataReader reader = dbcmd.ExecuteReader ();\r
try {\r
- Assertion.AssertEquals ("GetName failes ", "pk_tint", reader.GetName (0));\r
+ Assert.AreEqual ("pk_tint", reader.GetName (0), "GetName failes ");\r
} finally {\r
// clean up\r
if (reader != null && !reader.IsClosed)\r
// assemble here.\r
string col = Encoding.Default.GetString (val, 0, buffstart);\r
\r
- Assertion.AssertEquals ("The assembled value length does not match", \r
- 39, col.Length);\r
+ Assert.AreEqual (39, col.Length, "The assembled value length does not match");\r
}\r
} finally {\r
// clean up\r
OdbcDataReader reader = cmd.ExecuteReader (CommandBehavior.SequentialAccess);\r
try {\r
if (reader.Read ()) {\r
- Assertion.AssertEquals ("GetBytes on a fixed length column does not work!", \r
- 11, reader.GetBytes (1,0,null,0,0));\r
- Assertion.AssertEquals ("GetBytes with non null column does not work!", \r
- 39, reader.GetBytes (3,0,null,0,0));\r
+ Assert.AreEqual (11, reader.GetBytes (1,0,null,0,0), "GetBytes on a fixed length column does not work!");\r
+ Assert.AreEqual (39, reader.GetBytes (3,0,null,0,0), "GetBytes with non null column does not work!");\r
}\r
// for null value, length in bytes should return 0\r
if (reader.Read ()) \r
- Assertion.AssertEquals ("GetBytes with null column does not return -1" ,\r
- -1, reader.GetBytes (3,0,null,0,0));\r
+ AssertEquals ("GetBytes with null column does not return -1" , -1, reader.GetBytes (3,0,null,0,0));\r
} finally {\r
// clean up\r
if (reader != null && !reader.IsClosed )\r
try {\r
if (reader.Read ()) {\r
object ob = reader.GetValue (3);\r
- Assertion.AssertEquals ("Type of binary column is wrong!", \r
- "System.Byte[]", ob.GetType ().ToString () );\r
+ Assert.AreEqual ("System.Byte[]", ob.GetType ().ToString () , "Type of binary column is wrong!");\r
}\r
} finally {\r
// clean up\r
try {\r
if (reader.Read ()) {\r
object ob = reader["col_datetime"];\r
- Assertion.AssertEquals ("Type of datetime column is wrong!", \r
- "System.DateTime", ob.GetType ().ToString () );\r
+ Assert.AreEqual ("System.DateTime", ob.GetType ().ToString () , "Type of datetime column is wrong!");\r
ob = reader["col_date"];\r
- Assertion.AssertEquals ("Type of date column is wrong!", \r
- "System.DateTime", ob.GetType ().ToString () );\r
+ Assert.AreEqual ("System.DateTime", ob.GetType ().ToString () , "Type of date column is wrong!");\r
// FIXME : Once TIME data type is fixed, enable this check\r
//ob = reader["col_time"];\r
- //Assertion.AssertEquals ("Type of time column is wrong!", \r
- //"System.DateTime", ob.GetType ().ToString () );\r
+ //Assert.AreEqual ("System.DateTime", ob.GetType ().ToString () , "Type of time column is wrong!");\r
\r
DateTime dt = reader.GetDateTime (4);\r
- Assertion.AssertEquals ("DateValue (SQL_TIMESTAMP) is wrong", new DateTime (2004, 8, 22, 0, 0, 0), dt);\r
+ Assert.AreEqual (new DateTime (2004, 8, 22, 0, 0, 0), dt, "DateValue (SQL_TIMESTAMP) is wrong");\r
dt = reader.GetDateTime (5);\r
- Assertion.AssertEquals ("DateValue (SQL_DATE) is wrong", new DateTime (2004, 8, 22, 0, 0, 0), dt);\r
+ Assert.AreEqual (new DateTime (2004, 8, 22, 0, 0, 0), dt, "DateValue (SQL_DATE) is wrong");\r
// FIXME : Once TIME data type is fixed, enable this check\r
//dt = reader.GetDateTime (7);\r
- //Assertion.AssertEquals ("DateValue is wrong", "2004-08-22", dt.ToString ());\r
+ //Assert.AreEqual ("2004-08-22", dt.ToString (), "DateValue is wrong");\r
}\r
} finally {\r
// clean up\r
try {\r
if (reader.Read ()) {\r
object ob = reader.GetValue (0);\r
- Assertion.AssertEquals ("Type of tinyInt column is wrong!", \r
- "System.Byte", ob.GetType ().ToString () );\r
- Assertion.AssertEquals ("Value of tinyInt column is wrong!", \r
- 1, Convert.ToInt16(ob) );\r
+ Assert.AreEqual ("System.Byte", ob.GetType ().ToString () , "Type of tinyInt column is wrong!");\r
+ Assert.AreEqual (1, Convert.ToInt16(ob) , "Value of tinyInt column is wrong!");\r
}\r
} finally {\r
// clean up\r
+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
namespace MonoTests.System.Data.SqlTypes
{
[TestFixture]
- public class SqlBinaryTest : Assertion {
+ public class SqlBinaryTest {
SqlBinary Test1;
SqlBinary Test2;
{
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
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");
}
}
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]
{
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]
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]
{
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
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]
SqlGuid TestGuid = new SqlGuid (TestByteArray);
SqlBinary TestBinary = (SqlBinary)TestGuid;
- AssertEquals ("#N01", (byte)15, TestBinary [0]);
+ Assert.AreEqual ((byte)15, TestBinary [0], "#N01");
}
[Test]
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
}
namespace MonoTests.System.Data.SqlTypes\r
{\r
[TestFixture]\r
- public class SqlDateTimeTest : Assertion {\r
+ public class SqlDateTimeTest {\r
\r
private long[] myTicks = {\r
631501920000000000L, // 25 Feb 2002 - 00:00:00\r
// SqlDateTime (DateTime)\r
SqlDateTime CTest = new SqlDateTime (\r
new DateTime (2002, 5, 19, 3, 34, 0));\r
- AssertEquals ("#A01", 2002, CTest.Value.Year);\r
+ Assert.AreEqual (2002, CTest.Value.Year, "#A01");\r
\r
// SqlDateTime (int, int)\r
CTest = new SqlDateTime (0, 0);\r
\r
// SqlDateTime (int, int, int)\r
- AssertEquals ("#A02", 1900, CTest.Value.Year);\r
- AssertEquals ("#A03", 1, CTest.Value.Month);\r
- AssertEquals ("#A04", 1, CTest.Value.Day);\r
- AssertEquals ("#A05", 0, CTest.Value.Hour);\r
+ Assert.AreEqual (1900, CTest.Value.Year, "#A02");\r
+ Assert.AreEqual (1, CTest.Value.Month, "#A03");\r
+ Assert.AreEqual (1, CTest.Value.Day, "#A04");\r
+ Assert.AreEqual (0, CTest.Value.Hour, "#A05");\r
\r
// SqlDateTime (int, int, int, int, int, int)\r
CTest = new SqlDateTime (5000, 12, 31);\r
- AssertEquals ("#A06", 5000, CTest.Value.Year);\r
- AssertEquals ("#A07", 12, CTest.Value.Month);\r
- AssertEquals ("#A08", 31, CTest.Value.Day);\r
+ Assert.AreEqual (5000, CTest.Value.Year, "#A06");\r
+ Assert.AreEqual (12, CTest.Value.Month, "#A07");\r
+ Assert.AreEqual (31, CTest.Value.Day, "#A08");\r
\r
// SqlDateTime (int, int, int, int, int, int, double)\r
CTest = new SqlDateTime (1978, 5, 19, 3, 34, 0);\r
- AssertEquals ("#A09", 1978, CTest.Value.Year);\r
- AssertEquals ("#A10", 5, CTest.Value.Month);\r
- AssertEquals ("#A11", 19, CTest.Value.Day);\r
- AssertEquals ("#A12", 3, CTest.Value.Hour);\r
- AssertEquals ("#A13", 34, CTest.Value.Minute);\r
- AssertEquals ("#A14", 0, CTest.Value.Second);\r
+ Assert.AreEqual (1978, CTest.Value.Year, "#A09");\r
+ Assert.AreEqual (5, CTest.Value.Month, "#A10");\r
+ Assert.AreEqual (19, CTest.Value.Day, "#A11");\r
+ Assert.AreEqual (3, CTest.Value.Hour, "#A12");\r
+ Assert.AreEqual (34, CTest.Value.Minute, "#A13");\r
+ Assert.AreEqual (0, CTest.Value.Second, "#A14");\r
\r
try {\r
CTest = new SqlDateTime (10000, 12, 31);\r
- Fail ("#A15");\r
+ Assert.Fail ("#A15");\r
} catch (Exception e) {\r
- AssertEquals ("#A16", typeof (SqlTypeException),\r
- e.GetType ());\r
+ Assert.AreEqual (typeof (SqlTypeException), e.GetType (), "#A16");\r
}\r
\r
// SqlDateTime (int, int, int, int, int, int, int)\r
CTest = new SqlDateTime (1978, 5, 19, 3, 34, 0, 12);\r
- AssertEquals ("#A17", 1978, CTest.Value.Year);\r
- AssertEquals ("#A18", 5, CTest.Value.Month);\r
- AssertEquals ("#A19", 19, CTest.Value.Day);\r
- AssertEquals ("#A20", 3, CTest.Value.Hour);\r
- AssertEquals ("#A21", 34, CTest.Value.Minute);\r
- AssertEquals ("#A22", 0, CTest.Value.Second);\r
- AssertEquals ("#A23", 0, CTest.Value.Millisecond);\r
+ Assert.AreEqual (1978, CTest.Value.Year, "#A17");\r
+ Assert.AreEqual (5, CTest.Value.Month, "#A18");\r
+ Assert.AreEqual (19, CTest.Value.Day, "#A19");\r
+ Assert.AreEqual (3, CTest.Value.Hour, "#A20");\r
+ Assert.AreEqual (34, CTest.Value.Minute, "#A21");\r
+ Assert.AreEqual (0, CTest.Value.Second, "#A22");\r
+ Assert.AreEqual (0, CTest.Value.Millisecond, "#A23");\r
}\r
\r
// Test public fields\r
public void PublicFields()\r
{\r
// MaxValue\r
- AssertEquals ("#B01", 9999, SqlDateTime.MaxValue.Value.Year);\r
- AssertEquals ("#B02", 12, SqlDateTime.MaxValue.Value.Month);\r
- AssertEquals ("#B03", 31, SqlDateTime.MaxValue.Value.Day);\r
- AssertEquals ("#B04", 23, SqlDateTime.MaxValue.Value.Hour);\r
- AssertEquals ("#B05", 59, SqlDateTime.MaxValue.Value.Minute);\r
- AssertEquals ("#B06", 59, SqlDateTime.MaxValue.Value.Second);\r
+ Assert.AreEqual (9999, SqlDateTime.MaxValue.Value.Year, "#B01");\r
+ Assert.AreEqual (12, SqlDateTime.MaxValue.Value.Month, "#B02");\r
+ Assert.AreEqual (31, SqlDateTime.MaxValue.Value.Day, "#B03");\r
+ Assert.AreEqual (23, SqlDateTime.MaxValue.Value.Hour, "#B04");\r
+ Assert.AreEqual (59, SqlDateTime.MaxValue.Value.Minute, "#B05");\r
+ Assert.AreEqual (59, SqlDateTime.MaxValue.Value.Second, "#B06");\r
\r
// MinValue\r
- AssertEquals ("#B07", 1753, SqlDateTime.MinValue.Value.Year);\r
- AssertEquals ("#B08", 1, SqlDateTime.MinValue.Value.Month);\r
- AssertEquals ("#B09", 1, SqlDateTime.MinValue.Value.Day);\r
- AssertEquals ("#B10", 0, SqlDateTime.MinValue.Value.Hour);\r
- AssertEquals ("#B11", 0, SqlDateTime.MinValue.Value.Minute);\r
- AssertEquals ("#B12", 0, SqlDateTime.MinValue.Value.Second);\r
+ Assert.AreEqual (1753, SqlDateTime.MinValue.Value.Year, "#B07");\r
+ Assert.AreEqual (1, SqlDateTime.MinValue.Value.Month, "#B08");\r
+ Assert.AreEqual (1, SqlDateTime.MinValue.Value.Day, "#B09");\r
+ Assert.AreEqual (0, SqlDateTime.MinValue.Value.Hour, "#B10");\r
+ Assert.AreEqual (0, SqlDateTime.MinValue.Value.Minute, "#B11");\r
+ Assert.AreEqual (0, SqlDateTime.MinValue.Value.Second, "#B12");\r
\r
// Null\r
- Assert ("#B13", SqlDateTime.Null.IsNull);\r
+ Assert.IsTrue (SqlDateTime.Null.IsNull, "#B13");\r
\r
// SQLTicksPerHour\r
- AssertEquals ("#B14", 1080000, SqlDateTime.SQLTicksPerHour);\r
+ Assert.AreEqual (1080000, SqlDateTime.SQLTicksPerHour, "#B14");\r
\r
// SQLTicksPerMinute\r
- AssertEquals ("#B15", 18000, SqlDateTime.SQLTicksPerMinute);\r
+ Assert.AreEqual (18000, SqlDateTime.SQLTicksPerMinute, "#B15");\r
\r
// SQLTicksPerSecond\r
- AssertEquals ("#B16", 300, SqlDateTime.SQLTicksPerSecond);\r
+ Assert.AreEqual (300, SqlDateTime.SQLTicksPerSecond, "#B16");\r
}\r
\r
// Test properties\r
public void Properties()\r
{\r
// DayTicks\r
- AssertEquals ("#C01", 37546, Test1.DayTicks);\r
+ Assert.AreEqual (37546, Test1.DayTicks, "#C01");\r
\r
try {\r
int test = SqlDateTime.Null.DayTicks;\r
- Fail ("#C02");\r
+ Assert.Fail ("#C02");\r
} catch (Exception e) {\r
- AssertEquals ("#C03", typeof (SqlNullValueException), \r
- e.GetType ());\r
+ Assert.AreEqual (typeof (SqlNullValueException), e.GetType (), "#C03");\r
}\r
\r
// IsNull\r
- Assert ("#C04", SqlDateTime.Null.IsNull);\r
- Assert ("#C05", !Test2.IsNull);\r
+ Assert.IsTrue (SqlDateTime.Null.IsNull, "#C04");\r
+ Assert.IsTrue (!Test2.IsNull, "#C05");\r
\r
// TimeTicks\r
- AssertEquals ("#C06", 10440000, Test1.TimeTicks);\r
+ Assert.AreEqual (10440000, Test1.TimeTicks, "#C06");\r
\r
try {\r
int test = SqlDateTime.Null.TimeTicks;\r
- Fail ("#C07");\r
+ Assert.Fail ("#C07");\r
} catch (Exception e) {\r
- AssertEquals ("#C08", typeof (SqlNullValueException), \r
- e.GetType ());\r
+ Assert.AreEqual (typeof (SqlNullValueException), e.GetType (), "#C08");\r
}\r
\r
// Value\r
- AssertEquals ("#C09", 2003, Test2.Value.Year);\r
- AssertEquals ("#C10", 2002, Test1.Value.Year); \r
+ Assert.AreEqual (2003, Test2.Value.Year, "#C09");\r
+ Assert.AreEqual (2002, Test1.Value.Year, "#C10");\r
}\r
\r
// PUBLIC METHODS\r
{\r
SqlString TestString = new SqlString ("This is a test");\r
\r
- Assert ("#D01", Test1.CompareTo (Test3) < 0);\r
- Assert ("#D02", Test2.CompareTo (Test1) > 0);\r
- Assert ("#D03", Test2.CompareTo (Test3) == 0);\r
- Assert ("#D04", Test1.CompareTo (SqlDateTime.Null) > 0);\r
+ Assert.IsTrue (Test1.CompareTo (Test3) < 0, "#D01");\r
+ Assert.IsTrue (Test2.CompareTo (Test1) > 0, "#D02");\r
+ Assert.IsTrue (Test2.CompareTo (Test3) == 0, "#D03");\r
+ Assert.IsTrue (Test1.CompareTo (SqlDateTime.Null) > 0, "#D04");\r
\r
try {\r
Test1.CompareTo (TestString);\r
- Fail("#D05");\r
+ Assert.Fail("#D05");\r
} catch(Exception e) {\r
- AssertEquals ("#D06", typeof (ArgumentException), e.GetType ());\r
+ Assert.AreEqual (typeof (ArgumentException), e.GetType (), "#D06");\r
}\r
}\r
\r
[Test]\r
public void EqualsMethods()\r
{\r
- Assert ("#E01", !Test1.Equals (Test2));\r
- Assert ("#E03", !Test2.Equals (new SqlString ("TEST")));\r
- Assert ("#E04", Test2.Equals (Test3));\r
+ Assert.IsTrue (!Test1.Equals (Test2), "#E01");\r
+ Assert.IsTrue (!Test2.Equals (new SqlString ("TEST")), "#E03");\r
+ Assert.IsTrue (Test2.Equals (Test3), "#E04");\r
\r
// Static Equals()-method\r
- Assert ("#E05", SqlDateTime.Equals (Test2, Test3).Value);\r
- Assert ("#E06", !SqlDateTime.Equals (Test1, Test2).Value);\r
+ Assert.IsTrue (SqlDateTime.Equals (Test2, Test3).Value, "#E05");\r
+ Assert.IsTrue (!SqlDateTime.Equals (Test1, Test2).Value, "#E06");\r
}\r
\r
[Test]\r
public void GetHashCodeTest()\r
{\r
// FIXME: Better way to test HashCode\r
- AssertEquals ("#F01", Test1.GetHashCode (), Test1.GetHashCode ());\r
- Assert ("#F02", Test2.GetHashCode () != Test1.GetHashCode ());\r
+ Assert.AreEqual (Test1.GetHashCode (), Test1.GetHashCode (), "#F01");\r
+ Assert.IsTrue (Test2.GetHashCode () != Test1.GetHashCode (), "#F02");\r
}\r
\r
[Test]\r
public void GetTypeTest()\r
{\r
- AssertEquals ("#G01", "System.Data.SqlTypes.SqlDateTime", \r
- Test1.GetType ().ToString ());\r
- AssertEquals ("#G02", "System.DateTime", \r
- Test1.Value.GetType ().ToString ());\r
+ Assert.AreEqual ("System.Data.SqlTypes.SqlDateTime", Test1.GetType ().ToString (), "#G01");\r
+ Assert.AreEqual ("System.DateTime", Test1.Value.GetType ().ToString (), "#G02");\r
}\r
\r
[Test]\r
public void Greaters()\r
{\r
// GreateThan ()\r
- Assert ("#H01", !SqlDateTime.GreaterThan (Test1, Test2).Value);\r
- Assert ("#H02", SqlDateTime.GreaterThan (Test2, Test1).Value);\r
- Assert ("#H03", !SqlDateTime.GreaterThan (Test2, Test3).Value);\r
+ Assert.IsTrue (!SqlDateTime.GreaterThan (Test1, Test2).Value, "#H01");\r
+ Assert.IsTrue (SqlDateTime.GreaterThan (Test2, Test1).Value, "#H02");\r
+ Assert.IsTrue (!SqlDateTime.GreaterThan (Test2, Test3).Value, "#H03");\r
\r
// GreaterTharOrEqual ()\r
- Assert ("#H04", !SqlDateTime.GreaterThanOrEqual (Test1, Test2).Value);\r
- Assert ("#H05", SqlDateTime.GreaterThanOrEqual (Test2, Test1).Value);\r
- Assert ("#H06", SqlDateTime.GreaterThanOrEqual (Test2, Test3).Value);\r
+ Assert.IsTrue (!SqlDateTime.GreaterThanOrEqual (Test1, Test2).Value, "#H04");\r
+ Assert.IsTrue (SqlDateTime.GreaterThanOrEqual (Test2, Test1).Value, "#H05");\r
+ Assert.IsTrue (SqlDateTime.GreaterThanOrEqual (Test2, Test3).Value, "#H06");\r
}\r
\r
[Test]\r
public void Lessers()\r
{\r
// LessThan()\r
- Assert ("#I01", !SqlDateTime.LessThan (Test2, Test3).Value);\r
- Assert ("#I02", !SqlDateTime.LessThan (Test2, Test1).Value);\r
- Assert ("#I03", SqlDateTime.LessThan (Test1, Test3).Value);\r
+ Assert.IsTrue (!SqlDateTime.LessThan (Test2, Test3).Value, "#I01");\r
+ Assert.IsTrue (!SqlDateTime.LessThan (Test2, Test1).Value, "#I02");\r
+ Assert.IsTrue (SqlDateTime.LessThan (Test1, Test3).Value, "#I03");\r
\r
// LessThanOrEqual ()\r
- Assert ("#I04", SqlDateTime.LessThanOrEqual (Test1, Test2).Value);\r
- Assert ("#I05", !SqlDateTime.LessThanOrEqual (Test2, Test1).Value);\r
- Assert ("#I06", SqlDateTime.LessThanOrEqual (Test3, Test2).Value);\r
- Assert ("#I07", SqlDateTime.LessThanOrEqual (Test1, SqlDateTime.Null).IsNull);\r
+ Assert.IsTrue (SqlDateTime.LessThanOrEqual (Test1, Test2).Value, "#I04");\r
+ Assert.IsTrue (!SqlDateTime.LessThanOrEqual (Test2, Test1).Value, "#I05");\r
+ Assert.IsTrue (SqlDateTime.LessThanOrEqual (Test3, Test2).Value, "#I06");\r
+ Assert.IsTrue (SqlDateTime.LessThanOrEqual (Test1, SqlDateTime.Null).IsNull, "#I07");\r
}\r
\r
[Test]\r
public void NotEquals()\r
{\r
- Assert ("#J01", SqlDateTime.NotEquals (Test1, Test2).Value);\r
- Assert ("#J02", SqlDateTime.NotEquals (Test3, Test1).Value);\r
- Assert ("#J03", !SqlDateTime.NotEquals (Test2, Test3).Value);\r
- Assert ("#J04", SqlDateTime.NotEquals (SqlDateTime.Null, Test2).IsNull);\r
+ Assert.IsTrue (SqlDateTime.NotEquals (Test1, Test2).Value, "#J01");\r
+ Assert.IsTrue (SqlDateTime.NotEquals (Test3, Test1).Value, "#J02");\r
+ Assert.IsTrue (!SqlDateTime.NotEquals (Test2, Test3).Value, "#J03");\r
+ Assert.IsTrue (SqlDateTime.NotEquals (SqlDateTime.Null, Test2).IsNull, "#J04");\r
}\r
\r
[Test]\r
{\r
try {\r
SqlDateTime.Parse (null);\r
- Fail ("#K01");\r
+ Assert.Fail ("#K01");\r
} catch (Exception e) {\r
- AssertEquals ("#K02", typeof (ArgumentNullException), \r
- e.GetType ());\r
+ Assert.AreEqual (typeof (ArgumentNullException), e.GetType (), "#K02");\r
}\r
\r
try {\r
SqlDateTime.Parse ("not-a-number");\r
- Fail ("#K03");\r
+ Assert.Fail ("#K03");\r
} catch (Exception e) {\r
- AssertEquals ("#K04", typeof (FormatException), \r
- e.GetType ());\r
+ Assert.AreEqual (typeof (FormatException), e.GetType (), "#K04");\r
}\r
\r
SqlDateTime t1 = SqlDateTime.Parse ("02/25/2002");\r
- AssertEquals ("#K05", myTicks[0], t1.Value.Ticks);\r
+ Assert.AreEqual (myTicks[0], t1.Value.Ticks, "#K05");\r
\r
try {\r
t1 = SqlDateTime.Parse ("2002-02-25");\r
} catch (Exception e) {\r
- Fail ("#K06 " + e);\r
+ Assert.Fail ("#K06 " + e);\r
}\r
\r
// Thanks for Martin Baulig for these (DateTimeTest.cs)\r
- AssertEquals ("#K07", myTicks[0], t1.Value.Ticks);\r
+ Assert.AreEqual (myTicks[0], t1.Value.Ticks, "#K07");\r
t1 = SqlDateTime.Parse ("Monday, 25 February 2002");\r
- AssertEquals ("#K08", myTicks[0], t1.Value.Ticks);\r
+ Assert.AreEqual (myTicks[0], t1.Value.Ticks, "#K08");\r
t1 = SqlDateTime.Parse ("Monday, 25 February 2002 05:25");\r
- AssertEquals ("#K09", myTicks[3], t1.Value.Ticks);\r
+ Assert.AreEqual (myTicks[3], t1.Value.Ticks, "#K09");\r
t1 = SqlDateTime.Parse ("Monday, 25 February 2002 05:25:13");\r
- AssertEquals ("#K10", myTicks[4], t1.Value.Ticks);\r
+ Assert.AreEqual (myTicks[4], t1.Value.Ticks, "#K10");\r
t1 = SqlDateTime.Parse ("02/25/2002 05:25");\r
- AssertEquals ("#K11", myTicks[3], t1.Value.Ticks);\r
+ Assert.AreEqual (myTicks[3], t1.Value.Ticks, "#K11");\r
t1 = SqlDateTime.Parse ("02/25/2002 05:25:13");\r
- AssertEquals ("#K12", myTicks[4], t1.Value.Ticks);\r
+ Assert.AreEqual (myTicks[4], t1.Value.Ticks, "#K12");\r
t1 = SqlDateTime.Parse ("2002-02-25 04:25:13Z");\r
t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1.Value);\r
- AssertEquals ("#K13", 2002, t1.Value.Year);\r
- AssertEquals ("#K14", 02, t1.Value.Month);\r
- AssertEquals ("#K15", 25, t1.Value.Day);\r
- AssertEquals ("#K16", 04, t1.Value.Hour);\r
- AssertEquals ("#K17", 25, t1.Value.Minute);\r
- AssertEquals ("#K18", 13, t1.Value.Second);\r
+ Assert.AreEqual (2002, t1.Value.Year, "#K13");\r
+ Assert.AreEqual (02, t1.Value.Month, "#K14");\r
+ Assert.AreEqual (25, t1.Value.Day, "#K15");\r
+ Assert.AreEqual (04, t1.Value.Hour, "#K16");\r
+ Assert.AreEqual (25, t1.Value.Minute, "#K17");\r
+ Assert.AreEqual (13, t1.Value.Second, "#K18");\r
\r
SqlDateTime t2 = new SqlDateTime (DateTime.Today.Year, 2, 25);\r
t1 = SqlDateTime.Parse ("February 25");\r
- AssertEquals ("#K19", t2.Value.Ticks, t1.Value.Ticks);\r
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#K19");\r
\r
t2 = new SqlDateTime (DateTime.Today.Year, 2, 8);\r
t1 = SqlDateTime.Parse ("February 08");\r
- AssertEquals ("#K20", t2.Value.Ticks, t1.Value.Ticks);\r
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#K20");\r
\r
t1 = SqlDateTime.Parse ("Mon, 25 Feb 2002 04:25:13 GMT");\r
t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1.Value);\r
- AssertEquals ("#K21", 2002, t1.Value.Year);\r
- AssertEquals ("#K22", 02, t1.Value.Month);\r
- AssertEquals ("#K23", 25, t1.Value.Day);\r
- AssertEquals ("#K24", 04, t1.Value.Hour);\r
- AssertEquals ("#K25", 25, t1.Value.Minute);\r
- AssertEquals ("#K26", 13, t1.Value.Second);\r
+ Assert.AreEqual (2002, t1.Value.Year, "#K21");\r
+ Assert.AreEqual (02, t1.Value.Month, "#K22");\r
+ Assert.AreEqual (25, t1.Value.Day, "#K23");\r
+ Assert.AreEqual (04, t1.Value.Hour, "#K24");\r
+ Assert.AreEqual (25, t1.Value.Minute, "#K25");\r
+ Assert.AreEqual (13, t1.Value.Second, "#K26");\r
\r
t1 = SqlDateTime.Parse ("2002-02-25T05:25:13");\r
- AssertEquals ("#K27", myTicks[4], t1.Value.Ticks);\r
+ Assert.AreEqual (myTicks[4], t1.Value.Ticks, "#K27");\r
\r
t2 = DateTime.Today + new TimeSpan (5,25,0);\r
t1 = SqlDateTime.Parse ("05:25");\r
- AssertEquals("#K28", t2.Value.Ticks, t1.Value.Ticks);\r
+ Assert.AreEqual(t2.Value.Ticks, t1.Value.Ticks, "#K28");\r
\r
t2 = DateTime.Today + new TimeSpan (5,25,13);\r
t1 = SqlDateTime.Parse ("05:25:13");\r
- AssertEquals("#K29", t2.Value.Ticks, t1.Value.Ticks);\r
+ Assert.AreEqual(t2.Value.Ticks, t1.Value.Ticks, "#K29");\r
\r
t2 = new SqlDateTime (2002, 2, 1);\r
t1 = SqlDateTime.Parse ("2002 February");\r
- AssertEquals ("#K30", t2.Value.Ticks, t1.Value.Ticks);\r
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#K30");\r
\r
t2 = new SqlDateTime (2002, 2, 1);\r
t1 = SqlDateTime.Parse ("2002 February");\r
- AssertEquals ("#K31", t2.Value.Ticks, t1.Value.Ticks);\r
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#K31");\r
\r
t2 = new SqlDateTime (DateTime.Today.Year, 2, 8);\r
t1 = SqlDateTime.Parse ("February 8");\r
\r
- AssertEquals ("#K32", t2.Value.Ticks, t1.Value.Ticks);\r
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#K32");\r
}\r
\r
[Test]\r
SqlDateTime t2 = new SqlDateTime (2002, 2, 25, 15, 25, 13);\r
\r
// Standard patterns\r
- AssertEquals("L01", "2/25/2002 5:25:13 AM", t1.ToString ());\r
- AssertEquals("L02", (SqlString)"2/25/2002 5:25:13 AM", t1.ToSqlString ());\r
+ Assert.AreEqual("2/25/2002 5:25:13 AM", t1.ToString (), "L01");\r
+ Assert.AreEqual((SqlString)"2/25/2002 5:25:13 AM", t1.ToSqlString (), "L02");\r
}\r
\r
// OPERATORS\r
\r
// "+"-operator\r
ResultDateTime = Test1 + TestSpan;\r
- AssertEquals ("#M01", 2002, ResultDateTime.Value.Year);\r
- AssertEquals ("#M02", 8, ResultDateTime.Value.Day);\r
- AssertEquals ("#M03", 11, ResultDateTime.Value.Hour);\r
- AssertEquals ("#M04", 0, ResultDateTime.Value.Minute);\r
- AssertEquals ("#M05", 20, ResultDateTime.Value.Second); \r
- Assert ("#M06", (SqlDateTime.Null + TestSpan).IsNull);\r
+ Assert.AreEqual (2002, ResultDateTime.Value.Year, "#M01");\r
+ Assert.AreEqual (8, ResultDateTime.Value.Day, "#M02");\r
+ Assert.AreEqual (11, ResultDateTime.Value.Hour, "#M03");\r
+ Assert.AreEqual (0, ResultDateTime.Value.Minute, "#M04");\r
+ Assert.AreEqual (20, ResultDateTime.Value.Second, "#M05");\r
+ Assert.IsTrue ((SqlDateTime.Null + TestSpan).IsNull, "#M06");\r
\r
try {\r
ResultDateTime = SqlDateTime.MaxValue + TestSpan;\r
- Fail ("#M07");\r
+ Assert.Fail ("#M07");\r
} catch (Exception e) {\r
- AssertEquals ("#M08", typeof (ArgumentOutOfRangeException), e.GetType ());\r
+ Assert.AreEqual (typeof (ArgumentOutOfRangeException), e.GetType (), "#M08");\r
}\r
\r
// "-"-operator\r
ResultDateTime = Test1 - TestSpan;\r
- AssertEquals ("#M09", 2002, ResultDateTime.Value.Year);\r
- AssertEquals ("#M10", 29, ResultDateTime.Value.Day);\r
- AssertEquals ("#M11", 8, ResultDateTime.Value.Hour);\r
- AssertEquals ("#M12", 19, ResultDateTime.Value.Minute);\r
- AssertEquals ("#M13", 40, ResultDateTime.Value.Second); \r
- Assert ("#M14", (SqlDateTime.Null - TestSpan).IsNull);\r
+ Assert.AreEqual (2002, ResultDateTime.Value.Year, "#M09");\r
+ Assert.AreEqual (29, ResultDateTime.Value.Day, "#M10");\r
+ Assert.AreEqual (8, ResultDateTime.Value.Hour, "#M11");\r
+ Assert.AreEqual (19, ResultDateTime.Value.Minute, "#M12");\r
+ Assert.AreEqual (40, ResultDateTime.Value.Second, "#M13");\r
+ Assert.IsTrue ((SqlDateTime.Null - TestSpan).IsNull, "#M14");\r
\r
try {\r
ResultDateTime = SqlDateTime.MinValue - TestSpan;\r
- Fail ("#M15");\r
+ Assert.Fail ("#M15");\r
} catch (Exception e) {\r
- AssertEquals ("#M16", typeof (SqlTypeException), e.GetType ());\r
+ Assert.AreEqual (typeof (SqlTypeException), e.GetType (), "#M16");\r
}\r
}\r
\r
public void ThanOrEqualOperators()\r
{\r
// == -operator\r
- Assert ("#N01", (Test2 == Test3).Value);\r
- Assert ("#N02", !(Test1 == Test2).Value);\r
- Assert ("#N03", (Test1 == SqlDateTime.Null).IsNull);\r
+ Assert.IsTrue ((Test2 == Test3).Value, "#N01");\r
+ Assert.IsTrue (!(Test1 == Test2).Value, "#N02");\r
+ Assert.IsTrue ((Test1 == SqlDateTime.Null).IsNull, "#N03");\r
\r
// != -operator\r
- Assert ("#N04", !(Test2 != Test3).Value);\r
- Assert ("#N05", (Test1 != Test3).Value);\r
- Assert ("#N06", (Test1 != SqlDateTime.Null).IsNull);\r
+ Assert.IsTrue (!(Test2 != Test3).Value, "#N04");\r
+ Assert.IsTrue ((Test1 != Test3).Value, "#N05");\r
+ Assert.IsTrue ((Test1 != SqlDateTime.Null).IsNull, "#N06");\r
\r
// > -operator\r
- Assert ("#N07", (Test2 > Test1).Value);\r
- Assert ("#N08", !(Test3 > Test2).Value);\r
- Assert ("#N09", (Test1 > SqlDateTime.Null).IsNull);\r
+ Assert.IsTrue ((Test2 > Test1).Value, "#N07");\r
+ Assert.IsTrue (!(Test3 > Test2).Value, "#N08");\r
+ Assert.IsTrue ((Test1 > SqlDateTime.Null).IsNull, "#N09");\r
\r
// >= -operator\r
- Assert ("#N10", !(Test1 >= Test3).Value);\r
- Assert ("#N11", (Test3 >= Test1).Value);\r
- Assert ("#N12", (Test2 >= Test3).Value);\r
- Assert ("#N13", (Test1 >= SqlDateTime.Null).IsNull);\r
+ Assert.IsTrue (!(Test1 >= Test3).Value, "#N10");\r
+ Assert.IsTrue ((Test3 >= Test1).Value, "#N11");\r
+ Assert.IsTrue ((Test2 >= Test3).Value, "#N12");\r
+ Assert.IsTrue ((Test1 >= SqlDateTime.Null).IsNull, "#N13");\r
\r
// < -operator\r
- Assert ("#N14", !(Test2 < Test1).Value);\r
- Assert ("#N15", (Test1 < Test3).Value);\r
- Assert ("#N16", !(Test2 < Test3).Value);\r
- Assert ("#N17", (Test1 < SqlDateTime.Null).IsNull);\r
+ Assert.IsTrue (!(Test2 < Test1).Value, "#N14");\r
+ Assert.IsTrue ((Test1 < Test3).Value, "#N15");\r
+ Assert.IsTrue (!(Test2 < Test3).Value, "#N16");\r
+ Assert.IsTrue ((Test1 < SqlDateTime.Null).IsNull, "#N17");\r
\r
// <= -operator\r
- Assert ("#N18", (Test1 <= Test3).Value);\r
- Assert ("#N19", !(Test3 <= Test1).Value);\r
- Assert ("#N20", (Test2 <= Test3).Value);\r
- Assert ("#N21", (Test1 <= SqlDateTime.Null).IsNull);\r
+ Assert.IsTrue ((Test1 <= Test3).Value, "#N18");\r
+ Assert.IsTrue (!(Test3 <= Test1).Value, "#N19");\r
+ Assert.IsTrue ((Test2 <= Test3).Value, "#N20");\r
+ Assert.IsTrue ((Test1 <= SqlDateTime.Null).IsNull, "#N21");\r
}\r
\r
[Test]\r
public void SqlDateTimeToDateTime()\r
{\r
- AssertEquals ("O01", 2002, ((DateTime)Test1).Year);\r
- AssertEquals ("O03", 2003, ((DateTime)Test2).Year);\r
- AssertEquals ("O04", 10, ((DateTime)Test1).Month);\r
- AssertEquals ("O05", 19, ((DateTime)Test1).Day);\r
- AssertEquals ("O06", 9, ((DateTime)Test1).Hour);\r
- AssertEquals ("O07", 40, ((DateTime)Test1).Minute);\r
- AssertEquals ("O08", 0, ((DateTime)Test1).Second);\r
+ Assert.AreEqual (2002, ((DateTime)Test1).Year, "O01");\r
+ Assert.AreEqual (2003, ((DateTime)Test2).Year, "O03");\r
+ Assert.AreEqual (10, ((DateTime)Test1).Month, "O04");\r
+ Assert.AreEqual (19, ((DateTime)Test1).Day, "O05");\r
+ Assert.AreEqual (9, ((DateTime)Test1).Hour, "O06");\r
+ Assert.AreEqual (40, ((DateTime)Test1).Minute, "O07");\r
+ Assert.AreEqual (0, ((DateTime)Test1).Second, "O08");\r
}\r
\r
[Test]\r
SqlString TestString = new SqlString ("02/25/2002");\r
SqlDateTime t1 = (SqlDateTime)TestString;\r
\r
- AssertEquals ("#P01", myTicks[0], t1.Value.Ticks);\r
+ Assert.AreEqual (myTicks[0], t1.Value.Ticks, "#P01");\r
\r
// Thanks for Martin Baulig for these (DateTimeTest.cs)\r
- AssertEquals ("#P02", myTicks[0], t1.Value.Ticks);\r
+ Assert.AreEqual (myTicks[0], t1.Value.Ticks, "#P02");\r
t1 = (SqlDateTime) new SqlString ("Monday, 25 February 2002");\r
- AssertEquals ("#P04", myTicks[0], t1.Value.Ticks);\r
+ Assert.AreEqual (myTicks[0], t1.Value.Ticks, "#P04");\r
t1 = (SqlDateTime) new SqlString ("Monday, 25 February 2002 05:25");\r
- AssertEquals ("#P05", myTicks[3], t1.Value.Ticks);\r
+ Assert.AreEqual (myTicks[3], t1.Value.Ticks, "#P05");\r
t1 = (SqlDateTime) new SqlString ("Monday, 25 February 2002 05:25:13");\r
- AssertEquals ("#P05", myTicks[4], t1.Value.Ticks);\r
+ Assert.AreEqual (myTicks[4], t1.Value.Ticks, "#P05");\r
t1 = (SqlDateTime) new SqlString ("02/25/2002 05:25");\r
- AssertEquals ("#P06", myTicks[3], t1.Value.Ticks);\r
+ Assert.AreEqual (myTicks[3], t1.Value.Ticks, "#P06");\r
t1 = (SqlDateTime) new SqlString ("02/25/2002 05:25:13");\r
- AssertEquals ("#P07", myTicks[4], t1.Value.Ticks);\r
+ Assert.AreEqual (myTicks[4], t1.Value.Ticks, "#P07");\r
t1 = (SqlDateTime) new SqlString ("2002-02-25 04:25:13Z");\r
t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1.Value);\r
- AssertEquals ("#P08", 2002, t1.Value.Year);\r
- AssertEquals ("#P09", 02, t1.Value.Month);\r
- AssertEquals ("#P10", 25, t1.Value.Day);\r
- AssertEquals ("#P11", 04, t1.Value.Hour);\r
- AssertEquals ("#P12", 25, t1.Value.Minute);\r
- AssertEquals ("#P13", 13, t1.Value.Second);\r
+ Assert.AreEqual (2002, t1.Value.Year, "#P08");\r
+ Assert.AreEqual (02, t1.Value.Month, "#P09");\r
+ Assert.AreEqual (25, t1.Value.Day, "#P10");\r
+ Assert.AreEqual (04, t1.Value.Hour, "#P11");\r
+ Assert.AreEqual (25, t1.Value.Minute, "#P12");\r
+ Assert.AreEqual (13, t1.Value.Second, "#P13");\r
\r
SqlDateTime t2 = new SqlDateTime (DateTime.Today.Year, 2, 25);\r
t1 = (SqlDateTime) new SqlString ("February 25");\r
- AssertEquals ("#P14", t2.Value.Ticks, t1.Value.Ticks);\r
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#P14");\r
\r
t2 = new SqlDateTime (DateTime.Today.Year, 2, 8);\r
t1 = (SqlDateTime) new SqlString ("February 08");\r
- AssertEquals ("#P15", t2.Value.Ticks, t1.Value.Ticks);\r
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#P15");\r
\r
t1 = (SqlDateTime) new SqlString ("Mon, 25 Feb 2002 04:25:13 GMT");\r
t1 = TimeZone.CurrentTimeZone.ToUniversalTime(t1.Value);\r
- AssertEquals ("#P16", 2002, t1.Value.Year);\r
- AssertEquals ("#P17", 02, t1.Value.Month);\r
- AssertEquals ("#P18", 25, t1.Value.Day);\r
- AssertEquals ("#P19", 04, t1.Value.Hour);\r
- AssertEquals ("#P20", 25, t1.Value.Minute);\r
- AssertEquals ("#P21", 13, t1.Value.Second);\r
+ Assert.AreEqual (2002, t1.Value.Year, "#P16");\r
+ Assert.AreEqual (02, t1.Value.Month, "#P17");\r
+ Assert.AreEqual (25, t1.Value.Day, "#P18");\r
+ Assert.AreEqual (04, t1.Value.Hour, "#P19");\r
+ Assert.AreEqual (25, t1.Value.Minute, "#P20");\r
+ Assert.AreEqual (13, t1.Value.Second, "#P21");\r
\r
t1 = (SqlDateTime) new SqlString ("2002-02-25T05:25:13");\r
- AssertEquals ("#P22", myTicks[4], t1.Value.Ticks);\r
+ Assert.AreEqual (myTicks[4], t1.Value.Ticks, "#P22");\r
\r
t2 = DateTime.Today + new TimeSpan (5,25,0);\r
t1 = (SqlDateTime) new SqlString ("05:25");\r
- AssertEquals("#P23", t2.Value.Ticks, t1.Value.Ticks);\r
+ Assert.AreEqual(t2.Value.Ticks, t1.Value.Ticks, "#P23");\r
\r
t2 = DateTime.Today + new TimeSpan (5,25,13);\r
t1 = (SqlDateTime) new SqlString ("05:25:13");\r
- AssertEquals("#P24", t2.Value.Ticks, t1.Value.Ticks);\r
+ Assert.AreEqual(t2.Value.Ticks, t1.Value.Ticks, "#P24");\r
\r
t2 = new SqlDateTime (2002, 2, 1);\r
t1 = (SqlDateTime) new SqlString ("2002 February");\r
- AssertEquals ("#P25", t2.Value.Ticks, t1.Value.Ticks);\r
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#P25");\r
\r
t2 = new SqlDateTime (2002, 2, 1);\r
t1 = (SqlDateTime) new SqlString ("2002 February");\r
- AssertEquals ("#P26", t2.Value.Ticks, t1.Value.Ticks);\r
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#P26");\r
\r
t2 = new SqlDateTime (DateTime.Today.Year, 2, 8);\r
t1 = (SqlDateTime) new SqlString ("February 8");\r
\r
- AssertEquals ("#P27", t2.Value.Ticks, t1.Value.Ticks);\r
+ Assert.AreEqual (t2.Value.Ticks, t1.Value.Ticks, "#P27");\r
}\r
\r
[Test]\r
{\r
DateTime DateTimeTest = new DateTime (2002, 10, 19, 11, 53, 4);\r
SqlDateTime Result = (SqlDateTime)DateTimeTest;\r
- AssertEquals ("#Q01", 2002, Result.Value.Year);\r
- AssertEquals ("#Q02", 10, Result.Value.Month);\r
- AssertEquals ("#Q03", 19, Result.Value.Day);\r
- AssertEquals ("#Q04", 11, Result.Value.Hour);\r
- AssertEquals ("#Q05", 53, Result.Value.Minute);\r
- AssertEquals ("#Q06", 4, Result.Value.Second);\r
+ Assert.AreEqual (2002, Result.Value.Year, "#Q01");\r
+ Assert.AreEqual (10, Result.Value.Month, "#Q02");\r
+ Assert.AreEqual (19, Result.Value.Day, "#Q03");\r
+ Assert.AreEqual (11, Result.Value.Hour, "#Q04");\r
+ Assert.AreEqual (53, Result.Value.Minute, "#Q05");\r
+ Assert.AreEqual (4, Result.Value.Second, "#Q06");\r
}\r
\r
[Test]\r
SqlDateTime d1 = new SqlDateTime (2007, 05, 04, 18, 02, 40, 398.25);\r
SqlDateTime d2 = new SqlDateTime (d1.DayTicks, d1.TimeTicks);\r
\r
- AssertEquals ("#R01", 39204, d1.DayTicks);\r
- AssertEquals ("#R02", 19488119, d1.TimeTicks);\r
- AssertEquals ("#R03", 633138985603970000, d1.Value.Ticks);\r
- AssertEquals ("#R04", d1.DayTicks, d2.DayTicks);\r
- AssertEquals ("#R05", d1.TimeTicks, d2.TimeTicks);\r
- AssertEquals ("#R06", d1.Value.Ticks, d2.Value.Ticks);\r
- AssertEquals ("#R07", d1, d2);\r
+ Assert.AreEqual (39204, d1.DayTicks, "#R01");\r
+ Assert.AreEqual (19488119, d1.TimeTicks, "#R02");\r
+ Assert.AreEqual (633138985603970000, d1.Value.Ticks, "#R03");\r
+ Assert.AreEqual (d1.DayTicks, d2.DayTicks, "#R04");\r
+ Assert.AreEqual (d1.TimeTicks, d2.TimeTicks, "#R05");\r
+ Assert.AreEqual (d1.Value.Ticks, d2.Value.Ticks, "#R06");\r
+ Assert.AreEqual (d1, d2, "#R07");\r
}\r
\r
[Test]\r
{\r
SqlDateTime d1 = new SqlDateTime (2007, 05, 04, 18, 02, 40, 398252);\r
\r
- AssertEquals ("#S01", 39204, d1.DayTicks);\r
- AssertEquals ("#S02", 19488119, d1.TimeTicks);\r
- AssertEquals ("#R03", 633138985603970000, d1.Value.Ticks);\r
+ Assert.AreEqual (39204, d1.DayTicks, "#S01");\r
+ Assert.AreEqual (19488119, d1.TimeTicks, "#S02");\r
+ Assert.AreEqual (633138985603970000, d1.Value.Ticks, "#R03");\r
}\r
\r
#if NET_2_0\r
namespace MonoTests.System.Data.SqlTypes\r
{\r
[TestFixture]\r
- public class SqlGuidTest : Assertion {\r
+ public class SqlGuidTest {\r
\r
// 00000a01-0000-0000-0000-000000000000\r
private SqlGuid Test1;\r
Test = new SqlGuid (10, 1, 2, 13, 14, 15, 16, 17, 19, 20 ,21);\r
\r
} catch (Exception e) {\r
- Fail ("#A01 " + e);\r
+ Assert.Fail ("#A01 " + e);\r
}\r
}\r
\r
[Test]\r
public void PublicFields()\r
{\r
- Assert ("#B01", SqlGuid.Null.IsNull);\r
+ Assert.IsTrue (SqlGuid.Null.IsNull, "#B01");\r
}\r
\r
// Test properties\r
public void Properties()\r
{\r
Guid ResultGuid = new Guid ("00000f64-0000-0000-0000-000000000000"); \r
- Assert ("#C01", !Test1.IsNull);\r
- Assert ("#C02", SqlGuid.Null.IsNull);\r
- AssertEquals ("#C03", ResultGuid, Test2.Value);\r
+ Assert.IsTrue (!Test1.IsNull, "#C01");\r
+ Assert.IsTrue (SqlGuid.Null.IsNull, "#C02");\r
+ Assert.AreEqual (ResultGuid, Test2.Value, "#C03");\r
}\r
\r
// PUBLIC METHODS\r
SqlGuid test1 = new SqlGuid("1AAAAAAA-BBBB-CCCC-DDDD-3EEEEEEEEEEE");\r
SqlGuid test2 = new SqlGuid("1AAAAAAA-BBBB-CCCC-DDDD-2EEEEEEEEEEE");\r
SqlGuid test3 = new SqlGuid("1AAAAAAA-BBBB-CCCC-DDDD-1EEEEEEEEEEE");\r
- Assert ("#D01", Test1.CompareTo (Test3) < 0);\r
- Assert ("#D02", Test4.CompareTo (Test1) > 0);\r
- Assert ("#D03", Test3.CompareTo (Test2) == 0);\r
- Assert ("#D04", Test4.CompareTo (SqlGuid.Null) > 0);\r
- Assert ("#D05", test1.CompareTo (test2) > 0);\r
- Assert ("#D06", test3.CompareTo (test2) < 0);\r
+ Assert.IsTrue (Test1.CompareTo (Test3) < 0, "#D01");\r
+ Assert.IsTrue (Test4.CompareTo (Test1) > 0, "#D02");\r
+ Assert.IsTrue (Test3.CompareTo (Test2) == 0, "#D03");\r
+ Assert.IsTrue (Test4.CompareTo (SqlGuid.Null) > 0, "#D04");\r
+ Assert.IsTrue (test1.CompareTo (test2) > 0, "#D05");\r
+ Assert.IsTrue (test3.CompareTo (test2) < 0, "#D06");\r
\r
try {\r
Test1.CompareTo (TestString);\r
- Fail("#D05");\r
+ Assert.Fail("#D05");\r
} catch(Exception e) {\r
- AssertEquals ("#D06", typeof (ArgumentException), e.GetType ());\r
+ Assert.AreEqual (typeof (ArgumentException), e.GetType (), "#D06");\r
}\r
}\r
\r
[Test]\r
public void EqualsMethods()\r
{\r
- Assert ("#E01", !Test1.Equals (Test2));\r
- Assert ("#E02", !Test2.Equals (Test4));\r
- Assert ("#E03", !Test2.Equals (new SqlString ("TEST")));\r
- Assert ("#E04", Test2.Equals (Test3));\r
+ Assert.IsTrue (!Test1.Equals (Test2), "#E01");\r
+ Assert.IsTrue (!Test2.Equals (Test4), "#E02");\r
+ Assert.IsTrue (!Test2.Equals (new SqlString ("TEST")), "#E03");\r
+ Assert.IsTrue (Test2.Equals (Test3), "#E04");\r
\r
// Static Equals()-method\r
- Assert ("#E05", SqlGuid.Equals (Test2, Test3).Value);\r
- Assert ("#E06", !SqlGuid.Equals (Test1, Test2).Value);\r
+ Assert.IsTrue (SqlGuid.Equals (Test2, Test3).Value, "#E05");\r
+ Assert.IsTrue (!SqlGuid.Equals (Test1, Test2).Value, "#E06");\r
}\r
\r
[Test]\r
public void GetHashCodeTest()\r
{\r
- AssertEquals ("#F01", Test1.GetHashCode (), Test1.GetHashCode ());\r
- Assert ("#F02", Test1.GetHashCode () != Test2.GetHashCode ());\r
- AssertEquals ("#F02", Test3.GetHashCode (), Test2.GetHashCode ());\r
+ Assert.AreEqual (Test1.GetHashCode (), Test1.GetHashCode (), "#F01");\r
+ Assert.IsTrue (Test1.GetHashCode () != Test2.GetHashCode (), "#F02");\r
+ Assert.AreEqual (Test3.GetHashCode (), Test2.GetHashCode (), "#F02");\r
}\r
\r
[Test]\r
public void GetTypeTest()\r
{\r
- AssertEquals ("#G01", "System.Data.SqlTypes.SqlGuid", Test1.GetType ().ToString ());\r
- AssertEquals ("#G02", "System.Guid", Test3.Value.GetType ().ToString ());\r
+ Assert.AreEqual ("System.Data.SqlTypes.SqlGuid", Test1.GetType ().ToString (), "#G01");\r
+ Assert.AreEqual ("System.Guid", Test3.Value.GetType ().ToString (), "#G02");\r
}\r
\r
[Test]\r
public void Greaters()\r
{\r
// GreateThan ()\r
- Assert ("#H01", !SqlGuid.GreaterThan (Test1, Test2).Value);\r
- Assert ("#H02", SqlGuid.GreaterThan (Test2, Test1).Value);\r
- Assert ("#H03", !SqlGuid.GreaterThan (Test2, Test3).Value);\r
+ Assert.IsTrue (!SqlGuid.GreaterThan (Test1, Test2).Value, "#H01");\r
+ Assert.IsTrue (SqlGuid.GreaterThan (Test2, Test1).Value, "#H02");\r
+ Assert.IsTrue (!SqlGuid.GreaterThan (Test2, Test3).Value, "#H03");\r
// GreaterTharOrEqual ()\r
- Assert ("#H04", !SqlGuid.GreaterThanOrEqual (Test1, Test2).Value);\r
- Assert ("#H05", SqlGuid.GreaterThanOrEqual (Test2, Test1).Value);\r
- Assert ("#H06", SqlGuid.GreaterThanOrEqual (Test2, Test3).Value);\r
+ Assert.IsTrue (!SqlGuid.GreaterThanOrEqual (Test1, Test2).Value, "#H04");\r
+ Assert.IsTrue (SqlGuid.GreaterThanOrEqual (Test2, Test1).Value, "#H05");\r
+ Assert.IsTrue (SqlGuid.GreaterThanOrEqual (Test2, Test3).Value, "#H06");\r
}\r
\r
[Test]\r
public void Lessers()\r
{\r
// LessThan()\r
- Assert ("#I01", !SqlGuid.LessThan (Test2, Test3).Value);\r
- Assert ("#I02", !SqlGuid.LessThan (Test2, Test1).Value);\r
- Assert ("#I03", SqlGuid.LessThan (Test1, Test2).Value);\r
+ Assert.IsTrue (!SqlGuid.LessThan (Test2, Test3).Value, "#I01");\r
+ Assert.IsTrue (!SqlGuid.LessThan (Test2, Test1).Value, "#I02");\r
+ Assert.IsTrue (SqlGuid.LessThan (Test1, Test2).Value, "#I03");\r
\r
// LessThanOrEqual ()\r
- Assert ("#I04", SqlGuid.LessThanOrEqual (Test1, Test2).Value);\r
- Assert ("#I05", !SqlGuid.LessThanOrEqual (Test2, Test1).Value);\r
- Assert ("#I06", SqlGuid.LessThanOrEqual (Test2, Test3).Value);\r
- Assert ("#I07", SqlGuid.LessThanOrEqual (Test4, SqlGuid.Null).IsNull);\r
+ Assert.IsTrue (SqlGuid.LessThanOrEqual (Test1, Test2).Value, "#I04");\r
+ Assert.IsTrue (!SqlGuid.LessThanOrEqual (Test2, Test1).Value, "#I05");\r
+ Assert.IsTrue (SqlGuid.LessThanOrEqual (Test2, Test3).Value, "#I06");\r
+ Assert.IsTrue (SqlGuid.LessThanOrEqual (Test4, SqlGuid.Null).IsNull, "#I07");\r
}\r
\r
[Test]\r
public void NotEquals()\r
{\r
- Assert ("#J01", SqlGuid.NotEquals (Test1, Test2).Value);\r
- Assert ("#J02", SqlGuid.NotEquals (Test2, Test1).Value);\r
- Assert ("#J03", SqlGuid.NotEquals (Test3, Test1).Value);\r
- Assert ("#J04", !SqlGuid.NotEquals (Test3, Test2).Value); \r
- Assert ("#J05", SqlGuid.NotEquals (SqlGuid.Null, Test2).IsNull);\r
+ Assert.IsTrue (SqlGuid.NotEquals (Test1, Test2).Value, "#J01");\r
+ Assert.IsTrue (SqlGuid.NotEquals (Test2, Test1).Value, "#J02");\r
+ Assert.IsTrue (SqlGuid.NotEquals (Test3, Test1).Value, "#J03");\r
+ Assert.IsTrue (!SqlGuid.NotEquals (Test3, Test2).Value, "#J04");\r
+ Assert.IsTrue (SqlGuid.NotEquals (SqlGuid.Null, Test2).IsNull, "#J05");\r
}\r
\r
[Test]\r
{\r
try {\r
SqlGuid.Parse (null);\r
- Fail ("#K01");\r
+ Assert.Fail ("#K01");\r
} catch (Exception e) {\r
- AssertEquals ("#K02", typeof (ArgumentNullException), e.GetType ());\r
+ Assert.AreEqual (typeof (ArgumentNullException), e.GetType (), "#K02");\r
}\r
\r
try {\r
SqlGuid.Parse ("not-a-number");\r
- Fail ("#K03");\r
+ Assert.Fail ("#K03");\r
} catch (Exception e) {\r
- AssertEquals ("#K04", typeof (FormatException), e.GetType ());\r
+ Assert.AreEqual (typeof (FormatException), e.GetType (), "#K04");\r
}\r
\r
try {\r
SqlGuid.Parse ("9e400");\r
- Fail ("#K05");\r
+ Assert.Fail ("#K05");\r
} catch (Exception e) {\r
- AssertEquals ("#K06", typeof (FormatException), e.GetType ());\r
+ Assert.AreEqual (typeof (FormatException), e.GetType (), "#K06");\r
}\r
\r
- AssertEquals("#K07", new Guid("87654321-0000-0000-0000-000000000000"), \r
- SqlGuid.Parse ("87654321-0000-0000-0000-000000000000").Value);\r
+ Assert.AreEqual(new Guid("87654321-0000-0000-0000-000000000000"), SqlGuid.Parse ("87654321-0000-0000-0000-000000000000").Value, "#K07");\r
}\r
\r
[Test]\r
public void Conversions()\r
{\r
// ToByteArray ()\r
- AssertEquals ("#L01", (byte)1, Test1.ToByteArray () [0]);\r
- AssertEquals ("#L02", (byte)15, Test2.ToByteArray () [1]);\r
+ Assert.AreEqual ((byte)1, Test1.ToByteArray () [0], "#L01");\r
+ Assert.AreEqual ((byte)15, Test2.ToByteArray () [1], "#L02");\r
\r
// ToSqlBinary ()\r
byte [] b = new byte [2]; \r
b [0] = 100;\r
b [1] = 15;\r
\r
- AssertEquals ("#L03", new SqlBinary (b), Test3.ToSqlBinary ());\r
+ Assert.AreEqual (new SqlBinary (b), Test3.ToSqlBinary (), "#L03");\r
\r
// ToSqlString ()\r
- AssertEquals ("#L04", "00000a01-0000-0000-0000-000000000000", \r
- Test1.ToSqlString ().Value);\r
- AssertEquals ("#L05", "0000fafa-0000-0000-0000-000000000000", \r
- Test4.ToSqlString ().Value);\r
+ Assert.AreEqual ("00000a01-0000-0000-0000-000000000000", Test1.ToSqlString ().Value, "#L04");\r
+ Assert.AreEqual ("0000fafa-0000-0000-0000-000000000000", Test4.ToSqlString ().Value, "#L05");\r
\r
// ToString ()\r
- AssertEquals ("#L06", "00000a01-0000-0000-0000-000000000000", \r
- Test1.ToString ());\r
- AssertEquals ("#L07", "0000fafa-0000-0000-0000-000000000000", \r
- Test4.ToString ());\r
+ Assert.AreEqual ("00000a01-0000-0000-0000-000000000000", Test1.ToString (), "#L06");\r
+ Assert.AreEqual ("0000fafa-0000-0000-0000-000000000000", Test4.ToString (), "#L07");\r
}\r
\r
// OPERATORS\r
public void ThanOrEqualOperators()\r
{\r
// == -operator\r
- Assert ("#M01", (Test3 == Test2).Value);\r
- Assert ("#M02", !(Test1 == Test2).Value);\r
- Assert ("#M03", (Test1 == SqlGuid.Null).IsNull);\r
+ Assert.IsTrue ((Test3 == Test2).Value, "#M01");\r
+ Assert.IsTrue (!(Test1 == Test2).Value, "#M02");\r
+ Assert.IsTrue ((Test1 == SqlGuid.Null).IsNull, "#M03");\r
\r
// != -operator\r
- Assert ("#M04", !(Test2 != Test3).Value);\r
- Assert ("#M05", (Test1 != Test3).Value);\r
- Assert ("#M06", (Test1 != SqlGuid.Null).IsNull);\r
+ Assert.IsTrue (!(Test2 != Test3).Value, "#M04");\r
+ Assert.IsTrue ((Test1 != Test3).Value, "#M05");\r
+ Assert.IsTrue ((Test1 != SqlGuid.Null).IsNull, "#M06");\r
\r
// > -operator\r
- Assert ("#M07", (Test2 > Test1).Value);\r
- Assert ("#M08", !(Test1 > Test3).Value);\r
- Assert ("#M09", !(Test3 > Test2).Value);\r
- Assert ("#M10", (Test1 > SqlGuid.Null).IsNull);\r
+ Assert.IsTrue ((Test2 > Test1).Value, "#M07");\r
+ Assert.IsTrue (!(Test1 > Test3).Value, "#M08");\r
+ Assert.IsTrue (!(Test3 > Test2).Value, "#M09");\r
+ Assert.IsTrue ((Test1 > SqlGuid.Null).IsNull, "#M10");\r
\r
// >= -operator\r
- Assert ("#M12", !(Test1 >= Test3).Value);\r
- Assert ("#M13", (Test3 >= Test1).Value);\r
- Assert ("#M14", (Test3 >= Test2).Value);\r
- Assert ("#M15", (Test1 >= SqlGuid.Null).IsNull);\r
+ Assert.IsTrue (!(Test1 >= Test3).Value, "#M12");\r
+ Assert.IsTrue ((Test3 >= Test1).Value, "#M13");\r
+ Assert.IsTrue ((Test3 >= Test2).Value, "#M14");\r
+ Assert.IsTrue ((Test1 >= SqlGuid.Null).IsNull, "#M15");\r
\r
// < -operator\r
- Assert ("#M16", !(Test2 < Test1).Value);\r
- Assert ("#M17", (Test1 < Test3).Value);\r
- Assert ("#M18", !(Test2 < Test3).Value);\r
- Assert ("#M19", (Test1 < SqlGuid.Null).IsNull);\r
+ Assert.IsTrue (!(Test2 < Test1).Value, "#M16");\r
+ Assert.IsTrue ((Test1 < Test3).Value, "#M17");\r
+ Assert.IsTrue (!(Test2 < Test3).Value, "#M18");\r
+ Assert.IsTrue ((Test1 < SqlGuid.Null).IsNull, "#M19");\r
\r
// <= -operator\r
- Assert ("#M20", (Test1 <= Test3).Value);\r
- Assert ("#M21", !(Test3 <= Test1).Value);\r
- Assert ("#M22", (Test2 <= Test3).Value);\r
- Assert ("#M23", (Test1 <= SqlGuid.Null).IsNull);\r
+ Assert.IsTrue ((Test1 <= Test3).Value, "#M20");\r
+ Assert.IsTrue (!(Test3 <= Test1).Value, "#M21");\r
+ Assert.IsTrue ((Test2 <= Test3).Value, "#M22");\r
+ Assert.IsTrue ((Test1 <= SqlGuid.Null).IsNull, "#M23");\r
}\r
\r
[Test]\r
b [1] = 200;\r
SqlBinary TestBinary = new SqlBinary (b);\r
\r
- AssertEquals ("#N01", new Guid("0000c864-0000-0000-0000-000000000000"), \r
- ((SqlGuid)TestBinary).Value);\r
+ Assert.AreEqual (new Guid("0000c864-0000-0000-0000-000000000000"), ((SqlGuid)TestBinary).Value, "#N01");\r
}\r
\r
[Test]\r
public void SqlGuidToGuid()\r
{\r
- AssertEquals ("#O01", new Guid("00000a01-0000-0000-0000-000000000000"), \r
- (Guid)Test1);\r
- AssertEquals ("#O02", new Guid("00000f64-0000-0000-0000-000000000000"), \r
- (Guid)Test2);\r
+ Assert.AreEqual (new Guid("00000a01-0000-0000-0000-000000000000"), (Guid)Test1, "#O01");\r
+ Assert.AreEqual (new Guid("00000f64-0000-0000-0000-000000000000"), (Guid)Test2, "#O02");\r
} \r
\r
[Test]\r
SqlString TestString = new SqlString ("Test string");\r
SqlString TestString100 = new SqlString ("0000c864-0000-0000-0000-000000000000");\r
\r
- AssertEquals ("#P01", new Guid("0000c864-0000-0000-0000-000000000000"), \r
- ((SqlGuid)TestString100).Value);\r
+ Assert.AreEqual (new Guid("0000c864-0000-0000-0000-000000000000"), ((SqlGuid)TestString100).Value, "#P01");\r
\r
try {\r
SqlGuid test = (SqlGuid)TestString;\r
- Fail ("#P02");\r
+ Assert.Fail ("#P02");\r
} catch(Exception e) {\r
- AssertEquals ("#P03", typeof (FormatException), e.GetType ());\r
+ Assert.AreEqual (typeof (FormatException), e.GetType (), "#P03");\r
}\r
}\r
\r
public void GuidToSqlGuid()\r
{\r
Guid TestGuid = new Guid("0000c864-0000-0000-0000-000007650000");\r
- AssertEquals ("#Q01", new SqlGuid("0000c864-0000-0000-0000-000007650000"), \r
- (SqlGuid)TestGuid);\r
+ Assert.AreEqual (new SqlGuid("0000c864-0000-0000-0000-000007650000"), (SqlGuid)TestGuid, "#Q01");\r
}\r
#if NET_2_0\r
[Test]\r
public void GetXsdTypeTest ()\r
{\r
XmlQualifiedName qualifiedName = SqlGuid.GetXsdType (null);\r
- NUnit.Framework.Assert.AreEqual ("string", qualifiedName.Name, "#A01");\r
+ Assert.AreEqual ("string", qualifiedName.Name, "#A01");\r
}\r
#endif\r
}\r
projects / mono.git / commitdiff