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