mcs/class/System.Data/Test/System.Data.SqlTypes/SqlBooleanTest.cs

   1 // SqlDataTimeTest.cs - NUnit Test Cases for [explain here]
   2 //
   3 // Ville Palo (vi64pa@users.sourceforge.net)
   4 //
   5 // (C) Ville Palo
   6 //
   7
   8 using NUnit.Framework;
   9 using System;
  10 using System.Data.SqlTypes;
  11
  12 namespace MonoTests.System.Data.SqlTypes
  13 {
  14   public class SqlBooleanTest : TestCase {
  15
  16     private SqlBoolean SqlTrue;
  17     private SqlBoolean SqlFalse;
  18
  19     public SqlBooleanTest() : base ("System.Data.SqlTypes.SqlBoolean") {}
  20     public SqlBooleanTest(string name) : base(name) {}
  21
  22     protected override void TearDown() {}
  23
  24     protected override void SetUp() {
  25       SqlTrue = new SqlBoolean(true);
  26       SqlFalse = new SqlBoolean(false);
  27
  28     }
  29
  30     public static ITest Suite {
  31       get {
  32          return new TestSuite(typeof(SqlBoolean));
  33       }
  34     }
  35
  36     public void TestCreate ()
  37     {
  38       SqlBoolean SqlTrue2 = new SqlBoolean(1);
  39       SqlBoolean SqlFalse2 = new SqlBoolean(0);
  40
  41       Assert("Creation of SqlBoolean failed", SqlTrue.Value);
  42       Assert("Creation of SqlBoolean failed", SqlTrue2.Value);
  43       Assert("Creation of SqlBoolean failed", !SqlFalse.Value);
  44       Assert("Creation of SqlBoolean failed", !SqlFalse2.Value);
  45
  46     }
  47
  48     ////
  49     // PUBLIC STATIC METHODS
  50     //
  51
  52     // And
  53     public void TestAnd() {
  54
  55       SqlBoolean SqlTrue2 = new SqlBoolean(true);
  56       SqlBoolean SqlFalse2 = new SqlBoolean(false);
  57
  58       // One result value
  59       SqlBoolean sqlResult;
  60
  61       // true && false
  62       sqlResult = SqlBoolean.And(SqlTrue, SqlFalse);
  63       Assert("And method does not work correctly (true && false)", !sqlResult.Value);
  64       sqlResult = SqlBoolean.And(SqlFalse, SqlTrue);
  65       Assert("And method does not work correctly (false && true)", !sqlResult.Value);
  66
  67       // true && true
  68       sqlResult = SqlBoolean.And(SqlTrue, SqlTrue2);
  69       Assert("And method does not work correctly (true && true)", sqlResult.Value);
  70
  71       sqlResult = SqlBoolean.And(SqlTrue, SqlTrue);
  72       Assert("And method does not work correctly (true && true2)", sqlResult.Value);
  73
  74       // false && false
  75       sqlResult = SqlBoolean.And(SqlFalse, SqlFalse2);
  76       Assert("And method does not work correctly (false && false)", !sqlResult.Value);
  77       sqlResult = SqlBoolean.And(SqlFalse, SqlFalse);
  78       Assert("And method does not work correctly (false && false2)", !sqlResult.Value);
  79
  80     }
  81
  82     // NotEquals
  83     public void TestNotEquals() {
  84
  85       SqlBoolean SqlTrue2 = new SqlBoolean(true);
  86       SqlBoolean SqlFalse2 = new SqlBoolean(false);
  87
  88       SqlBoolean SqlResult;
  89
  90       // true != false
  91       SqlResult = SqlBoolean.NotEquals(SqlTrue, SqlFalse);
  92       Assert("NotEquals method does not work correctly (true != false)", SqlResult.Value);
  93       SqlResult = SqlBoolean.NotEquals(SqlFalse, SqlTrue);
  94       Assert("NotEquals method does not work correctly (false != true)", SqlResult.Value);
  95
  96
  97       // true != true
  98       SqlResult = SqlBoolean.NotEquals(SqlTrue, SqlTrue);
  99       Assert("NotEquals method does not work correctly (true != true)", !SqlResult.Value);
 100       SqlResult = SqlBoolean.NotEquals(SqlTrue, SqlTrue2);
 101       Assert("NotEquals method does not work correctly (true != true2)", !SqlResult.Value);
 102                  // false != false
 103       SqlResult = SqlBoolean.NotEquals(SqlFalse, SqlFalse);
 104       Assert("NotEquals method does not work correctly (false != false)", !SqlResult.Value);
 105       SqlResult = SqlBoolean.NotEquals(SqlTrue, SqlTrue2);
 106       Assert("NotEquals method does not work correctly (false != false2)", !SqlResult.Value);
 107
 108       // If either instance of SqlBoolean is null, the Value of the SqlBoolean will be Null.
 109       SqlResult = SqlBoolean.NotEquals(SqlBoolean.Null, SqlFalse);
 110       Assert("NotEquals method does not work correctly (Null != false)", SqlResult.IsNull);
 111       SqlResult = SqlBoolean.NotEquals(SqlTrue, SqlBoolean.Null);
 112       Assert("NotEquals method does not work correctly (false != Null)", SqlResult.IsNull);
 113
 114     }
 115
 116     // OnesComplement
 117     public void TestOnesComplement() {
 118
 119       SqlBoolean SqlFalse2 = SqlBoolean.OnesComplement(SqlTrue);
 120       Assert("OnesComplement method does not work correctly", !SqlFalse2.Value);
 121
 122       SqlBoolean SqlTrue2 = SqlBoolean.OnesComplement(SqlFalse);
 123       Assert("OnesComplement method does not work correctly", SqlTrue2.Value);
 124
 125     }
 126
 127     // Or
 128     public void TestOr() {
 129
 130       SqlBoolean SqlTrue2 = new SqlBoolean(true);
 131       SqlBoolean SqlFalse2 = new SqlBoolean(false);
 132
 133       SqlBoolean SqlResult;
 134
 135       // true || false
 136       SqlResult = SqlBoolean.Or(SqlTrue, SqlFalse);
 137       Assert("Or method does not work correctly (true || false)", SqlResult.Value);
 138       SqlResult = SqlBoolean.Or(SqlFalse, SqlTrue);
 139       Assert("Or method does not work correctly (false || true)", SqlResult.Value);
 140
 141       // true || true
 142       SqlResult = SqlBoolean.Or(SqlTrue, SqlTrue);
 143       Assert("Or method does not work correctly (true || true)", SqlResult.Value);
 144       SqlResult = SqlBoolean.Or(SqlTrue, SqlTrue2);
 145       Assert("Or method does not work correctly (true || true2)", SqlResult.Value);
 146
 147       // false || false
 148       SqlResult = SqlBoolean.Or(SqlFalse, SqlFalse);
 149       Assert("Or method does not work correctly (false || false)", !SqlResult.Value);
 150       SqlResult = SqlBoolean.Or(SqlFalse, SqlFalse2);
 151       Assert("Or method does not work correctly (false || false2)", !SqlResult.Value);
 152
 153     }
 154
 155
 156     //  Parse
 157     public void TestParse() {
 158
 159       String error = "Parse method does not work correctly ";
 160
 161       Assert(error + "(\"True\")", SqlBoolean.Parse("True").Value);
 162       Assert(error + "(\" True\")", SqlBoolean.Parse(" True").Value);
 163       Assert(error + "(\"True \")", SqlBoolean.Parse("True ").Value);
 164       Assert(error + "(\"tRue\")", SqlBoolean.Parse("tRuE").Value);
 165       Assert(error + "(\"False\")", !SqlBoolean.Parse("False").Value);
 166       Assert(error + "(\" False\")", !SqlBoolean.Parse(" False").Value);
 167       Assert(error + "(\"False \")", !SqlBoolean.Parse("False ").Value);
 168       Assert(error + "(\"fAlSe\")", !SqlBoolean.Parse("fAlSe").Value);
 169
 170     }
 171
 172     // Xor
 173     public void TestXor() {
 174
 175       SqlBoolean SqlTrue2 = new SqlBoolean(true);
 176       SqlBoolean SqlFalse2 = new SqlBoolean(false);
 177
 178       SqlBoolean SqlResult;
 179
 180       // true ^ false
 181       SqlResult = SqlBoolean.Xor(SqlTrue, SqlFalse);
 182       Assert("Xor method does not work correctly (true ^ false)", SqlResult.Value);
 183       SqlResult = SqlBoolean.Xor(SqlFalse, SqlTrue);
 184       Assert("Xor method does not work correctly (false ^ true)", SqlResult.Value);
 185
 186       // true ^ true
 187       SqlResult = SqlBoolean.Xor(SqlTrue, SqlTrue2);
 188       Assert("Xor method does not work correctly (true ^ true)", !SqlResult.Value);
 189
 190       // false ^ false
 191       SqlResult = SqlBoolean.Xor(SqlFalse, SqlFalse2);
 192       Assert("Xor method does not work correctly (false ^ false)", !SqlResult.Value);
 193
 194     }
 195
 196     // static Equals
 197     public void TestStaticEquals() {
 198
 199       SqlBoolean SqlTrue2 = new SqlBoolean(true);
 200       SqlBoolean SqlFalse2 = new SqlBoolean(false);
 201       String error = "Static Equals method does not work correctly ";
 202
 203       Assert(error +  "(true == true)", SqlBoolean.Equals(SqlTrue, SqlTrue2).Value);
 204       Assert(error +  "(false == false)", SqlBoolean.Equals(SqlFalse, SqlFalse2).Value);
 205
 206       Assert(error +  "(true == false)", !SqlBoolean.Equals(SqlTrue, SqlFalse).Value);
 207       Assert(error +  "(false == true)", !SqlBoolean.Equals(SqlFalse, SqlTrue).Value);
 208
 209       AssertEquals(error +  "(null == false)", SqlBoolean.Null, SqlBoolean.Equals(SqlBoolean.Null, SqlFalse));
 210       AssertEquals(error +  "(true == null)", SqlBoolean.Null, SqlBoolean.Equals(SqlTrue, SqlBoolean.Null));
 211
 212     }
 213
 214     //
 215     // END OF STATIC METHODS
 216     ////
 217
 218     ////
 219     // PUBLIC METHODS
 220     //
 221
 222     // CompareTo
 223     public void TestCompareTo() {
 224
 225       String error = "CompareTo method does not work correctly";
 226
 227       Assert(error, (SqlTrue.CompareTo(SqlBoolean.Null) > 0));
 228       Assert(error, (SqlTrue.CompareTo(SqlFalse) > 0));
 229       Assert(error, (SqlFalse.CompareTo(SqlTrue) < 0));
 230       Assert(error, (SqlFalse.CompareTo(SqlFalse) == 0));
 231
 232     }
 233
 234     // Equals
 235     public void TestEquals() {
 236
 237       SqlBoolean SqlTrue2 = new SqlBoolean(true);
 238       SqlBoolean SqlFalse2 = new SqlBoolean(false);
 239
 240       String error = "Equals method does not work correctly ";
 241
 242       Assert(error + "(true == true)", SqlTrue.Equals(SqlTrue2));
 243       Assert(error + "(false == false)", SqlFalse.Equals(SqlFalse2));
 244
 245       Assert(error + "(true == false)", !SqlTrue.Equals(SqlFalse));
 246       Assert(error + "(false == true)", !SqlFalse.Equals(SqlTrue));
 247
 248       Assert(error + "(true == false)", !SqlTrue.Equals(null));
 249
 250     }
 251
 252     public void TestGetHashCode() {
 253
 254       AssertEquals("GetHashCode method does not work correctly",
 255           1, SqlTrue.GetHashCode());
 256
 257       AssertEquals("GetHashCode method does not work correctly",
 258           0, SqlFalse.GetHashCode());
 259
 260     }
 261
 262     // GetType
 263     public void TestGetType() {
 264
 265       AssertEquals("GetType method does not work correctly",
 266           SqlTrue.GetType().ToString(), "System.Data.SqlTypes.SqlBoolean");
 267     }
 268
 269     // ToSqlByte
 270     public void TestToSqlByte() {
 271
 272       SqlByte SqlTestByte;
 273
 274       String error = "ToSqlByte method does not work correctly ";
 275
 276       SqlTestByte = SqlTrue.ToSqlByte();
 277       AssertEquals(error, (byte)1,SqlTestByte.Value);
 278
 279       SqlTestByte = SqlFalse.ToSqlByte();
 280       AssertEquals(error, (byte)0, SqlTestByte.Value);
 281
 282     }
 283
 284     // ToSqlDecimal
 285     public void TestToSqlDecimal() {
 286
 287       SqlDecimal SqlTestDecimal;
 288
 289       String error = "ToSqlDecimal method does not work correctly ";
 290
 291       SqlTestDecimal = SqlTrue.ToSqlDecimal();
 292
 293       AssertEquals(error, (decimal)1, SqlTestDecimal.Value);
 294
 295       SqlTestDecimal = SqlFalse.ToSqlDecimal();
 296       AssertEquals(error, (decimal)0, SqlTestDecimal.Value);
 297     }
 298
 299     // ToSqlDouble
 300     public void TestToSqlDouble() {
 301
 302       SqlDouble SqlTestDouble;
 303
 304       String error = "ToSqlDouble method does not work correctly ";
 305
 306       SqlTestDouble = SqlTrue.ToSqlDouble();
 307       AssertEquals(error, (double)1, SqlTestDouble.Value);
 308
 309       SqlTestDouble = SqlFalse.ToSqlDouble();
 310       AssertEquals(error, (double)0, SqlTestDouble.Value);
 311     }
 312
 313     // ToSqlInt16
 314     public void TestToSqlInt16() {
 315
 316       SqlInt16 SqlTestInt16;
 317
 318       String error = "ToSqlInt16 method does not work correctly ";
 319
 320       SqlTestInt16 = SqlTrue.ToSqlInt16();
 321       AssertEquals(error, (short)1, SqlTestInt16.Value);
 322
 323       SqlTestInt16 = SqlFalse.ToSqlInt16();
 324       AssertEquals(error, (short)0, SqlTestInt16.Value);
 325
 326     }
 327
 328     // ToSqlInt32
 329     public void TestToSqlInt32() {
 330
 331       SqlInt32 SqlTestInt32;
 332
 333       String error = "ToSqlInt32 method does not work correctly ";
 334
 335       SqlTestInt32 = SqlTrue.ToSqlInt32();
 336       AssertEquals(error, (int)1, SqlTestInt32.Value);
 337
 338       SqlTestInt32 = SqlFalse.ToSqlInt32();
 339       AssertEquals(error, (int)0, SqlTestInt32.Value);
 340
 341     }
 342
 343     // ToSqlInt64
 344     public void TestToSqlInt64() {
 345
 346       SqlInt64 SqlTestInt64;
 347
 348       String error = "ToSqlInt64 method does not work correctly ";
 349
 350       SqlTestInt64 = SqlTrue.ToSqlInt64();
 351       AssertEquals(error, (long)1, SqlTestInt64.Value);
 352
 353       SqlTestInt64 = SqlFalse.ToSqlInt64();
 354       AssertEquals(error, (long)0, SqlTestInt64.Value);
 355
 356     }
 357
 358     // ToSqlMoney
 359     public void TestToSqlMoney() {
 360
 361       SqlMoney SqlTestMoney;
 362
 363       String error = "ToSqlMoney method does not work correctly ";
 364
 365       SqlTestMoney = SqlTrue.ToSqlMoney();
 366       AssertEquals(error, (decimal)1, SqlTestMoney.Value);
 367
 368       SqlTestMoney = SqlFalse.ToSqlMoney();
 369       AssertEquals(error, (decimal)0, SqlTestMoney.Value);
 370
 371     }
 372
 373     // ToSqlSingle
 374     public void TestToSqlsingle() {
 375
 376       SqlSingle SqlTestSingle;
 377
 378       String error = "ToSqlSingle method does not work correctly ";
 379
 380       SqlTestSingle = SqlTrue.ToSqlSingle();
 381       AssertEquals(error, (float)1, SqlTestSingle.Value);
 382
 383       SqlTestSingle = SqlFalse.ToSqlSingle();
 384       AssertEquals(error, (float)0, SqlTestSingle.Value);
 385
 386     }
 387
 388     // ToSqlString
 389     public void TestToSqlString() {
 390
 391       SqlString SqlTestString;
 392
 393       String error = "ToSqlString method does not work correctly ";
 394
 395       SqlTestString = SqlTrue.ToSqlString();
 396       AssertEquals(error, "True", SqlTestString.Value);
 397
 398       SqlTestString = SqlFalse.ToSqlString();
 399       AssertEquals(error, "False", SqlTestString.Value);
 400
 401     }
 402
 403     // ToString
 404     public void TestToString() {
 405
 406       SqlString TestString;
 407
 408       String error = "ToString method does not work correctly ";
 409
 410       TestString = SqlTrue.ToString();
 411       AssertEquals(error, "True", TestString.Value);
 412
 413       TestString = SqlFalse.ToSqlString();
 414       AssertEquals(error, "False", TestString.Value);
 415
 416     }
 417
 418     // END OF PUBLIC METHODS
 419     ////
 420
 421     ////
 422     // OPERATORS
 423
 424     // BitwixeAnd operator
 425     public void TestBitwiseAndOperator() {
 426
 427       SqlBoolean SqlTrue2 = new SqlBoolean(true);
 428       SqlBoolean SqlFalse2 = new SqlBoolean(false);
 429
 430       SqlBoolean SqlResult;
 431       String error = "BitwiseAnd operator does not work correctly ";
 432
 433       SqlResult = SqlTrue & SqlFalse;
 434       Assert(error + "(true & false)", !SqlResult.Value);
 435       SqlResult = SqlFalse & SqlTrue;
 436       Assert(error + "(false & true)", !SqlResult.Value);
 437
 438       SqlResult = SqlTrue & SqlTrue2;
 439       Assert(error + "(true & true)", SqlResult.Value);
 440
 441       SqlResult = SqlFalse & SqlFalse2;
 442       Assert(error + "(false & false)", !SqlResult.Value);
 443
 444
 445     }
 446
 447     // BitwixeOr operator
 448     public void TestBitwiseOrOperator() {
 449
 450       SqlBoolean SqlTrue2 = new SqlBoolean(true);
 451       SqlBoolean SqlFalse2 = new SqlBoolean(false);
 452
 453       SqlBoolean SqlResult;
 454       String error = "BitwiseOr operator does not work correctly ";
 455
 456       SqlResult = SqlTrue | SqlFalse;
 457       Assert(error + "(true | false)", SqlResult.Value);
 458       SqlResult = SqlFalse | SqlTrue;
 459
 460       Assert(error + "(false | true)", SqlResult.Value);
 461
 462       SqlResult = SqlTrue | SqlTrue2;
 463       Assert(error + "(true | true)", SqlResult.Value);
 464
 465       SqlResult = SqlFalse | SqlFalse2;
 466       Assert(error + "(false | false)", !SqlResult.Value);
 467
 468     }
 469
 470     // Equality operator
 471     public void TestEqualityOperator() {
 472
 473       SqlBoolean SqlTrue2 = new SqlBoolean(true);
 474       SqlBoolean SqlFalse2 = new SqlBoolean(false);
 475
 476       SqlBoolean SqlResult;
 477       String error = "Equality operator does not work correctly ";
 478
 479       SqlResult = SqlTrue == SqlFalse;
 480       Assert(error + "(true == false)", !SqlResult.Value);
 481       SqlResult = SqlFalse == SqlTrue;
 482       Assert(error + "(false == true)", !SqlResult.Value);
 483
 484       SqlResult = SqlTrue == SqlTrue2;
 485       Assert(error + "(true == true)", SqlResult.Value);
 486
 487       SqlResult = SqlFalse == SqlFalse2;
 488       Assert(error + "(false == false)", SqlResult.Value);
 489
 490       SqlResult = SqlFalse == SqlBoolean.Null;
 491       Assert(error + "(false == Null)", SqlResult.IsNull);
 492       SqlResult = SqlBoolean.Null == SqlBoolean.Null;
 493       Assert(error + "(Null == true)", SqlResult.IsNull);
 494
 495     }
 496
 497     // ExlusiveOr operator
 498     public void TestExlusiveOrOperator() {
 499
 500       SqlBoolean SqlTrue2 = new SqlBoolean(true);
 501       SqlBoolean SqlFalse2 = new SqlBoolean(false);
 502
 503       SqlBoolean SqlResult;
 504       String error = "ExclusiveOr operator does not work correctly ";
 505
 506       SqlResult = SqlTrue ^ SqlFalse;
 507       Assert(error + "(true ^ false)", SqlResult.Value);
 508       SqlResult = SqlFalse | SqlTrue;
 509       Assert(error + "(false ^ true)", SqlResult.Value);
 510
 511       SqlResult = SqlTrue ^ SqlTrue2;
 512       Assert(error + "(true ^ true)", !SqlResult.Value);
 513
 514       SqlResult = SqlFalse ^ SqlFalse2;
 515       Assert(error + "(false ^ false)", !SqlResult.Value);
 516
 517     }
 518
 519     // false operator
 520     public void TestFalseOperator() {
 521
 522       String error = "false operator does not work correctly ";
 523
 524       AssertEquals(error + "(true)", SqlBoolean.False, (!SqlTrue));
 525       AssertEquals(error + "(false)", SqlBoolean.True, (!SqlFalse));
 526
 527     }
 528
 529     // Inequality operator
 530     public void TestInequalityOperator() {
 531
 532       SqlBoolean SqlTrue2 = new SqlBoolean(true);
 533       SqlBoolean SqlFalse2 = new SqlBoolean(false);
 534
 535       String error = "Inequality operator does not work correctly" ;
 536
 537       AssertEquals(error + "(true != true)",   SqlBoolean.False, SqlTrue != SqlTrue);
 538       AssertEquals(error + "(true != true)",   SqlBoolean.False, SqlTrue != SqlTrue2);
 539       AssertEquals(error + "(false != false)", SqlBoolean.False, SqlFalse != SqlFalse);
 540       AssertEquals(error + "(false != false)", SqlBoolean.False, SqlFalse != SqlFalse2);
 541       AssertEquals(error + "(true != false)",  SqlBoolean.True, SqlTrue != SqlFalse);
 542       AssertEquals(error + "(false != true)",  SqlBoolean.True, SqlFalse != SqlTrue);
 543       AssertEquals(error + "(null != true)",   SqlBoolean.Null, SqlBoolean.Null != SqlTrue);
 544       AssertEquals(error + "(false != null)",  SqlBoolean.Null, SqlFalse != SqlBoolean.Null);
 545
 546     }
 547
 548     // Logical Not operator
 549     public void TestLogicalNotOperator() {
 550
 551       String error = "Logical Not operator does not work correctly" ;
 552
 553       AssertEquals(error + "(true)", SqlBoolean.False, !SqlTrue);
 554       AssertEquals(error + "(false)", SqlBoolean.True, !SqlFalse);
 555
 556     }
 557
 558     // OnesComplement operator
 559     public void TestOnesComplementOperator() {
 560
 561       String error = "Ones complement operator does not work correctly" ;
 562
 563       SqlBoolean SqlResult;
 564
 565       SqlResult = ~SqlTrue;
 566       Assert(error + "(true)", !SqlResult.Value);
 567       SqlResult = ~SqlFalse;
 568       Assert(error + "(false)", SqlResult.Value);
 569
 570     }
 571
 572
 573     // true operator
 574     public void TestTrueOperator() {
 575
 576       String error = "true operator does not work correctly ";
 577
 578       AssertEquals(error + "(true)", SqlBoolean.True, (SqlTrue));
 579       AssertEquals(error + "(false)", SqlBoolean.False, (SqlFalse));
 580
 581     }
 582
 583     // SqlBoolean to Boolean
 584     public void TestSqlBooleanToBoolean() {
 585
 586       String error = "SqlBooleanToBoolean operator does not work correctly ";
 587
 588       Boolean TestBoolean = (Boolean)SqlTrue;
 589       Assert(error + "(true)",  TestBoolean);
 590       TestBoolean = (Boolean)SqlFalse;
 591       Assert(error + "(false)",  !TestBoolean);
 592
 593     }
 594
 595     // SqlByte to SqlBoolean
 596     public void TestSqlByteToSqlBoolean() {
 597
 598       SqlByte SqlTestByte;
 599       SqlBoolean SqlTestBoolean;
 600       String error = "SqlByteToSqlBoolean operator does not work correctly ";
 601
 602       SqlTestByte = new SqlByte(1);
 603       SqlTestBoolean = (SqlBoolean)SqlTestByte;
 604       Assert(error + "(true)", SqlTestBoolean.Value);
 605
 606       SqlTestByte = new SqlByte(2);
 607       SqlTestBoolean = (SqlBoolean)SqlTestByte;
 608       Assert(error + "(true)", SqlTestBoolean.Value);
 609
 610       SqlTestByte = new SqlByte(0);
 611       SqlTestBoolean = (SqlBoolean)SqlTestByte;
 612       Assert(error + "(false)", !SqlTestBoolean.Value);
 613
 614     }
 615
 616     // SqlDecimal to SqlBoolean
 617     public void TestSqlDecimalToSqlBoolean() {
 618
 619       SqlDecimal SqlTest;
 620       SqlBoolean SqlTestBoolean;
 621       String error = "SqlDecimalToSqlBoolean operator does not work correctly ";
 622
 623       SqlTest = new SqlDecimal(1);
 624       SqlTestBoolean = (SqlBoolean)SqlTest;
 625       Assert(error + "(true)", SqlTestBoolean.Value);
 626
 627       SqlTest = new SqlDecimal(19);
 628       SqlTestBoolean = (SqlBoolean)SqlTest;
 629       Assert(error + "(true)", SqlTestBoolean.Value);
 630
 631       SqlTest = new SqlDecimal(0);
 632       SqlTestBoolean = (SqlBoolean)SqlTest;
 633       Assert(error + "(false)", !SqlTestBoolean.Value);
 634
 635     }
 636
 637     // SqlDouble to SqlBoolean
 638     public void TestSqlDoubleToSqlBoolean() {
 639
 640       SqlDouble SqlTest;
 641       SqlBoolean SqlTestBoolean;
 642       String error = "SqlDoubleToSqlBoolean operator does not work correctly ";
 643
 644       SqlTest = new SqlDouble(1);
 645       SqlTestBoolean = (SqlBoolean)SqlTest;
 646       Assert(error + "(true)", SqlTestBoolean.Value);
 647
 648       SqlTest = new SqlDouble(-19.8);
 649       SqlTestBoolean = (SqlBoolean)SqlTest;
 650       Assert(error + "(true)", SqlTestBoolean.Value);
 651
 652       SqlTest = new SqlDouble(0);
 653       SqlTestBoolean = (SqlBoolean)SqlTest;
 654       Assert(error + "(false)", !SqlTestBoolean.Value);
 655
 656     }
 657
 658     // SqlIn16 to SqlBoolean
 659     public void TestSqlInt16ToSqlBoolean() {
 660
 661       SqlInt16 SqlTest;
 662       SqlBoolean SqlTestBoolean;
 663       String error = "SqlInt16ToSqlBoolean operator does not work correctly ";
 664
 665       SqlTest = new SqlInt16(1);
 666       SqlTestBoolean = (SqlBoolean)SqlTest;
 667       Assert(error + "(true)", SqlTestBoolean.Value);
 668
 669       SqlTest = new SqlInt16(-143);
 670       SqlTestBoolean = (SqlBoolean)SqlTest;
 671       Assert(error + "(true)", SqlTestBoolean.Value);
 672
 673       SqlTest = new SqlInt16(0);
 674       SqlTestBoolean = (SqlBoolean)SqlTest;
 675       Assert(error + "(false)", !SqlTestBoolean.Value);
 676
 677     }
 678
 679     // SqlInt32 to SqlBoolean
 680     public void TestSqlInt32ToSqlBoolean() {
 681
 682       SqlInt32 SqlTest;
 683       SqlBoolean SqlTestBoolean;
 684       String error = "SqlInt32ToSqlBoolean operator does not work correctly ";
 685
 686       SqlTest = new SqlInt32(1);
 687       SqlTestBoolean = (SqlBoolean)SqlTest;
 688       Assert(error + "(true)", SqlTestBoolean.Value);
 689
 690       SqlTest = new SqlInt32(1430);
 691       SqlTestBoolean = (SqlBoolean)SqlTest;
 692       Assert(error + "(true)", SqlTestBoolean.Value);
 693
 694       SqlTest = new SqlInt32(0);
 695       SqlTestBoolean = (SqlBoolean)SqlTest;
 696       Assert(error + "(false)", !SqlTestBoolean.Value);
 697     }
 698
 699     // SqlInt64 to SqlBoolean
 700     public void TestSqlInt64ToSqlBoolean() {
 701
 702       SqlInt64 SqlTest;
 703       SqlBoolean SqlTestBoolean;
 704       String error = "SqlInt64ToSqlBoolean operator does not work correctly ";
 705
 706       SqlTest = new SqlInt64(1);
 707       SqlTestBoolean = (SqlBoolean)SqlTest;
 708       Assert(error + "(true)", SqlTestBoolean.Value);
 709
 710       SqlTest = new SqlInt64(-14305);
 711       SqlTestBoolean = (SqlBoolean)SqlTest;
 712       Assert(error + "(true)", SqlTestBoolean.Value);
 713
 714       SqlTest = new SqlInt64(0);
 715       SqlTestBoolean = (SqlBoolean)SqlTest;
 716       Assert(error + "(false)", !SqlTestBoolean.Value);
 717
 718     }
 719
 720     // SqlMoney to SqlBoolean
 721     public void TestSqlMoneyToSqlBoolean() {
 722
 723       SqlMoney SqlTest;
 724       SqlBoolean SqlTestBoolean;
 725       String error = "SqlMoneyToSqlBoolean operator does not work correctly ";
 726
 727       SqlTest = new SqlMoney(1);
 728       SqlTestBoolean = (SqlBoolean)SqlTest;
 729       Assert(error + "(true)", SqlTestBoolean.Value);
 730
 731       SqlTest = new SqlMoney(1305);
 732       SqlTestBoolean = (SqlBoolean)SqlTest;
 733       Assert(error + "(true)", SqlTestBoolean.Value);
 734
 735       SqlTest = new SqlMoney(0);
 736       SqlTestBoolean = (SqlBoolean)SqlTest;
 737       Assert(error + "(false)", !SqlTestBoolean.Value);
 738
 739     }
 740
 741     // SqlSingle to SqlBoolean
 742     public void TestSqlSingleToSqlBoolean() {
 743
 744       SqlSingle SqlTest;
 745       SqlBoolean SqlTestBoolean;
 746       String error = "SqlSingleToSqlBoolean operator does not work correctly ";
 747
 748       SqlTest = new SqlSingle(1);
 749       SqlTestBoolean = (SqlBoolean)SqlTest;
 750       Assert(error + "(true)", SqlTestBoolean.Value);
 751
 752       SqlTest = new SqlSingle(1305);
 753       SqlTestBoolean = (SqlBoolean)SqlTest;
 754       Assert(error + "(true)", SqlTestBoolean.Value);
 755
 756       SqlTest = new SqlSingle(-305.3);
 757       SqlTestBoolean = (SqlBoolean)SqlTest;
 758       Assert(error + "(true)", SqlTestBoolean.Value);
 759
 760       SqlTest = new SqlSingle(0);
 761       SqlTestBoolean = (SqlBoolean)SqlTest;
 762       Assert(error + "(false)", !SqlTestBoolean.Value);
 763
 764     }
 765
 766     // SqlString to SqlBoolean
 767     public void TestSqlStringToSqlBoolean() {
 768
 769       SqlString SqlTest;
 770       SqlBoolean SqlTestBoolean;
 771       String error = "SqlSingleToSqlBoolean operator does not work correctly ";
 772
 773       SqlTest = new SqlString("true");
 774       SqlTestBoolean = (SqlBoolean)SqlTest;
 775       Assert(error + "(true)", SqlTestBoolean.Value);
 776
 777       SqlTest = new SqlString("TRUE");
 778       SqlTestBoolean = (SqlBoolean)SqlTest;
 779       Assert(error + "(true)", SqlTestBoolean.Value);
 780
 781       SqlTest = new SqlString("True");
 782       SqlTestBoolean = (SqlBoolean)SqlTest;
 783       Assert(error + "(true)", SqlTestBoolean.Value);
 784
 785       SqlTest = new SqlString("false");
 786       SqlTestBoolean = (SqlBoolean)SqlTest;
 787       Assert(error + "(false)", !SqlTestBoolean.Value);
 788
 789     }
 790
 791     // Boolean to SqlBoolean
 792     public void BooleanToSqlBoolean() {
 793
 794       SqlBoolean SqlTestBoolean;
 795       bool btrue = true;
 796       bool bfalse = false;
 797       String error = "BooleanToSqlBoolean operator does not work correctly ";
 798
 799       Boolean SqlTest = true;
 800       SqlTestBoolean = (SqlBoolean)SqlTest;
 801       Assert(error + "(true)", SqlTestBoolean.Value);
 802       SqlTestBoolean = (SqlBoolean)btrue;
 803       Assert(error + "(true)", SqlTestBoolean.Value);
 804
 805
 806       SqlTest = false;
 807       SqlTestBoolean = (SqlBoolean)SqlTest;
 808       Assert(error + "(false)", !SqlTestBoolean.Value);
 809       SqlTestBoolean = (SqlBoolean)bfalse;
 810       Assert(error + "(false)", !SqlTestBoolean.Value);
 811
 812     }
 813
 814     // END OF OPERATORS
 815     ////
 816
 817     ////
 818     // PROPERTIES
 819
 820     // ByteValue property
 821     public void TestByteValueProperty() {
 822
 823       String error = "ByteValue property does not work correctly ";
 824
 825       AssertEquals(error + "(true)", (byte)1, SqlTrue.ByteValue);
 826       AssertEquals(error + "(false)", (byte)0, SqlFalse.ByteValue);
 827
 828     }
 829
 830     // IsFalse property
 831     public void TestIsFalseProperty() {
 832
 833       String error = "IsFalse property does not work correctly ";
 834
 835       Assert(error + "(true)", !SqlTrue.IsFalse);
 836       Assert(error + "(false)", SqlFalse.IsFalse);
 837
 838     }
 839
 840     // IsNull property
 841     public void TestIsNullProperty() {
 842
 843       String error = "IsNull property does not work correctly ";
 844
 845       Assert(error + "(true)", !SqlTrue.IsNull);
 846       Assert(error + "(false)", !SqlFalse.IsNull);
 847       Assert(error + "(Null)", SqlBoolean.Null.IsNull);
 848
 849     }
 850
 851     // IsTrue property
 852     public void TestIsTrueProperty() {
 853
 854       String error = "IsTrue property does not work correctly ";
 855
 856       Assert(error + "(true)", SqlTrue.IsTrue);
 857       Assert(error + "(false)", !SqlFalse.IsTrue);
 858
 859     }
 860
 861     // Value property
 862     public void TestValueProperty() {
 863
 864       String error = "Value property does not work correctly ";
 865
 866       Assert(error + "(true)", SqlTrue.Value);
 867       Assert(error + "(false)", !SqlFalse.Value);
 868
 869     }
 870
 871     // END OF PROPERTIEs
 872     ////
 873
 874     ////
 875     // FIELDS
 876
 877     public void TestFalseField() {
 878
 879       Assert("False field does not work correctly",
 880         !SqlBoolean.False.Value);
 881
 882     }
 883
 884     public void TestNullField() {
 885
 886       Assert("Null field does not work correctly",
 887         SqlBoolean.Null.IsNull);
 888
 889     }
 890
 891     public void TestOneField() {
 892
 893       AssertEquals("One field does not work correctly",
 894         (byte)1, SqlBoolean.One.ByteValue);
 895     }
 896
 897
 898     public void TestTrueField() {
 899
 900       Assert("True field does not work correctly",
 901         SqlBoolean.True.Value);
 902
 903     }
 904
 905     public void TestZeroField() {
 906
 907       AssertEquals("Zero field does not work correctly",
 908         (byte)0, SqlBoolean.Zero.ByteValue);
 909
 910     }
 911   }
 912 }
 913