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

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