--- /dev/null
+// 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);
+
+ }
+ }
+}
+
projects / mono.git / commitdiff