From: Rodrigo Moya Date: Tue, 1 Oct 2002 09:18:23 +0000 (-0000) Subject: 2002-10-01 Rodrigo Moya X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=commitdiff_plain;h=3dfe241caa54947ebd453a285621be6d31a32bbf;p=mono.git 2002-10-01 Rodrigo Moya * System.Data.SqlClient/AllTests.cs: added SqlBoolean test. 2002-10-01 ville * System.Data.SqlClient/SqlBooleanTest.cs: new test suite for SqlBoolean class. svn path=/trunk/mcs/; revision=7899 --- diff --git a/mcs/class/System.Data/Test/ChangeLog b/mcs/class/System.Data/Test/ChangeLog index 18eb175b475..2ec23ea8349 100644 --- a/mcs/class/System.Data/Test/ChangeLog +++ b/mcs/class/System.Data/Test/ChangeLog @@ -1,3 +1,12 @@ +2002-10-01 Rodrigo Moya + + * System.Data.SqlClient/AllTests.cs: added SqlBoolean test. + +2002-10-01 ville + + * System.Data.SqlClient/SqlBooleanTest.cs: new test suite for + SqlBoolean class. + 2002-09-06 Franklin Wise * System.Data\ForeignKeyConstraintTest.cs: added diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/AllTests.cs b/mcs/class/System.Data/Test/System.Data.SqlTypes/AllTests.cs index 41df325d247..8688fecde5c 100644 --- a/mcs/class/System.Data/Test/System.Data.SqlTypes/AllTests.cs +++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/AllTests.cs @@ -19,6 +19,7 @@ namespace MonoTests.System.Data.SqlTypes public static ITest Suite { get { TestSuite suite = new TestSuite (); + suite.AddTest (new TestSuite (typeof (SqlBooleanTest))); suite.AddTest (new TestSuite (typeof (SqlInt32Test))); return suite; } diff --git a/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlBooleanTest.cs b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlBooleanTest.cs new file mode 100644 index 00000000000..f209e19b783 --- /dev/null +++ b/mcs/class/System.Data/Test/System.Data.SqlTypes/SqlBooleanTest.cs @@ -0,0 +1,913 @@ +// SqlDataTimeTest.cs - NUnit Test Cases for [explain here] +// +// Ville Palo (vi64pa@users.sourceforge.net) +// +// (C) Ville Palo +// + +using NUnit.Framework; +using System; +using System.Data.SqlTypes; + +namespace MonoTests.System.Data.SqlTypes +{ + public class SqlBooleanTest : TestCase { + + private SqlBoolean SqlTrue; + private SqlBoolean SqlFalse; + + public SqlBooleanTest() : base ("System.Data.SqlTypes.SqlBoolean") {} + public SqlBooleanTest(string name) : base(name) {} + + protected override void TearDown() {} + + protected override void SetUp() { + SqlTrue = new SqlBoolean(true); + SqlFalse = new SqlBoolean(false); + + } + + public static ITest Suite { + get { + return new TestSuite(typeof(SqlBoolean)); + } + } + + public void TestCreate () + { + SqlBoolean SqlTrue2 = new SqlBoolean(1); + SqlBoolean SqlFalse2 = new SqlBoolean(0); + + Assert("Creation of SqlBoolean failed", SqlTrue.Value); + Assert("Creation of SqlBoolean failed", SqlTrue2.Value); + Assert("Creation of SqlBoolean failed", !SqlFalse.Value); + Assert("Creation of SqlBoolean failed", !SqlFalse2.Value); + + } + + //// + // PUBLIC STATIC METHODS + // + + // And + public void TestAnd() { + + SqlBoolean SqlTrue2 = new SqlBoolean(true); + SqlBoolean SqlFalse2 = new SqlBoolean(false); + + // One result value + SqlBoolean sqlResult; + + // true && false + sqlResult = SqlBoolean.And(SqlTrue, SqlFalse); + Assert("And method does not work correctly (true && false)", !sqlResult.Value); + sqlResult = SqlBoolean.And(SqlFalse, SqlTrue); + Assert("And method does not work correctly (false && true)", !sqlResult.Value); + + // true && true + sqlResult = SqlBoolean.And(SqlTrue, SqlTrue2); + Assert("And method does not work correctly (true && true)", sqlResult.Value); + + sqlResult = SqlBoolean.And(SqlTrue, SqlTrue); + Assert("And method does not work correctly (true && true2)", sqlResult.Value); + + // false && false + sqlResult = SqlBoolean.And(SqlFalse, SqlFalse2); + Assert("And method does not work correctly (false && false)", !sqlResult.Value); + sqlResult = SqlBoolean.And(SqlFalse, SqlFalse); + Assert("And method does not work correctly (false && false2)", !sqlResult.Value); + + } + + // NotEquals + public void TestNotEquals() { + + SqlBoolean SqlTrue2 = new SqlBoolean(true); + SqlBoolean SqlFalse2 = new SqlBoolean(false); + + SqlBoolean SqlResult; + + // true != false + SqlResult = SqlBoolean.NotEquals(SqlTrue, SqlFalse); + Assert("NotEquals method does not work correctly (true != false)", SqlResult.Value); + SqlResult = SqlBoolean.NotEquals(SqlFalse, SqlTrue); + Assert("NotEquals method does not work correctly (false != true)", SqlResult.Value); + + + // true != true + SqlResult = SqlBoolean.NotEquals(SqlTrue, SqlTrue); + Assert("NotEquals method does not work correctly (true != true)", !SqlResult.Value); + SqlResult = SqlBoolean.NotEquals(SqlTrue, SqlTrue2); + Assert("NotEquals method does not work correctly (true != true2)", !SqlResult.Value); + // false != false + SqlResult = SqlBoolean.NotEquals(SqlFalse, SqlFalse); + Assert("NotEquals method does not work correctly (false != false)", !SqlResult.Value); + SqlResult = SqlBoolean.NotEquals(SqlTrue, SqlTrue2); + Assert("NotEquals method does not work correctly (false != false2)", !SqlResult.Value); + + // If either instance of SqlBoolean is null, the Value of the SqlBoolean will be Null. + SqlResult = SqlBoolean.NotEquals(SqlBoolean.Null, SqlFalse); + Assert("NotEquals method does not work correctly (Null != false)", SqlResult.IsNull); + SqlResult = SqlBoolean.NotEquals(SqlTrue, SqlBoolean.Null); + Assert("NotEquals method does not work correctly (false != Null)", SqlResult.IsNull); + + } + + // OnesComplement + public void TestOnesComplement() { + + SqlBoolean SqlFalse2 = SqlBoolean.OnesComplement(SqlTrue); + Assert("OnesComplement method does not work correctly", !SqlFalse2.Value); + + SqlBoolean SqlTrue2 = SqlBoolean.OnesComplement(SqlFalse); + Assert("OnesComplement method does not work correctly", SqlTrue2.Value); + + } + + // Or + public void TestOr() { + + SqlBoolean SqlTrue2 = new SqlBoolean(true); + SqlBoolean SqlFalse2 = new SqlBoolean(false); + + SqlBoolean SqlResult; + + // true || false + SqlResult = SqlBoolean.Or(SqlTrue, SqlFalse); + Assert("Or method does not work correctly (true || false)", SqlResult.Value); + SqlResult = SqlBoolean.Or(SqlFalse, SqlTrue); + Assert("Or method does not work correctly (false || true)", SqlResult.Value); + + // true || true + SqlResult = SqlBoolean.Or(SqlTrue, SqlTrue); + Assert("Or method does not work correctly (true || true)", SqlResult.Value); + SqlResult = SqlBoolean.Or(SqlTrue, SqlTrue2); + Assert("Or method does not work correctly (true || true2)", SqlResult.Value); + + // false || false + SqlResult = SqlBoolean.Or(SqlFalse, SqlFalse); + Assert("Or method does not work correctly (false || false)", !SqlResult.Value); + SqlResult = SqlBoolean.Or(SqlFalse, SqlFalse2); + Assert("Or method does not work correctly (false || false2)", !SqlResult.Value); + + } + + + // Parse + public void TestParse() { + + String error = "Parse method does not work correctly "; + + Assert(error + "(\"True\")", SqlBoolean.Parse("True").Value); + Assert(error + "(\" True\")", SqlBoolean.Parse(" True").Value); + Assert(error + "(\"True \")", SqlBoolean.Parse("True ").Value); + Assert(error + "(\"tRue\")", SqlBoolean.Parse("tRuE").Value); + Assert(error + "(\"False\")", !SqlBoolean.Parse("False").Value); + Assert(error + "(\" False\")", !SqlBoolean.Parse(" False").Value); + Assert(error + "(\"False \")", !SqlBoolean.Parse("False ").Value); + Assert(error + "(\"fAlSe\")", !SqlBoolean.Parse("fAlSe").Value); + + } + + // Xor + public void TestXor() { + + SqlBoolean SqlTrue2 = new SqlBoolean(true); + SqlBoolean SqlFalse2 = new SqlBoolean(false); + + SqlBoolean SqlResult; + + // true ^ false + SqlResult = SqlBoolean.Xor(SqlTrue, SqlFalse); + Assert("Xor method does not work correctly (true ^ false)", SqlResult.Value); + SqlResult = SqlBoolean.Xor(SqlFalse, SqlTrue); + Assert("Xor method does not work correctly (false ^ true)", SqlResult.Value); + + // true ^ true + SqlResult = SqlBoolean.Xor(SqlTrue, SqlTrue2); + Assert("Xor method does not work correctly (true ^ true)", !SqlResult.Value); + + // false ^ false + SqlResult = SqlBoolean.Xor(SqlFalse, SqlFalse2); + Assert("Xor method does not work correctly (false ^ false)", !SqlResult.Value); + + } + + // static Equals + public void TestStaticEquals() { + + SqlBoolean SqlTrue2 = new SqlBoolean(true); + SqlBoolean SqlFalse2 = new SqlBoolean(false); + String error = "Static Equals method does not work correctly "; + + Assert(error + "(true == true)", SqlBoolean.Equals(SqlTrue, SqlTrue2).Value); + Assert(error + "(false == false)", SqlBoolean.Equals(SqlFalse, SqlFalse2).Value); + + Assert(error + "(true == false)", !SqlBoolean.Equals(SqlTrue, SqlFalse).Value); + Assert(error + "(false == true)", !SqlBoolean.Equals(SqlFalse, SqlTrue).Value); + + AssertEquals(error + "(null == false)", SqlBoolean.Null, SqlBoolean.Equals(SqlBoolean.Null, SqlFalse)); + AssertEquals(error + "(true == null)", SqlBoolean.Null, SqlBoolean.Equals(SqlTrue, SqlBoolean.Null)); + + } + + // + // END OF STATIC METHODS + //// + + //// + // PUBLIC METHODS + // + + // CompareTo + public void TestCompareTo() { + + String error = "CompareTo method does not work correctly"; + + Assert(error, (SqlTrue.CompareTo(SqlBoolean.Null) > 0)); + Assert(error, (SqlTrue.CompareTo(SqlFalse) > 0)); + Assert(error, (SqlFalse.CompareTo(SqlTrue) < 0)); + Assert(error, (SqlFalse.CompareTo(SqlFalse) == 0)); + + } + + // Equals + public void TestEquals() { + + SqlBoolean SqlTrue2 = new SqlBoolean(true); + SqlBoolean SqlFalse2 = new SqlBoolean(false); + + String error = "Equals method does not work correctly "; + + Assert(error + "(true == true)", SqlTrue.Equals(SqlTrue2)); + Assert(error + "(false == false)", SqlFalse.Equals(SqlFalse2)); + + Assert(error + "(true == false)", !SqlTrue.Equals(SqlFalse)); + Assert(error + "(false == true)", !SqlFalse.Equals(SqlTrue)); + + Assert(error + "(true == false)", !SqlTrue.Equals(null)); + + } + + public void TestGetHashCode() { + + AssertEquals("GetHashCode method does not work correctly", + 1, SqlTrue.GetHashCode()); + + AssertEquals("GetHashCode method does not work correctly", + 0, SqlFalse.GetHashCode()); + + } + + // GetType + public void TestGetType() { + + AssertEquals("GetType method does not work correctly", + SqlTrue.GetType().ToString(), "System.Data.SqlTypes.SqlBoolean"); + } + + // ToSqlByte + public void TestToSqlByte() { + + SqlByte SqlTestByte; + + String error = "ToSqlByte method does not work correctly "; + + SqlTestByte = SqlTrue.ToSqlByte(); + AssertEquals(error, (byte)1,SqlTestByte.Value); + + SqlTestByte = SqlFalse.ToSqlByte(); + AssertEquals(error, (byte)0, SqlTestByte.Value); + + } + + // ToSqlDecimal + public void TestToSqlDecimal() { + + SqlDecimal SqlTestDecimal; + + String error = "ToSqlDecimal method does not work correctly "; + + SqlTestDecimal = SqlTrue.ToSqlDecimal(); + + AssertEquals(error, (decimal)1, SqlTestDecimal.Value); + + SqlTestDecimal = SqlFalse.ToSqlDecimal(); + AssertEquals(error, (decimal)0, SqlTestDecimal.Value); + } + + // ToSqlDouble + public void TestToSqlDouble() { + + SqlDouble SqlTestDouble; + + String error = "ToSqlDouble method does not work correctly "; + + SqlTestDouble = SqlTrue.ToSqlDouble(); + AssertEquals(error, (double)1, SqlTestDouble.Value); + + SqlTestDouble = SqlFalse.ToSqlDouble(); + AssertEquals(error, (double)0, SqlTestDouble.Value); + } + + // ToSqlInt16 + public void TestToSqlInt16() { + + SqlInt16 SqlTestInt16; + + String error = "ToSqlInt16 method does not work correctly "; + + SqlTestInt16 = SqlTrue.ToSqlInt16(); + AssertEquals(error, (short)1, SqlTestInt16.Value); + + SqlTestInt16 = SqlFalse.ToSqlInt16(); + AssertEquals(error, (short)0, SqlTestInt16.Value); + + } + + // ToSqlInt32 + public void TestToSqlInt32() { + + SqlInt32 SqlTestInt32; + + String error = "ToSqlInt32 method does not work correctly "; + + SqlTestInt32 = SqlTrue.ToSqlInt32(); + AssertEquals(error, (int)1, SqlTestInt32.Value); + + SqlTestInt32 = SqlFalse.ToSqlInt32(); + AssertEquals(error, (int)0, SqlTestInt32.Value); + + } + + // ToSqlInt64 + public void TestToSqlInt64() { + + SqlInt64 SqlTestInt64; + + String error = "ToSqlInt64 method does not work correctly "; + + SqlTestInt64 = SqlTrue.ToSqlInt64(); + AssertEquals(error, (long)1, SqlTestInt64.Value); + + SqlTestInt64 = SqlFalse.ToSqlInt64(); + AssertEquals(error, (long)0, SqlTestInt64.Value); + + } + + // ToSqlMoney + public void TestToSqlMoney() { + + SqlMoney SqlTestMoney; + + String error = "ToSqlMoney method does not work correctly "; + + SqlTestMoney = SqlTrue.ToSqlMoney(); + AssertEquals(error, (decimal)1, SqlTestMoney.Value); + + SqlTestMoney = SqlFalse.ToSqlMoney(); + AssertEquals(error, (decimal)0, SqlTestMoney.Value); + + } + + // ToSqlSingle + public void TestToSqlsingle() { + + SqlSingle SqlTestSingle; + + String error = "ToSqlSingle method does not work correctly "; + + SqlTestSingle = SqlTrue.ToSqlSingle(); + AssertEquals(error, (float)1, SqlTestSingle.Value); + + SqlTestSingle = SqlFalse.ToSqlSingle(); + AssertEquals(error, (float)0, SqlTestSingle.Value); + + } + + // ToSqlString + public void TestToSqlString() { + + SqlString SqlTestString; + + String error = "ToSqlString method does not work correctly "; + + SqlTestString = SqlTrue.ToSqlString(); + AssertEquals(error, "True", SqlTestString.Value); + + SqlTestString = SqlFalse.ToSqlString(); + AssertEquals(error, "False", SqlTestString.Value); + + } + + // ToString + public void TestToString() { + + SqlString TestString; + + String error = "ToString method does not work correctly "; + + TestString = SqlTrue.ToString(); + AssertEquals(error, "True", TestString.Value); + + TestString = SqlFalse.ToSqlString(); + AssertEquals(error, "False", TestString.Value); + + } + + // END OF PUBLIC METHODS + //// + + //// + // OPERATORS + + // BitwixeAnd operator + public void TestBitwiseAndOperator() { + + SqlBoolean SqlTrue2 = new SqlBoolean(true); + SqlBoolean SqlFalse2 = new SqlBoolean(false); + + SqlBoolean SqlResult; + String error = "BitwiseAnd operator does not work correctly "; + + SqlResult = SqlTrue & SqlFalse; + Assert(error + "(true & false)", !SqlResult.Value); + SqlResult = SqlFalse & SqlTrue; + Assert(error + "(false & true)", !SqlResult.Value); + + SqlResult = SqlTrue & SqlTrue2; + Assert(error + "(true & true)", SqlResult.Value); + + SqlResult = SqlFalse & SqlFalse2; + Assert(error + "(false & false)", !SqlResult.Value); + + + } + + // BitwixeOr operator + public void TestBitwiseOrOperator() { + + SqlBoolean SqlTrue2 = new SqlBoolean(true); + SqlBoolean SqlFalse2 = new SqlBoolean(false); + + SqlBoolean SqlResult; + String error = "BitwiseOr operator does not work correctly "; + + SqlResult = SqlTrue | SqlFalse; + Assert(error + "(true | false)", SqlResult.Value); + SqlResult = SqlFalse | SqlTrue; + + Assert(error + "(false | true)", SqlResult.Value); + + SqlResult = SqlTrue | SqlTrue2; + Assert(error + "(true | true)", SqlResult.Value); + + SqlResult = SqlFalse | SqlFalse2; + Assert(error + "(false | false)", !SqlResult.Value); + + } + + // Equality operator + public void TestEqualityOperator() { + + SqlBoolean SqlTrue2 = new SqlBoolean(true); + SqlBoolean SqlFalse2 = new SqlBoolean(false); + + SqlBoolean SqlResult; + String error = "Equality operator does not work correctly "; + + SqlResult = SqlTrue == SqlFalse; + Assert(error + "(true == false)", !SqlResult.Value); + SqlResult = SqlFalse == SqlTrue; + Assert(error + "(false == true)", !SqlResult.Value); + + SqlResult = SqlTrue == SqlTrue2; + Assert(error + "(true == true)", SqlResult.Value); + + SqlResult = SqlFalse == SqlFalse2; + Assert(error + "(false == false)", SqlResult.Value); + + SqlResult = SqlFalse == SqlBoolean.Null; + Assert(error + "(false == Null)", SqlResult.IsNull); + SqlResult = SqlBoolean.Null == SqlBoolean.Null; + Assert(error + "(Null == true)", SqlResult.IsNull); + + } + + // ExlusiveOr operator + public void TestExlusiveOrOperator() { + + SqlBoolean SqlTrue2 = new SqlBoolean(true); + SqlBoolean SqlFalse2 = new SqlBoolean(false); + + SqlBoolean SqlResult; + String error = "ExclusiveOr operator does not work correctly "; + + SqlResult = SqlTrue ^ SqlFalse; + Assert(error + "(true ^ false)", SqlResult.Value); + SqlResult = SqlFalse | SqlTrue; + Assert(error + "(false ^ true)", SqlResult.Value); + + SqlResult = SqlTrue ^ SqlTrue2; + Assert(error + "(true ^ true)", !SqlResult.Value); + + SqlResult = SqlFalse ^ SqlFalse2; + Assert(error + "(false ^ false)", !SqlResult.Value); + + } + + // false operator + public void TestFalseOperator() { + + String error = "false operator does not work correctly "; + + AssertEquals(error + "(true)", SqlBoolean.False, (!SqlTrue)); + AssertEquals(error + "(false)", SqlBoolean.True, (!SqlFalse)); + + } + + // Inequality operator + public void TestInequalityOperator() { + + SqlBoolean SqlTrue2 = new SqlBoolean(true); + SqlBoolean SqlFalse2 = new SqlBoolean(false); + + String error = "Inequality operator does not work correctly" ; + + AssertEquals(error + "(true != true)", SqlBoolean.False, SqlTrue != SqlTrue); + AssertEquals(error + "(true != true)", SqlBoolean.False, SqlTrue != SqlTrue2); + AssertEquals(error + "(false != false)", SqlBoolean.False, SqlFalse != SqlFalse); + AssertEquals(error + "(false != false)", SqlBoolean.False, SqlFalse != SqlFalse2); + AssertEquals(error + "(true != false)", SqlBoolean.True, SqlTrue != SqlFalse); + AssertEquals(error + "(false != true)", SqlBoolean.True, SqlFalse != SqlTrue); + AssertEquals(error + "(null != true)", SqlBoolean.Null, SqlBoolean.Null != SqlTrue); + AssertEquals(error + "(false != null)", SqlBoolean.Null, SqlFalse != SqlBoolean.Null); + + } + + // Logical Not operator + public void TestLogicalNotOperator() { + + String error = "Logical Not operator does not work correctly" ; + + AssertEquals(error + "(true)", SqlBoolean.False, !SqlTrue); + AssertEquals(error + "(false)", SqlBoolean.True, !SqlFalse); + + } + + // OnesComplement operator + public void TestOnesComplementOperator() { + + String error = "Ones complement operator does not work correctly" ; + + SqlBoolean SqlResult; + + SqlResult = ~SqlTrue; + Assert(error + "(true)", !SqlResult.Value); + SqlResult = ~SqlFalse; + Assert(error + "(false)", SqlResult.Value); + + } + + + // true operator + public void TestTrueOperator() { + + String error = "true operator does not work correctly "; + + AssertEquals(error + "(true)", SqlBoolean.True, (SqlTrue)); + AssertEquals(error + "(false)", SqlBoolean.False, (SqlFalse)); + + } + + // SqlBoolean to Boolean + public void TestSqlBooleanToBoolean() { + + String error = "SqlBooleanToBoolean operator does not work correctly "; + + Boolean TestBoolean = (Boolean)SqlTrue; + Assert(error + "(true)", TestBoolean); + TestBoolean = (Boolean)SqlFalse; + Assert(error + "(false)", !TestBoolean); + + } + + // SqlByte to SqlBoolean + public void TestSqlByteToSqlBoolean() { + + SqlByte SqlTestByte; + SqlBoolean SqlTestBoolean; + String error = "SqlByteToSqlBoolean operator does not work correctly "; + + SqlTestByte = new SqlByte(1); + SqlTestBoolean = (SqlBoolean)SqlTestByte; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTestByte = new SqlByte(2); + SqlTestBoolean = (SqlBoolean)SqlTestByte; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTestByte = new SqlByte(0); + SqlTestBoolean = (SqlBoolean)SqlTestByte; + Assert(error + "(false)", !SqlTestBoolean.Value); + + } + + // SqlDecimal to SqlBoolean + public void TestSqlDecimalToSqlBoolean() { + + SqlDecimal SqlTest; + SqlBoolean SqlTestBoolean; + String error = "SqlDecimalToSqlBoolean operator does not work correctly "; + + SqlTest = new SqlDecimal(1); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlDecimal(19); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlDecimal(0); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(false)", !SqlTestBoolean.Value); + + } + + // SqlDouble to SqlBoolean + public void TestSqlDoubleToSqlBoolean() { + + SqlDouble SqlTest; + SqlBoolean SqlTestBoolean; + String error = "SqlDoubleToSqlBoolean operator does not work correctly "; + + SqlTest = new SqlDouble(1); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlDouble(-19.8); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlDouble(0); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(false)", !SqlTestBoolean.Value); + + } + + // SqlIn16 to SqlBoolean + public void TestSqlInt16ToSqlBoolean() { + + SqlInt16 SqlTest; + SqlBoolean SqlTestBoolean; + String error = "SqlInt16ToSqlBoolean operator does not work correctly "; + + SqlTest = new SqlInt16(1); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlInt16(-143); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlInt16(0); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(false)", !SqlTestBoolean.Value); + + } + + // SqlInt32 to SqlBoolean + public void TestSqlInt32ToSqlBoolean() { + + SqlInt32 SqlTest; + SqlBoolean SqlTestBoolean; + String error = "SqlInt32ToSqlBoolean operator does not work correctly "; + + SqlTest = new SqlInt32(1); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlInt32(1430); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlInt32(0); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(false)", !SqlTestBoolean.Value); + } + + // SqlInt64 to SqlBoolean + public void TestSqlInt64ToSqlBoolean() { + + SqlInt64 SqlTest; + SqlBoolean SqlTestBoolean; + String error = "SqlInt64ToSqlBoolean operator does not work correctly "; + + SqlTest = new SqlInt64(1); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlInt64(-14305); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlInt64(0); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(false)", !SqlTestBoolean.Value); + + } + + // SqlMoney to SqlBoolean + public void TestSqlMoneyToSqlBoolean() { + + SqlMoney SqlTest; + SqlBoolean SqlTestBoolean; + String error = "SqlMoneyToSqlBoolean operator does not work correctly "; + + SqlTest = new SqlMoney(1); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlMoney(1305); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlMoney(0); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(false)", !SqlTestBoolean.Value); + + } + + // SqlSingle to SqlBoolean + public void TestSqlSingleToSqlBoolean() { + + SqlSingle SqlTest; + SqlBoolean SqlTestBoolean; + String error = "SqlSingleToSqlBoolean operator does not work correctly "; + + SqlTest = new SqlSingle(1); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlSingle(1305); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlSingle(-305.3); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlSingle(0); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(false)", !SqlTestBoolean.Value); + + } + + // SqlString to SqlBoolean + public void TestSqlStringToSqlBoolean() { + + SqlString SqlTest; + SqlBoolean SqlTestBoolean; + String error = "SqlSingleToSqlBoolean operator does not work correctly "; + + SqlTest = new SqlString("true"); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlString("TRUE"); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlString("True"); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + + SqlTest = new SqlString("false"); + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(false)", !SqlTestBoolean.Value); + + } + + // Boolean to SqlBoolean + public void BooleanToSqlBoolean() { + + SqlBoolean SqlTestBoolean; + bool btrue = true; + bool bfalse = false; + String error = "BooleanToSqlBoolean operator does not work correctly "; + + Boolean SqlTest = true; + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(true)", SqlTestBoolean.Value); + SqlTestBoolean = (SqlBoolean)btrue; + Assert(error + "(true)", SqlTestBoolean.Value); + + + SqlTest = false; + SqlTestBoolean = (SqlBoolean)SqlTest; + Assert(error + "(false)", !SqlTestBoolean.Value); + SqlTestBoolean = (SqlBoolean)bfalse; + Assert(error + "(false)", !SqlTestBoolean.Value); + + } + + // END OF OPERATORS + //// + + //// + // PROPERTIES + + // ByteValue property + public void TestByteValueProperty() { + + String error = "ByteValue property does not work correctly "; + + AssertEquals(error + "(true)", (byte)1, SqlTrue.ByteValue); + AssertEquals(error + "(false)", (byte)0, SqlFalse.ByteValue); + + } + + // IsFalse property + public void TestIsFalseProperty() { + + String error = "IsFalse property does not work correctly "; + + Assert(error + "(true)", !SqlTrue.IsFalse); + Assert(error + "(false)", SqlFalse.IsFalse); + + } + + // IsNull property + public void TestIsNullProperty() { + + String error = "IsNull property does not work correctly "; + + Assert(error + "(true)", !SqlTrue.IsNull); + Assert(error + "(false)", !SqlFalse.IsNull); + Assert(error + "(Null)", SqlBoolean.Null.IsNull); + + } + + // IsTrue property + public void TestIsTrueProperty() { + + String error = "IsTrue property does not work correctly "; + + Assert(error + "(true)", SqlTrue.IsTrue); + Assert(error + "(false)", !SqlFalse.IsTrue); + + } + + // Value property + public void TestValueProperty() { + + String error = "Value property does not work correctly "; + + Assert(error + "(true)", SqlTrue.Value); + Assert(error + "(false)", !SqlFalse.Value); + + } + + // END OF PROPERTIEs + //// + + //// + // FIELDS + + public void TestFalseField() { + + Assert("False field does not work correctly", + !SqlBoolean.False.Value); + + } + + public void TestNullField() { + + Assert("Null field does not work correctly", + SqlBoolean.Null.IsNull); + + } + + public void TestOneField() { + + AssertEquals("One field does not work correctly", + (byte)1, SqlBoolean.One.ByteValue); + } + + + public void TestTrueField() { + + Assert("True field does not work correctly", + SqlBoolean.True.Value); + + } + + public void TestZeroField() { + + AssertEquals("Zero field does not work correctly", + (byte)0, SqlBoolean.Zero.ByteValue); + + } + } +} +