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

   1 //
   2 // SqlDoubleTest.cs - NUnit Test Cases for System.Data.SqlTypes.SqlDouble
   3 //
   4 // Authors:
   5 //   Ville Palo (vi64pa@koti.soon.fi)
   6 //   Martin Willemoes Hansen (mwh@sysrq.dk)
   7 //
   8 // (C) 2002 Ville Palo
   9 // (C) 2003 Martin Willemoes Hansen
  10 //
  11
  12 //
  13 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  14 //
  15 // Permission is hereby granted, free of charge, to any person obtaining
  16 // a copy of this software and associated documentation files (the
  17 // "Software"), to deal in the Software without restriction, including
  18 // without limitation the rights to use, copy, modify, merge, publish,
  19 // distribute, sublicense, and/or sell copies of the Software, and to
  20 // permit persons to whom the Software is furnished to do so, subject to
  21 // the following conditions:
  22 //
  23 // The above copyright notice and this permission notice shall be
  24 // included in all copies or substantial portions of the Software.
  25 //
  26 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  30 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  31 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  32 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  33 //
  34
  35 using NUnit.Framework;
  36 using System;
  37 using System.Data.SqlTypes;
  38 using System.Threading;
  39 using System.Globalization;
  40
  41 namespace MonoTests.System.Data.SqlTypes
  42 {
  43         [TestFixture]
  44         public class SqlDoubleTest
  45         {
  46
  47                 [SetUp]
  48                 public void SetUp ()
  49                 {
  50                       Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
  51                 }
  52                 // Test constructor
  53                 [Test]
  54                 public void Create()
  55                 {
  56                         SqlDouble Test= new SqlDouble ((double)34.87);
  57                         Assert.AreEqual (34.87D, Test.Value, "#A01");
  58
  59                         Test = new SqlDouble (-9000.6543);
  60                         Assert.AreEqual (-9000.6543D, Test.Value, "#A02");
  61                 }
  62
  63                 // Test public fields
  64                 [Test]
  65                 public void PublicFields()
  66                 {
  67                         Assert.AreEqual (1.7976931348623157e+308, SqlDouble.MaxValue.Value, "#B01");
  68                         Assert.AreEqual (-1.7976931348623157e+308, SqlDouble.MinValue.Value, "#B02");
  69                         Assert.IsTrue (SqlDouble.Null.IsNull, "#B03");
  70                         Assert.AreEqual (0d, SqlDouble.Zero.Value, "#B04");
  71                 }
  72
  73                 // Test properties
  74                 [Test]
  75                 public void Properties()
  76                 {
  77                         SqlDouble Test5443 = new SqlDouble (5443e12);
  78                         SqlDouble Test1 = new SqlDouble (1);
  79
  80                         Assert.IsTrue (SqlDouble.Null.IsNull, "#C01");
  81                         Assert.AreEqual (5443e12, Test5443.Value, "#C02");
  82                         Assert.AreEqual ((double)1, Test1.Value, "#C03");
  83                 }
  84
  85                 // PUBLIC METHODS
  86
  87                 [Test]
  88                 public void ArithmeticMethods()
  89                 {
  90                         SqlDouble Test0 = new SqlDouble (0);
  91                         SqlDouble Test1 = new SqlDouble (15E+108);
  92                         SqlDouble Test2 = new SqlDouble (-65E+64);
  93                         SqlDouble Test3 = new SqlDouble (5E+64);
  94                         SqlDouble Test4 = new SqlDouble (5E+108);
  95                         SqlDouble TestMax = new SqlDouble (SqlDouble.MaxValue.Value);
  96
  97                         // Add()
  98                         Assert.AreEqual (15E+108, SqlDouble.Add (Test1, Test0).Value, "#D01A");
  99                         Assert.AreEqual (1.5E+109, SqlDouble.Add (Test1, Test2).Value, "#D02A");
 100
 101                         try {
 102                                 SqlDouble test = SqlDouble.Add (SqlDouble.MaxValue, SqlDouble.MaxValue);
 103                                 Assert.Fail ("#D03A");
 104                         } catch (Exception e) {
 105                                 Assert.AreEqual (typeof (OverflowException), e.GetType (), "#D04A");
 106                         }
 107
 108                         // Divide()
 109                         Assert.AreEqual ((SqlDouble)3, SqlDouble.Divide (Test1, Test4), "#D01B");
 110                         Assert.AreEqual (-13d, SqlDouble.Divide (Test2, Test3).Value, "#D02B");
 111
 112                         try {
 113                                 SqlDouble test = SqlDouble.Divide(Test1, Test0).Value;
 114                                 Assert.Fail ("#D03B");
 115                         } catch(Exception e) {
 116                                 Assert.AreEqual (typeof (DivideByZeroException), e.GetType (), "#D04B");
 117                         }
 118
 119                         // Multiply()
 120                         Assert.AreEqual ((double)(75E+216), SqlDouble.Multiply (Test1, Test4).Value, "#D01D");
 121                         Assert.AreEqual ((double)0, SqlDouble.Multiply (Test1, Test0).Value, "#D02D");
 122
 123                         try {
 124                                 SqlDouble test = SqlDouble.Multiply (TestMax, Test1);
 125                                 Assert.Fail ("#D03D");
 126                         } catch (Exception e) {
 127                                 Assert.AreEqual (typeof (OverflowException), e.GetType (), "#D04D");
 128                         }
 129
 130
 131                         // Subtract()
 132                         Assert.AreEqual ((double)1.5E+109, SqlDouble.Subtract (Test1, Test3).Value, "#D01F");
 133
 134                         try {
 135                                 SqlDouble test = SqlDouble.Subtract(SqlDouble.MinValue, SqlDouble.MaxValue);
 136                                 Assert.Fail ("D02F");
 137                         } catch (Exception e) {
 138                                 Assert.AreEqual (typeof (OverflowException), e.GetType (), "#D03F");
 139                         }
 140                 }
 141
 142                 [Test]
 143                 public void CompareTo()
 144                 {
 145                         SqlDouble Test1 = new SqlDouble (4e64);
 146                         SqlDouble Test11 = new SqlDouble (4e64);
 147                         SqlDouble Test2 = new SqlDouble (-9e34);
 148                         SqlDouble Test3 = new SqlDouble (10000);
 149                         SqlString TestString = new SqlString ("This is a test");
 150
 151                         Assert.IsTrue (Test1.CompareTo (Test3) > 0, "#E01");
 152                         Assert.IsTrue (Test2.CompareTo (Test3) < 0, "#E02");
 153                         Assert.IsTrue (Test1.CompareTo (Test11) == 0, "#E03");
 154                         Assert.IsTrue (Test11.CompareTo (SqlDouble.Null) > 0, "#E04");
 155
 156                         try {
 157                                 Test1.CompareTo (TestString);
 158                                 Assert.Fail("#E05");
 159                         } catch(Exception e) {
 160                                 Assert.AreEqual (typeof (ArgumentException), e.GetType (), "#E06");
 161                         }
 162                 }
 163
 164                 [Test]
 165                 public void EqualsMethods()
 166                 {
 167                         SqlDouble Test0 = new SqlDouble (0);
 168                         SqlDouble Test1 = new SqlDouble (1.58e30);
 169                         SqlDouble Test2 = new SqlDouble (1.8e180);
 170                         SqlDouble Test22 = new SqlDouble (1.8e180);
 171
 172                         Assert.IsTrue (!Test0.Equals (Test1), "#F01");
 173                         Assert.IsTrue (!Test1.Equals (Test2), "#F02");
 174                         Assert.IsTrue (!Test2.Equals (new SqlString ("TEST")), "#F03");
 175                         Assert.IsTrue (Test2.Equals (Test22), "#F04");
 176
 177                         // Static Equals()-method
 178                         Assert.IsTrue (SqlDouble.Equals (Test2, Test22).Value, "#F05");
 179                         Assert.IsTrue (!SqlDouble.Equals (Test1, Test2).Value, "#F06");
 180                 }
 181
 182                 [Test]
 183                 public void GetHashCodeTest()
 184                 {
 185                         SqlDouble Test15 = new SqlDouble (15);
 186
 187                         // FIXME: Better way to test HashCode
 188                         Assert.AreEqual (Test15.GetHashCode (), Test15.GetHashCode (), "#G01");
 189                 }
 190
 191                 [Test]
 192                 public void GetTypeTest()
 193                 {
 194                         SqlDouble Test = new SqlDouble (84);
 195                         Assert.AreEqual ("System.Data.SqlTypes.SqlDouble", Test.GetType ().ToString (), "#H01");
 196                         Assert.AreEqual ("System.Double", Test.Value.GetType ().ToString (), "#H02");
 197                 }
 198
 199                 [Test]
 200                 public void Greaters()
 201                 {
 202                         SqlDouble Test1 = new SqlDouble (1e100);
 203                         SqlDouble Test11 = new SqlDouble (1e100);
 204                         SqlDouble Test2 = new SqlDouble (64e164);
 205
 206                         // GreateThan ()
 207                         Assert.IsTrue (!SqlDouble.GreaterThan (Test1, Test2).Value, "#I01");
 208                         Assert.IsTrue (SqlDouble.GreaterThan (Test2, Test1).Value, "#I02");
 209                         Assert.IsTrue (!SqlDouble.GreaterThan (Test1, Test11).Value, "#I03");
 210
 211                         // GreaterTharOrEqual ()
 212                         Assert.IsTrue (!SqlDouble.GreaterThanOrEqual (Test1, Test2).Value, "#I04");
 213                         Assert.IsTrue (SqlDouble.GreaterThanOrEqual (Test2, Test1).Value, "#I05");
 214                         Assert.IsTrue (SqlDouble.GreaterThanOrEqual (Test1, Test11).Value, "#I06");
 215                 }
 216
 217                 [Test]
 218                 public void Lessers()
 219                 {
 220                         SqlDouble Test1 = new SqlDouble (1.8e100);
 221                         SqlDouble Test11 = new SqlDouble (1.8e100);
 222                         SqlDouble Test2 = new SqlDouble (64e164);
 223
 224                         // LessThan()
 225                         Assert.IsTrue (!SqlDouble.LessThan (Test1, Test11).Value, "#J01");
 226                         Assert.IsTrue (!SqlDouble.LessThan (Test2, Test1).Value, "#J02");
 227                         Assert.IsTrue (SqlDouble.LessThan (Test11, Test2).Value, "#J03");
 228
 229                         // LessThanOrEqual ()
 230                         Assert.IsTrue (SqlDouble.LessThanOrEqual (Test1, Test2).Value, "#J04");
 231                         Assert.IsTrue (!SqlDouble.LessThanOrEqual (Test2, Test1).Value, "#J05");
 232                         Assert.IsTrue (SqlDouble.LessThanOrEqual (Test11, Test1).Value, "#J06");
 233                         Assert.IsTrue (SqlDouble.LessThanOrEqual (Test11, SqlDouble.Null).IsNull, "#J07");
 234                 }
 235
 236                 [Test]
 237                 public void NotEquals()
 238                 {
 239                         SqlDouble Test1 = new SqlDouble (1280000000001);
 240                         SqlDouble Test2 = new SqlDouble (128e10);
 241                         SqlDouble Test22 = new SqlDouble (128e10);
 242
 243                         Assert.IsTrue (SqlDouble.NotEquals (Test1, Test2).Value, "#K01");
 244                         Assert.IsTrue (SqlDouble.NotEquals (Test2, Test1).Value, "#K02");
 245                         Assert.IsTrue (SqlDouble.NotEquals (Test22, Test1).Value, "#K03");
 246                         Assert.IsTrue (!SqlDouble.NotEquals (Test22, Test2).Value, "#K04");
 247                         Assert.IsTrue (!SqlDouble.NotEquals (Test2, Test22).Value, "#K05");
 248                         Assert.IsTrue (SqlDouble.NotEquals (SqlDouble.Null, Test22).IsNull, "#K06");
 249                         Assert.IsTrue (SqlDouble.NotEquals (SqlDouble.Null, Test22).IsNull, "#K07");
 250                 }
 251
 252                 [Test]
 253                 public void Parse()
 254                 {
 255                         try {
 256                                 SqlDouble.Parse (null);
 257                                 Assert.Fail ("#L01");
 258                         } catch (Exception e) {
 259                                 Assert.AreEqual (typeof (ArgumentNullException), e.GetType (), "#L02");
 260                         }
 261
 262                         try {
 263                                 SqlDouble.Parse ("not-a-number");
 264                                 Assert.Fail ("#L03");
 265                         } catch (Exception e) {
 266
 267                                 Assert.AreEqual (typeof (FormatException), e.GetType (), "#L04");
 268                         }
 269
 270                          try {
 271                                 SqlDouble.Parse ("9e400");
 272                                 Assert.Fail ("#L05");
 273                         } catch (Exception e) {
 274                                 Assert.AreEqual (typeof (OverflowException), e.GetType (), "#L06");
 275                         }
 276
 277                         Assert.AreEqual((double)150, SqlDouble.Parse ("150").Value, "#L07");
 278                 }
 279
 280                 [Test]
 281                 public void Conversions()
 282                 {
 283                         SqlDouble Test0 = new SqlDouble (0);
 284                         SqlDouble Test1 = new SqlDouble (250);
 285                         SqlDouble Test2 = new SqlDouble (64e64);
 286                         SqlDouble Test3 = new SqlDouble (64e164);
 287                         SqlDouble TestNull = SqlDouble.Null;
 288
 289                         // ToSqlBoolean ()
 290                         Assert.IsTrue (Test1.ToSqlBoolean ().Value, "#M01A");
 291                         Assert.IsTrue (!Test0.ToSqlBoolean ().Value, "#M02A");
 292                         Assert.IsTrue (TestNull.ToSqlBoolean ().IsNull, "#M03A");
 293
 294                         // ToSqlByte ()
 295                         Assert.AreEqual ((byte)250, Test1.ToSqlByte ().Value, "#M01B");
 296                         Assert.AreEqual ((byte)0, Test0.ToSqlByte ().Value, "#M02B");
 297
 298                         try {
 299                                 SqlByte b = (byte)Test2.ToSqlByte ();
 300                                 Assert.Fail ("#M03B");
 301                         } catch (Exception e) {
 302                                 Assert.AreEqual (typeof (OverflowException), e.GetType (), "#M04B");
 303                         }
 304
 305                         // ToSqlDecimal ()
 306                         Assert.AreEqual (250.00000000000000M, Test1.ToSqlDecimal ().Value, "#M01C");
 307                         Assert.AreEqual ((decimal)0, Test0.ToSqlDecimal ().Value, "#M02C");
 308
 309                         try {
 310                                 SqlDecimal test = Test3.ToSqlDecimal ().Value;
 311                                 Assert.Fail ("#M03C");
 312                         } catch (Exception e) {
 313                                 Assert.AreEqual (typeof (OverflowException), e.GetType (), "#M04C");
 314                         }
 315
 316                         // ToSqlInt16 ()
 317                         Assert.AreEqual ((short)250, Test1.ToSqlInt16 ().Value, "#M01D");
 318                         Assert.AreEqual ((short)0, Test0.ToSqlInt16 ().Value, "#M02D");
 319
 320                         try {
 321                                 SqlInt16 test = Test2.ToSqlInt16().Value;
 322                                 Assert.Fail ("#M03D");
 323                         } catch (Exception e) {
 324                                 Assert.AreEqual (typeof (OverflowException), e.GetType (), "#M04D");
 325                         }
 326
 327                         // ToSqlInt32 ()
 328                         Assert.AreEqual ((int)250, Test1.ToSqlInt32 ().Value, "#M01E");
 329                         Assert.AreEqual ((int)0, Test0.ToSqlInt32 ().Value, "#M02E");
 330
 331                         try {
 332                                 SqlInt32 test = Test2.ToSqlInt32 ().Value;
 333                                 Assert.Fail ("#M03E");
 334                         } catch (Exception e) {
 335                                 Assert.AreEqual (typeof (OverflowException), e.GetType (), "#M04E");
 336                         }
 337
 338                         // ToSqlInt64 ()
 339                         Assert.AreEqual ((long)250, Test1.ToSqlInt64 ().Value, "#M01F");
 340                         Assert.AreEqual ((long)0, Test0.ToSqlInt64 ().Value, "#M02F");
 341
 342                         try {
 343                                 SqlInt64 test = Test2.ToSqlInt64 ().Value;
 344                                 Assert.Fail ("#M03F");
 345                         } catch (Exception e) {
 346                                 Assert.AreEqual (typeof (OverflowException), e.GetType (), "#M04F");
 347                         }
 348
 349                         // ToSqlMoney ()
 350                         Assert.AreEqual (250.0000M, Test1.ToSqlMoney ().Value, "#M01G");
 351                         Assert.AreEqual ((decimal)0, Test0.ToSqlMoney ().Value, "#M02G");
 352
 353                         try {
 354                                 SqlMoney test = Test2.ToSqlMoney ().Value;
 355                                 Assert.Fail ("#M03G");
 356                         } catch (Exception e) {
 357                                 Assert.AreEqual (typeof (OverflowException), e.GetType (), "#M04G");
 358                         }
 359
 360                         // ToSqlSingle ()
 361                         Assert.AreEqual ((float)250, Test1.ToSqlSingle ().Value, "#M01H");
 362                         Assert.AreEqual ((float)0, Test0.ToSqlSingle ().Value, "#M02H");
 363
 364                         try {
 365                                 SqlSingle test = Test2.ToSqlSingle().Value;
 366                                 Assert.Fail ("#MO3H");
 367                         } catch (Exception e) {
 368                                 Assert.AreEqual (typeof (OverflowException), e.GetType (), "#M04H");
 369                         }
 370
 371                         // ToSqlString ()
 372                         Assert.AreEqual ("250", Test1.ToSqlString ().Value, "#M01I");
 373                         Assert.AreEqual ("0", Test0.ToSqlString ().Value, "#M02I");
 374                         Assert.AreEqual ("6.4E+65", Test2.ToSqlString ().Value, "#M03I");
 375
 376                         // ToString ()
 377                         Assert.AreEqual ("250", Test1.ToString (), "#M01J");
 378                         Assert.AreEqual ("0", Test0.ToString (), "#M02J");
 379                         Assert.AreEqual ("6.4E+65", Test2.ToString (), "#M03J");
 380                 }
 381
 382                 // OPERATORS
 383
 384                 [Test]
 385                 public void ArithmeticOperators()
 386                 {
 387                         SqlDouble Test0 = new SqlDouble (0);
 388                         SqlDouble Test1 = new SqlDouble (24E+100);
 389                         SqlDouble Test2 = new SqlDouble (64E+164);
 390                         SqlDouble Test3 = new SqlDouble (12E+100);
 391                         SqlDouble Test4 = new SqlDouble (1E+10);
 392                         SqlDouble Test5 = new SqlDouble (2E+10);
 393
 394                         // "+"-operator
 395                         Assert.AreEqual ((SqlDouble)3E+10, Test4 + Test5, "#N01");
 396
 397                         try {
 398                                 SqlDouble test = SqlDouble.MaxValue + SqlDouble.MaxValue;
 399                                 Assert.Fail ("#N02");
 400                         } catch (Exception e) {
 401                                 Assert.AreEqual (typeof (OverflowException), e.GetType (), "#N03");
 402                         }
 403
 404                         // "/"-operator
 405                         Assert.AreEqual ((SqlDouble)2, Test1 / Test3, "#N04");
 406
 407                         try {
 408                                 SqlDouble test = Test3 / Test0;
 409                                 Assert.Fail ("#N05");
 410                         } catch (Exception e) {
 411                                 Assert.AreEqual (typeof (DivideByZeroException), e.GetType (), "#N06");
 412                         }
 413
 414                         // "*"-operator
 415                         Assert.AreEqual ((SqlDouble)2e20, Test4 * Test5, "#N07");
 416
 417                         try {
 418                                 SqlDouble test = SqlDouble.MaxValue * Test1;
 419                                 Assert.Fail ("#N08");
 420                         } catch (Exception e) {
 421                                 Assert.AreEqual (typeof (OverflowException), e.GetType (), "#N09");
 422                         }
 423
 424                         // "-"-operator
 425                         Assert.AreEqual ((SqlDouble)12e100, Test1 - Test3, "#N10");
 426
 427                         try {
 428                                 SqlDouble test = SqlDouble.MinValue - SqlDouble.MaxValue;
 429                                 Assert.Fail ("#N11");
 430                         } catch  (Exception e) {
 431                                 Assert.AreEqual (typeof (OverflowException), e.GetType (), "#N12");
 432                         }
 433                 }
 434
 435                 [Test]
 436                 public void ThanOrEqualOperators()
 437                 {
 438                         SqlDouble Test1 = new SqlDouble (1E+164);
 439                         SqlDouble Test2 = new SqlDouble (9.7E+100);
 440                         SqlDouble Test22 = new SqlDouble (9.7E+100);
 441                         SqlDouble Test3 = new SqlDouble (2E+200);
 442
 443                         // == -operator
 444                         Assert.IsTrue ((Test2 == Test22).Value, "#O01");
 445                         Assert.IsTrue (!(Test1 == Test2).Value, "#O02");
 446                         Assert.IsTrue ((Test1 == SqlDouble.Null).IsNull, "#O03");
 447
 448                         // != -operator
 449                         Assert.IsTrue (!(Test2 != Test22).Value, "#O04");
 450                         Assert.IsTrue ((Test2 != Test3).Value, "#O05");
 451                         Assert.IsTrue ((Test1 != Test3).Value, "#O06");
 452                         Assert.IsTrue ((Test1 != SqlDouble.Null).IsNull, "#O07");
 453
 454                         // > -operator
 455                         Assert.IsTrue ((Test1 > Test2).Value, "#O08");
 456                         Assert.IsTrue (!(Test1 > Test3).Value, "#O09");
 457                         Assert.IsTrue (!(Test2 > Test22).Value, "#O10");
 458                         Assert.IsTrue ((Test1 > SqlDouble.Null).IsNull, "#O11");
 459
 460                         // >=  -operator
 461                         Assert.IsTrue (!(Test1 >= Test3).Value, "#O12");
 462                         Assert.IsTrue ((Test3 >= Test1).Value, "#O13");
 463                         Assert.IsTrue ((Test2 >= Test22).Value, "#O14");
 464                         Assert.IsTrue ((Test1 >= SqlDouble.Null).IsNull, "#O15");
 465
 466                         // < -operator
 467                         Assert.IsTrue (!(Test1 < Test2).Value, "#O16");
 468                         Assert.IsTrue ((Test1 < Test3).Value, "#O17");
 469                         Assert.IsTrue (!(Test2 < Test22).Value, "#O18");
 470                         Assert.IsTrue ((Test1 < SqlDouble.Null).IsNull, "#O19");
 471
 472                         // <= -operator
 473                         Assert.IsTrue ((Test1 <= Test3).Value, "#O20");
 474                         Assert.IsTrue (!(Test3 <= Test1).Value, "#O21");
 475                         Assert.IsTrue ((Test2 <= Test22).Value, "#O22");
 476                         Assert.IsTrue ((Test1 <= SqlDouble.Null).IsNull, "#O23");
 477                 }
 478
 479                 [Test]
 480                 public void UnaryNegation()
 481                 {
 482                         SqlDouble Test = new SqlDouble (2000000001);
 483                         SqlDouble TestNeg = new SqlDouble (-3000);
 484
 485                         SqlDouble Result = -Test;
 486                         Assert.AreEqual ((double)(-2000000001), Result.Value, "#P01");
 487
 488                         Result = -TestNeg;
 489                         Assert.AreEqual ((double)3000, Result.Value, "#P02");
 490                 }
 491
 492                 [Test]
 493                 public void SqlBooleanToSqlDouble()
 494                 {
 495                         SqlBoolean TestBoolean = new SqlBoolean (true);
 496                         SqlDouble Result;
 497
 498                         Result = (SqlDouble)TestBoolean;
 499
 500                         Assert.AreEqual ((double)1, Result.Value, "#Q01");
 501
 502                         Result = (SqlDouble)SqlBoolean.Null;
 503                         Assert.IsTrue (Result.IsNull, "#Q02");
 504                 }
 505
 506                 [Test]
 507                 public void SqlDoubleToDouble()
 508                 {
 509                         SqlDouble Test = new SqlDouble (12e12);
 510                         Double Result = (double)Test;
 511                         Assert.AreEqual (12e12, Result, "#R01");
 512                 }
 513
 514                 [Test]
 515                 public void SqlStringToSqlDouble()
 516                 {
 517                         SqlString TestString = new SqlString ("Test string");
 518                         SqlString TestString100 = new SqlString ("100");
 519
 520                         Assert.AreEqual ((double)100, ((SqlDouble)TestString100).Value, "#S01");
 521
 522                         try {
 523                                 SqlDouble test = (SqlDouble)TestString;
 524                                 Assert.Fail ("#S02");
 525                         } catch(Exception e) {
 526                                 Assert.AreEqual (typeof (FormatException), e.GetType (), "#S03");
 527                         }
 528                 }
 529
 530                 [Test]
 531                 public void DoubleToSqlDouble()
 532                 {
 533                         double Test1 = 5e64;
 534                         SqlDouble Result = (SqlDouble)Test1;
 535                         Assert.AreEqual (5e64, Result.Value, "#T01");
 536                 }
 537
 538                 [Test]
 539                 public void ByteToSqlDouble()
 540                 {
 541                         short TestShort = 14;
 542                         Assert.AreEqual ((double)14, ((SqlDouble)TestShort).Value, "#U01");
 543                 }
 544
 545                 [Test]
 546                 public void SqlDecimalToSqlDouble()
 547                 {
 548                         SqlDecimal TestDecimal64 = new SqlDecimal (64);
 549
 550                         Assert.AreEqual ((double)64, ((SqlDouble)TestDecimal64).Value, "#V01");
 551                         Assert.AreEqual (SqlDouble.Null, ((SqlDouble)SqlDecimal.Null), "#V02");
 552                 }
 553
 554                 [Test]
 555                 public void SqlIntToSqlDouble()
 556                 {
 557                         SqlInt16 Test64 = new SqlInt16 (64);
 558                         SqlInt32 Test640 = new SqlInt32 (640);
 559                         SqlInt64 Test64000 = new SqlInt64 (64000);
 560                         Assert.AreEqual ((double)64, ((SqlDouble)Test64).Value, "#W01");
 561                         Assert.AreEqual ((double)640, ((SqlDouble)Test640).Value, "#W02");
 562                         Assert.AreEqual ((double)64000, ((SqlDouble)Test64000).Value, "#W03");
 563                 }
 564
 565                 [Test]
 566                 public void SqlMoneyToSqlDouble()
 567                 {
 568                         SqlMoney TestMoney64 = new SqlMoney(64);
 569                         Assert.AreEqual ((double)64, ((SqlDouble)TestMoney64).Value, "#X01");
 570                 }
 571
 572                 [Test]
 573                 public void SqlSingleToSqlDouble()
 574                 {
 575                         SqlSingle TestSingle64 = new SqlSingle (64);
 576                         Assert.AreEqual ((double)64, ((SqlDouble)TestSingle64).Value, "#Y01");
 577                 }
 578         }
 579 }
 580