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

   1 //
   2 // SqlInt16Test.cs - NUnit Test Cases for System.Data.SqlTypes.SqlInt16
   3 //
   4 // Ville Palo (vi64pa@koti.soon.fi)
   5 //
   6 // (C) Ville Palo 2002
   7 //
   8
   9 using NUnit.Framework;
  10 using System;
  11 using System.Data.SqlTypes;
  12
  13 namespace MonoTests.System.Data.SqlTypes
  14 {
  15         public class SqlInt16Test : TestCase {
  16
  17                 public SqlInt16Test() : base ("System.Data.SqlTypes.SqlInt64") {}
  18                 public SqlInt16Test(string name) : base(name) {}
  19
  20                 protected override void TearDown() {}
  21
  22                 protected override void SetUp() {}
  23
  24                 public static ITest Suite {
  25                         get {
  26                                 return new TestSuite(typeof(SqlInt32));
  27                         }
  28                 }
  29
  30                 // Test constructor
  31                 public void TestCreate()
  32                 {
  33                         SqlInt16 TestShort = new SqlInt16 (29);
  34                         AssertEquals ("Test#1", (short)29, TestShort.Value);
  35
  36                         TestShort = new SqlInt16 (-9000);
  37                         AssertEquals ("Test#2", (short)-9000, TestShort.Value);
  38                 }
  39
  40                 // Test public fields
  41                 public void TestPublicFields()
  42                 {
  43                         AssertEquals ("Test#1", (SqlInt16)32767, SqlInt16.MaxValue);
  44                         AssertEquals ("Test#2", (SqlInt16)(-32768), SqlInt16.MinValue);
  45                         Assert ("Test#3", SqlInt16.Null.IsNull);
  46                         AssertEquals ("Test#4", (short)0, SqlInt16.Zero.Value);
  47                 }
  48
  49                 // Test properties
  50                 public void TestProperties()
  51                 {
  52                         SqlInt16 Test5443 = new SqlInt16 (5443);
  53                         SqlInt16 Test1 = new SqlInt16 (1);
  54                         Assert ("Test#1", SqlInt16.Null.IsNull);
  55                         AssertEquals ("Test#2", (short)5443, Test5443.Value);
  56                         AssertEquals ("Test#3", (short)1, Test1.Value);
  57                 }
  58
  59                 // PUBLIC METHODS
  60
  61                 public void TestArithmeticMethods()
  62                 {
  63                         SqlInt16 Test64 = new SqlInt16 (64);
  64                         SqlInt16 Test0 = new SqlInt16 (0);
  65                         SqlInt16 Test164 = new SqlInt16 (164);
  66                         SqlInt16 TestMax = new SqlInt16 (SqlInt16.MaxValue.Value);
  67
  68                         // Add()
  69                         AssertEquals ("Test#1", (short)64, SqlInt16.Add (Test64, Test0).Value);
  70                         AssertEquals ("Test#2", (short)228, SqlInt16.Add (Test64, Test164).Value);
  71                         AssertEquals ("Test#3", (short)164, SqlInt16.Add (Test0, Test164).Value);
  72                         AssertEquals ("Test#4", (short)SqlInt16.MaxValue, SqlInt16.Add (TestMax, Test0).Value);
  73
  74                         try {
  75                                 SqlInt16.Add (TestMax, Test64);
  76                                 Fail ("Test#5");
  77                         } catch (Exception e) {
  78                                 AssertEquals ("Test#6", typeof (OverflowException), e.GetType ());
  79                         }
  80
  81                         // Divide()
  82                         AssertEquals ("Test#7", (short)2, SqlInt16.Divide (Test164, Test64).Value);
  83                         AssertEquals ("Test#8", (short)0, SqlInt16.Divide (Test64, Test164).Value);
  84                         try {
  85                                 SqlInt16.Divide(Test64, Test0);
  86                                 Fail ("Test#9");
  87                         } catch(Exception e) {
  88                                 AssertEquals ("Test#10", typeof (DivideByZeroException), e.GetType ());
  89                         }
  90
  91                         // Mod()
  92                         AssertEquals ("Test#11", (SqlInt16)36, SqlInt16.Mod (Test164, Test64));
  93                         AssertEquals ("Test#12",  (SqlInt16)64, SqlInt16.Mod (Test64, Test164));
  94
  95                         // Multiply()
  96                         AssertEquals ("Test#13", (short)10496, SqlInt16.Multiply (Test64, Test164).Value);
  97                         AssertEquals ("Test#14", (short)0, SqlInt16.Multiply (Test64, Test0).Value);
  98
  99                         try {
 100                                 SqlInt16.Multiply (TestMax, Test64);
 101                                 Fail ("Test#15");
 102                         } catch(Exception e) {
 103                                 AssertEquals ("Test#16", typeof (OverflowException), e.GetType ());
 104                         }
 105
 106                         // Subtract()
 107                         AssertEquals ("Test#17", (short)100, SqlInt16.Subtract (Test164, Test64).Value);
 108
 109                         try {
 110                                 SqlInt16.Subtract (SqlInt16.MinValue, Test164);
 111                                 Fail("Test#18");
 112                         } catch(Exception e) {
 113                                 AssertEquals ("Test#19", typeof (OverflowException), e.GetType ());
 114                         }
 115                 }
 116
 117                 public void TestBitwiseMethods()
 118                 {
 119                         short MaxValue = SqlInt16.MaxValue.Value;
 120                         SqlInt16 TestInt = new SqlInt16 (0);
 121                         SqlInt16 TestIntMax = new SqlInt16 (MaxValue);
 122                         SqlInt16 TestInt2 = new SqlInt16 (10922);
 123                         SqlInt16 TestInt3 = new SqlInt16 (21845);
 124
 125                         // BitwiseAnd
 126                         AssertEquals ("Test#1", (short)21845, SqlInt16.BitwiseAnd (TestInt3, TestIntMax).Value);
 127                         AssertEquals ("Test#2", (short)0, SqlInt16.BitwiseAnd (TestInt2, TestInt3).Value);
 128                         AssertEquals ("Test#3", (short)10922, SqlInt16.BitwiseAnd (TestInt2, TestIntMax).Value);
 129
 130                         //BitwiseOr
 131                         AssertEquals ("Test#4", (short)MaxValue, SqlInt16.BitwiseOr (TestInt2, TestInt3).Value);
 132                         AssertEquals ("Test#5", (short)21845, SqlInt16.BitwiseOr (TestInt, TestInt3).Value);
 133                         AssertEquals ("Test#6", (short)MaxValue, SqlInt16.BitwiseOr (TestIntMax, TestInt2).Value);
 134                 }
 135
 136                 public void TestCompareTo()
 137                 {
 138                         SqlInt16 TestInt4000 = new SqlInt16 (4000);
 139                         SqlInt16 TestInt4000II = new SqlInt16 (4000);
 140                         SqlInt16 TestInt10 = new SqlInt16 (10);
 141                         SqlInt16 TestInt10000 = new SqlInt16 (10000);
 142                         SqlString TestString = new SqlString ("This is a test");
 143
 144                         Assert ("Test#1", TestInt4000.CompareTo (TestInt10) > 0);
 145                         Assert ("Test#2", TestInt10.CompareTo (TestInt4000) < 0);
 146                         Assert ("Test#3", TestInt4000II.CompareTo (TestInt4000) == 0);
 147                         Assert ("Test#4", TestInt4000II.CompareTo (SqlInt16.Null) > 0);
 148
 149                         try {
 150                                 TestInt10.CompareTo (TestString);
 151                                 Fail ("Test#5");
 152                         } catch(Exception e) {
 153                                 AssertEquals ("Test#6", typeof (ArgumentException), e.GetType ());
 154                         }
 155                 }
 156
 157                 public void TestEqualsMethod()
 158                 {
 159                         SqlInt16 Test0 = new SqlInt16 (0);
 160                         SqlInt16 Test158 = new SqlInt16 (158);
 161                         SqlInt16 Test180 = new SqlInt16 (180);
 162                         SqlInt16 Test180II = new SqlInt16 (180);
 163
 164                         Assert ("Test#1", !Test0.Equals (Test158));
 165                         Assert ("Test#2", !Test158.Equals (Test180));
 166                         Assert ("Test#3", !Test180.Equals (new SqlString ("TEST")));
 167                         Assert ("Test#4", Test180.Equals (Test180II));
 168                 }
 169
 170                 public void TestStaticEqualsMethod()
 171                 {
 172                         SqlInt16 Test34 = new SqlInt16 (34);
 173                         SqlInt16 Test34II = new SqlInt16 (34);
 174                         SqlInt16 Test15 = new SqlInt16 (15);
 175
 176                         Assert ("Test#1", SqlInt16.Equals (Test34, Test34II).Value);
 177                         Assert ("Test#2", !SqlInt16.Equals (Test34, Test15).Value);
 178                         Assert ("Test#3", !SqlInt16.Equals (Test15, Test34II).Value);
 179                 }
 180
 181                 public void TestGetHashCode()
 182                 {
 183                         SqlInt16 Test15 = new SqlInt16 (15);
 184
 185                         // FIXME: Better way to test GetHashCode()-methods
 186                         AssertEquals ("Test#1", Test15.GetHashCode (), Test15.GetHashCode ());
 187                 }
 188
 189                 public void TestGetType()
 190                 {
 191                         SqlInt16 Test = new SqlInt16 (84);
 192                         AssertEquals ("Test#1", "System.Data.SqlTypes.SqlInt16", Test.GetType ().ToString ());
 193                 }
 194
 195                 public void TestGreaters()
 196                 {
 197                         SqlInt16 Test10 = new SqlInt16 (10);
 198                         SqlInt16 Test10II = new SqlInt16 (10);
 199                         SqlInt16 Test110 = new SqlInt16 (110);
 200
 201                         // GreateThan ()
 202                         Assert ("Test#1", !SqlInt16.GreaterThan (Test10, Test110).Value);
 203                         Assert ("Test#2", SqlInt16.GreaterThan (Test110, Test10).Value);
 204                         Assert ("Test#3", !SqlInt16.GreaterThan (Test10II, Test10).Value);
 205
 206                         // GreaterTharOrEqual ()
 207                         Assert ("Test#4", !SqlInt16.GreaterThanOrEqual (Test10, Test110).Value);
 208                         Assert ("Test#5", SqlInt16.GreaterThanOrEqual (Test110, Test10).Value);
 209                         Assert ("Test#6", SqlInt16.GreaterThanOrEqual (Test10II, Test10).Value);
 210                 }
 211
 212                 public void TestLessers()
 213                 {
 214                         SqlInt16 Test10 = new SqlInt16 (10);
 215                         SqlInt16 Test10II = new SqlInt16 (10);
 216                         SqlInt16 Test110 = new SqlInt16 (110);
 217
 218                         // LessThan()
 219                         Assert ("Test#1", SqlInt16.LessThan (Test10, Test110).Value);
 220                         Assert ("Test#2", !SqlInt16.LessThan (Test110, Test10).Value);
 221                         Assert ("Test#3", !SqlInt16.LessThan (Test10II, Test10).Value);
 222
 223                         // LessThanOrEqual ()
 224                         Assert ("Test#4", SqlInt16.LessThanOrEqual (Test10, Test110).Value);
 225                         Assert ("Test#5", !SqlInt16.LessThanOrEqual (Test110, Test10).Value);
 226                         Assert ("Test#6", SqlInt16.LessThanOrEqual (Test10II, Test10).Value);
 227                         Assert ("Test#7", SqlInt16.LessThanOrEqual (Test10II, SqlInt16.Null).IsNull);
 228                 }
 229
 230                 public void TestNotEquals()
 231                 {
 232                         SqlInt16 Test12 = new SqlInt16 (12);
 233                         SqlInt16 Test128 = new SqlInt16 (128);
 234                         SqlInt16 Test128II = new SqlInt16 (128);
 235
 236                         Assert ("Test#1", SqlInt16.NotEquals (Test12, Test128).Value);
 237                         Assert ("Test#2", SqlInt16.NotEquals (Test128, Test12).Value);
 238                         Assert ("Test#3", SqlInt16.NotEquals (Test128II, Test12).Value);
 239                         Assert ("Test#4", !SqlInt16.NotEquals (Test128II, Test128).Value);
 240                         Assert ("Test#5", !SqlInt16.NotEquals (Test128, Test128II).Value);
 241                         Assert ("Test#6", SqlInt16.NotEquals (SqlInt16.Null, Test128II).IsNull);
 242                         Assert ("Test#7", SqlInt16.NotEquals (SqlInt16.Null, Test128II).IsNull);
 243                 }
 244
 245                 public void TestOnesComplement()
 246                 {
 247                         SqlInt16 Test12 = new SqlInt16(12);
 248                         SqlInt16 Test128 = new SqlInt16(128);
 249
 250                         AssertEquals ("Test#1", (SqlInt16)(-13), SqlInt16.OnesComplement (Test12));
 251                         AssertEquals ("Test#2", (SqlInt16)(-129), SqlInt16.OnesComplement (Test128));
 252                 }
 253
 254                 public void TestParse()
 255                 {
 256                         try {
 257                                 SqlInt16.Parse (null);
 258                                 Fail ("Test#1");
 259                         } catch (Exception e) {
 260                                 AssertEquals ("Test#2", typeof (ArgumentNullException), e.GetType ());
 261                         }
 262
 263                         try {
 264                                 SqlInt16.Parse ("not-a-number");
 265                                 Fail ("Test#3");
 266                         } catch (Exception e) {
 267                                 AssertEquals ("Test#4", typeof (FormatException), e.GetType ());
 268                         }
 269
 270                         try {
 271                                 int OverInt = (int)SqlInt16.MaxValue + 1;
 272                                 SqlInt16.Parse (OverInt.ToString ());
 273                                 Fail ("Test#5");
 274                         } catch (Exception e) {
 275                                 AssertEquals ("Test#6", typeof (OverflowException), e.GetType ());
 276                         }
 277
 278                         AssertEquals("Test#7", (short)150, SqlInt16.Parse ("150").Value);
 279                 }
 280
 281                 public void TestConversions()
 282                 {
 283                         SqlInt16 Test12 = new SqlInt16 (12);
 284                         SqlInt16 Test0 = new SqlInt16 (0);
 285                         SqlInt16 TestNull = SqlInt16.Null;
 286                         SqlInt16 Test1000 = new SqlInt16 (1000);
 287                         SqlInt16 Test288 = new SqlInt16(288);
 288
 289                         // ToSqlBoolean ()
 290                         Assert ("TestA#1", Test12.ToSqlBoolean ().Value);
 291                         Assert ("TestA#2", !Test0.ToSqlBoolean ().Value);
 292                         Assert ("TestA#3", TestNull.ToSqlBoolean ().IsNull);
 293
 294                         // ToSqlByte ()
 295                         AssertEquals ("TestB#1", (byte)12, Test12.ToSqlByte ().Value);
 296                         AssertEquals ("TestB#2", (byte)0, Test0.ToSqlByte ().Value);
 297
 298                         try {
 299                                 SqlByte b = (byte)Test1000.ToSqlByte ();
 300                                 Fail ("TestB#4");
 301                         } catch (Exception e) {
 302                                 AssertEquals ("TestB#5", typeof (OverflowException), e.GetType ());
 303                         }
 304
 305                         // ToSqlDecimal ()
 306                         AssertEquals ("TestC#1", (decimal)12, Test12.ToSqlDecimal ().Value);
 307                         AssertEquals ("TestC#2", (decimal)0, Test0.ToSqlDecimal ().Value);
 308                         AssertEquals ("TestC#3", (decimal)288, Test288.ToSqlDecimal ().Value);
 309
 310                         // ToSqlDouble ()
 311                         AssertEquals ("TestD#1", (double)12, Test12.ToSqlDouble ().Value);
 312                         AssertEquals ("TestD#2", (double)0, Test0.ToSqlDouble ().Value);
 313                         AssertEquals ("TestD#3", (double)1000, Test1000.ToSqlDouble ().Value);
 314
 315                         // ToSqlInt32 ()
 316                         AssertEquals ("TestE#1", (int)12, Test12.ToSqlInt32 ().Value);
 317                         AssertEquals ("TestE#2", (int)0, Test0.ToSqlInt32 ().Value);
 318                         AssertEquals ("TestE#3", (int)288, Test288.ToSqlInt32().Value);
 319
 320                         // ToSqlInt64 ()
 321                         AssertEquals ("TestF#1", (long)12, Test12.ToSqlInt64 ().Value);
 322                         AssertEquals ("TestF#2", (long)0, Test0.ToSqlInt64 ().Value);
 323                         AssertEquals ("TestF#3", (long)288, Test288.ToSqlInt64 ().Value);
 324
 325                         // ToSqlMoney ()
 326                         AssertEquals ("TestG#1", (decimal)12, Test12.ToSqlMoney ().Value);
 327                         AssertEquals ("TestG#2", (decimal)0, Test0.ToSqlMoney ().Value);
 328                         AssertEquals ("TestG#3", (decimal)288, Test288.ToSqlMoney ().Value);
 329
 330                         // ToSqlSingle ()
 331                         AssertEquals ("TestH#1", (float)12, Test12.ToSqlSingle ().Value);
 332                         AssertEquals ("TestH#2", (float)0, Test0.ToSqlSingle ().Value);
 333                         AssertEquals ("TestH#3", (float)288, Test288.ToSqlSingle().Value);
 334
 335                         // ToSqlString ()
 336                         AssertEquals ("TestI#1", "12", Test12.ToSqlString ().Value);
 337                         AssertEquals ("TestI#2", "0", Test0.ToSqlString ().Value);
 338                         AssertEquals ("TestI#3", "288", Test288.ToSqlString ().Value);
 339
 340                         // ToString ()
 341                         AssertEquals ("TestJ#1", "12", Test12.ToString ());
 342                         AssertEquals ("TestJ#2", "0", Test0.ToString ());
 343                         AssertEquals ("TestJ#3", "288", Test288.ToString ());
 344                 }
 345
 346
 347                 public void TestXor()
 348                 {
 349                         SqlInt16 Test14 = new SqlInt16 (14);
 350                         SqlInt16 Test58 = new SqlInt16 (58);
 351                         SqlInt16 Test130 = new SqlInt16 (130);
 352                         SqlInt16 TestMax = new SqlInt16 (SqlInt16.MaxValue.Value);
 353                         SqlInt16 Test0 = new SqlInt16 (0);
 354
 355                         AssertEquals ("Test#1", (short)52, SqlInt16.Xor (Test14, Test58).Value);
 356                         AssertEquals ("Test#2", (short)140, SqlInt16.Xor (Test14, Test130).Value);
 357                         AssertEquals ("Test#3", (short)184, SqlInt16.Xor (Test58, Test130).Value);
 358                         AssertEquals ("Test#4", (short)0, SqlInt16.Xor (TestMax, TestMax).Value);
 359                         AssertEquals ("Test#5", TestMax.Value, SqlInt16.Xor (TestMax, Test0).Value);
 360                 }
 361
 362                 // OPERATORS
 363
 364                 public void TestArithmeticOperators()
 365                 {
 366                         SqlInt16 Test24 = new SqlInt16 (24);
 367                         SqlInt16 Test64 = new SqlInt16 (64);
 368                         SqlInt16 Test2550 = new SqlInt16 (2550);
 369                         SqlInt16 Test0 = new SqlInt16 (0);
 370
 371                         // "+"-operator
 372                         AssertEquals ("TestA#1", (SqlInt16)2614,Test2550 + Test64);
 373                         try {
 374                                 SqlInt16 result = Test64 + SqlInt16.MaxValue;
 375                                 Fail ("TestA#2");
 376                         } catch (Exception e) {
 377                                 AssertEquals ("TestA#3", typeof (OverflowException), e.GetType ());
 378                         }
 379
 380                         // "/"-operator
 381                         AssertEquals ("TestB#1", (SqlInt16)39, Test2550 / Test64);
 382                         AssertEquals ("TestB#2", (SqlInt16)0, Test24 / Test64);
 383
 384                         try {
 385                                 SqlInt16 result = Test2550 / Test0;
 386                                 Fail ("TestB#3");
 387                         } catch (Exception e) {
 388                                 AssertEquals ("TestB#4", typeof (DivideByZeroException), e.GetType ());
 389                         }
 390
 391                         // "*"-operator
 392                         AssertEquals ("TestC#1", (SqlInt16)1536, Test64 * Test24);
 393
 394                         try {
 395                                 SqlInt16 test = (SqlInt16.MaxValue * Test64);
 396                                 Fail ("TestC#2");
 397                         } catch (Exception e) {
 398                                 AssertEquals ("TestC#3", typeof (OverflowException), e.GetType ());
 399                         }
 400
 401                         // "-"-operator
 402                         AssertEquals ("TestD#1", (SqlInt16)2526, Test2550 - Test24);
 403
 404                         try {
 405                                 SqlInt16 test = SqlInt16.MinValue - Test64;
 406                                 Fail ("TestD#2");
 407                         } catch (Exception e) {
 408                                 AssertEquals ("OverflowException", typeof (OverflowException), e.GetType ());
 409                         }
 410
 411                         // "%"-operator
 412                         AssertEquals ("TestE#1", (SqlInt16)54, Test2550 % Test64);
 413                         AssertEquals ("TestE#2", (SqlInt16)24, Test24 % Test64);
 414                         AssertEquals ("TestE#1", (SqlInt16)0, new SqlInt16 (100) % new SqlInt16 (10));
 415                 }
 416
 417                 public void TestBitwiseOperators()
 418                 {
 419                         SqlInt16 Test2 = new SqlInt16 (2);
 420                         SqlInt16 Test4 = new SqlInt16 (4);
 421                         SqlInt16 Test2550 = new SqlInt16 (2550);
 422
 423                         // & -operator
 424                         AssertEquals ("TestA#1", (SqlInt16)0, Test2 & Test4);
 425                         AssertEquals ("TestA#2", (SqlInt16)2, Test2 & Test2550);
 426                         AssertEquals ("TestA#3", (SqlInt16)0,  SqlInt16.MaxValue & SqlInt16.MinValue);
 427
 428                         // | -operator
 429                         AssertEquals ("TestB#1", (SqlInt16)6,Test2 | Test4);
 430                         AssertEquals ("TestB#2", (SqlInt16)2550, Test2 | Test2550);
 431                         AssertEquals ("TestB#3", (SqlInt16)(-1), SqlInt16.MinValue | SqlInt16.MaxValue);
 432
 433                         //  ^ -operator
 434                         AssertEquals("TestC#1", (SqlInt16)2546, (Test2550 ^ Test4));
 435                         AssertEquals("TestC#2", (SqlInt16)6, (Test2 ^ Test4));
 436                 }
 437
 438                 public void TestThanOrEqualOperators()
 439                 {
 440                         SqlInt16 Test165 = new SqlInt16 (165);
 441                         SqlInt16 Test100 = new SqlInt16 (100);
 442                         SqlInt16 Test100II = new SqlInt16 (100);
 443                         SqlInt16 Test255 = new SqlInt16 (2550);
 444
 445                         // == -operator
 446                         Assert ("TestA#1", (Test100 == Test100II).Value);
 447                         Assert ("TestA#2", !(Test165 == Test100).Value);
 448                         Assert ("TestA#3", (Test165 == SqlInt16.Null).IsNull);
 449
 450                         // != -operator
 451                         Assert ("TestB#1", !(Test100 != Test100II).Value);
 452                         Assert ("TestB#2", (Test100 != Test255).Value);
 453                         Assert ("TestB#3", (Test165 != Test255).Value);
 454                         Assert ("TestB#4", (Test165 != SqlInt16.Null).IsNull);
 455
 456                         // > -operator
 457                         Assert ("TestC#1", (Test165 > Test100).Value);
 458                         Assert ("TestC#2", !(Test165 > Test255).Value);
 459                         Assert ("TestC#3", !(Test100 > Test100II).Value);
 460                         Assert ("TestC#4", (Test165 > SqlInt16.Null).IsNull);
 461
 462                         // >=  -operator
 463                         Assert ("TestD#1", !(Test165 >= Test255).Value);
 464                         Assert ("TestD#2", (Test255 >= Test165).Value);
 465                         Assert ("TestD#3", (Test100 >= Test100II).Value);
 466                         Assert ("TestD#4", (Test165 >= SqlInt16.Null).IsNull);
 467
 468                         // < -operator
 469                         Assert ("TestE#1", !(Test165 < Test100).Value);
 470                         Assert ("TestE#2", (Test165 < Test255).Value);
 471                         Assert ("TestE#3", !(Test100 < Test100II).Value);
 472                         Assert ("TestE#4", (Test165 < SqlInt16.Null).IsNull);
 473
 474                         // <= -operator
 475                         Assert ("TestF#1", (Test165 <= Test255).Value);
 476                         Assert ("TestF#2", !(Test255 <= Test165).Value);
 477                         Assert ("TestF#3", (Test100 <= Test100II).Value);
 478                         Assert ("TestF#4", (Test165 <= SqlInt16.Null).IsNull);
 479                 }
 480
 481                 public void TestOnesComplementOperator()
 482                 {
 483                         SqlInt16 Test12 = new SqlInt16 (12);
 484                         SqlInt16 Test128 = new SqlInt16 (128);
 485
 486                         AssertEquals ("Test#1", (SqlInt16)(-13), ~Test12);
 487                         AssertEquals ("Test#2", (SqlInt16)(-129), ~Test128);
 488                         AssertEquals ("Test#3", SqlInt16.Null, ~SqlInt16.Null);
 489                 }
 490
 491                 public void TestUnaryNegation()
 492                 {
 493                         SqlInt16 Test = new SqlInt16 (2000);
 494                         SqlInt16 TestNeg = new SqlInt16 (-3000);
 495
 496                         SqlInt16 Result = -Test;
 497                         AssertEquals ("Test#1", (short)(-2000), Result.Value);
 498
 499                         Result = -TestNeg;
 500                         AssertEquals ("Test#2", (short)3000, Result.Value);
 501                 }
 502
 503                 public void TestSqlBooleanToSqlInt16()
 504                 {
 505                         SqlBoolean TestBoolean = new SqlBoolean (true);
 506                         SqlInt16 Result;
 507
 508                         Result = (SqlInt16)TestBoolean;
 509
 510                         AssertEquals ("Test#1", (short)1, Result.Value);
 511
 512                         Result = (SqlInt16)SqlBoolean.Null;
 513                         Assert ("Test#2", Result.IsNull);
 514                 }
 515
 516                 public void TestSqlDecimalToSqlInt16()
 517                 {
 518                         SqlDecimal TestDecimal64 = new SqlDecimal (64);
 519                         SqlDecimal TestDecimal900 = new SqlDecimal (90000);
 520
 521                         AssertEquals ("Test#1", (short)64, ((SqlInt16)TestDecimal64).Value);
 522                         AssertEquals ("Test#2", SqlInt16.Null, ((SqlInt16)SqlDecimal.Null));
 523
 524                         try {
 525                                 SqlInt16 test = (SqlInt16)TestDecimal900;
 526                                 Fail ("Test#3");
 527                         } catch (Exception e) {
 528                                 AssertEquals("Test#4", typeof(OverflowException), e.GetType ());
 529                         }
 530                 }
 531
 532                 public void TestSqlDoubleToSqlInt16()
 533                 {
 534                         SqlDouble TestDouble64 = new SqlDouble (64);
 535                         SqlDouble TestDouble900 = new SqlDouble (90000);
 536
 537                         AssertEquals ("Test#1", (short)64, ((SqlInt16)TestDouble64).Value);
 538                         AssertEquals ("Test#2", SqlInt16.Null, ((SqlInt16)SqlDouble.Null));
 539
 540                         try {
 541                                 SqlInt16 test = (SqlInt16)TestDouble900;
 542                                 Fail ("Test#3");
 543                         } catch (Exception e) {
 544                                 AssertEquals("Test#4", typeof (OverflowException), e.GetType ());
 545                         }
 546                 }
 547
 548                 public void TestSqlIntToInt16()
 549                 {
 550                         SqlInt16 Test = new SqlInt16(12);
 551                         Int16 Result = (Int16)Test;
 552                         AssertEquals("Test#1", (short)12, Result);
 553                 }
 554
 555                 public void TestSqlInt32ToSqlInt16()
 556                 {
 557                         SqlInt32 Test64 = new SqlInt32 (64);
 558                         SqlInt32 Test900 = new SqlInt32 (90000);
 559
 560                         AssertEquals ("Test#1", (short)64, ((SqlInt16)Test64).Value);
 561
 562                         try {
 563                                 SqlInt16 test = (SqlInt16)Test900;
 564                                 Fail ("Test#2");
 565                         } catch (Exception e) {
 566                                 AssertEquals ("Test#3", typeof (OverflowException), e.GetType ());
 567                         }
 568                 }
 569
 570                 public void TestSqlInt64ToSqlInt16()
 571                 {
 572                         SqlInt64 Test64 = new SqlInt64 (64);
 573                         SqlInt64 Test900 = new SqlInt64 (90000);
 574
 575                         AssertEquals ("Test#1", (short)64, ((SqlInt16)Test64).Value);
 576
 577                         try {
 578                                 SqlInt16 test = (SqlInt16)Test900;
 579                                 Fail ("Test#2");
 580                         } catch (Exception e) {
 581                                 AssertEquals("Test#3", typeof (OverflowException), e.GetType ());
 582                         }
 583                 }
 584
 585                 public void TestSqlMoneyToSqlInt16()
 586                 {
 587                         SqlMoney TestMoney64 = new SqlMoney(64);
 588                         SqlMoney TestMoney900 = new SqlMoney(90000);
 589
 590                         AssertEquals ("Test#1", (short)64, ((SqlInt16)TestMoney64).Value);
 591
 592                         try {
 593                                 SqlInt16 test = (SqlInt16)TestMoney900;
 594                                 Fail ("Test#2");
 595                         } catch (Exception e) {
 596                                 AssertEquals("test#3", typeof (OverflowException), e.GetType ());
 597                         }
 598                 }
 599
 600                 public void TestSqlSingleToSqlInt16()
 601                 {
 602                         SqlSingle TestSingle64 = new SqlSingle(64);
 603                         SqlSingle TestSingle900 = new SqlSingle(90000);
 604
 605                         AssertEquals("Test#1", (short)64, ((SqlInt16)TestSingle64).Value);
 606
 607                         try {
 608                                 SqlInt16 test = (SqlInt16)TestSingle900;
 609                                 Fail ("Test#2");
 610                         } catch (Exception e) {
 611                                 AssertEquals ("Test#3", typeof (OverflowException), e.GetType ());
 612                         }
 613                 }
 614
 615                 public void TestSqlStringToSqlInt16()
 616                 {
 617                         SqlString TestString = new SqlString("Test string");
 618                         SqlString TestString100 = new SqlString("100");
 619                         SqlString TestString1000 = new SqlString("100000");
 620
 621                         AssertEquals ("Test#1", (short)100, ((SqlInt16)TestString100).Value);
 622
 623                         try {
 624                                 SqlInt16 test = (SqlInt16)TestString1000;
 625                                 Fail ("Test#2");
 626                         } catch(Exception e) {
 627                                 AssertEquals ("Test#3", typeof (OverflowException), e.GetType ());
 628                         }
 629
 630                         try {
 631                                 SqlInt16 test = (SqlInt16)TestString;
 632                                 Fail ("Test#3");
 633                         } catch(Exception e) {
 634                                 AssertEquals ("Test#4", typeof (FormatException), e.GetType ());
 635                         }
 636                 }
 637
 638                 public void TestByteToSqlInt16()
 639                 {
 640                         short TestShort = 14;
 641                         AssertEquals ("Test#1", (short)14, ((SqlInt16)TestShort).Value);
 642                 }
 643         }
 644 }
 645