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