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

   1 //
   2 // SqlDecimalTest.cs - NUnit Test Cases for System.Data.SqlTypes.SqlDecimal
   3 //
   4 // Authors:
   5 //   Ville Palo (vi64pa@koti.soon.fi)
   6 //   Martin Willemoes Hansen
   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 SqlDecimalTest : Assertion {
  45
  46                 private SqlDecimal Test1;
  47                 private SqlDecimal Test2;
  48                 private SqlDecimal Test3;
  49                 private SqlDecimal Test4;
  50
  51                 [SetUp]
  52                 public void GetReady()
  53                 {
  54                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
  55                         Test1 = new SqlDecimal (6464.6464m);
  56                         Test2 = new SqlDecimal (10000.00m);
  57                         Test3 = new SqlDecimal (10000.00m);
  58                         Test4 = new SqlDecimal (-6m);
  59                 }
  60
  61                 // Test constructor
  62                 [Test]
  63                 public void Create()
  64                 {
  65                         // SqlDecimal (decimal)
  66                         SqlDecimal Test = new SqlDecimal (30.3098m);
  67                         AssertEquals ("#A01", (decimal)30.3098, Test.Value);
  68
  69                         try {
  70                                 SqlDecimal test = new SqlDecimal (Decimal.MaxValue + 1);
  71                                 Fail ("#A02");
  72                         } catch (Exception e) {
  73                                 AssertEquals ("#A03", typeof (OverflowException), e.GetType ());
  74                         }
  75
  76                         // SqlDecimal (double)
  77                         Test = new SqlDecimal (10E+10d);
  78                         AssertEquals ("#A05", 100000000000.00000m, Test.Value);
  79
  80                         try {
  81                                 SqlDecimal test = new SqlDecimal (10E+200d);
  82                                 Fail ("#A06");
  83                         } catch (Exception e) {
  84                                 AssertEquals ("#A07", typeof (OverflowException), e.GetType ());
  85                         }
  86
  87                         // SqlDecimal (int)
  88                         Test = new SqlDecimal (-1);
  89                         AssertEquals ("#A08", -1m, Test.Value);
  90
  91                         // SqlDecimal (long)
  92                         Test = new SqlDecimal ((long)(-99999));
  93                         AssertEquals ("#A09", -99999m, Test.Value);
  94
  95                         // SqlDecimal (byte, byte, bool. int[]
  96                         Test = new SqlDecimal (10, 3, false, new int [4] {200, 1, 0, 0});
  97                         AssertEquals ("#A10", -4294967.496m, Test.Value);
  98
  99                         try {
 100                                 Test = new SqlDecimal (100, 100, false,
 101                                                        new int [4] {Int32.MaxValue,
 102                                                        Int32.MaxValue, Int32.MaxValue,
 103                                                        Int32.MaxValue});
 104                                 Fail ("#A11");
 105                         } catch (SqlTypeException) {
 106                         }
 107
 108                         // sqlDecimal (byte, byte, bool, int, int, int, int)
 109                         Test = new SqlDecimal (12, 2, true, 100, 100, 0, 0);
 110                         AssertEquals ("#A13", 4294967297.00m, Test.Value);
 111
 112                         try {
 113                                 Test = new SqlDecimal (100, 100, false,
 114                                                        Int32.MaxValue,
 115                                                        Int32.MaxValue, Int32.MaxValue,
 116                                                        Int32.MaxValue);
 117                                 Fail ("#A14");
 118                         } catch (SqlTypeException) {
 119                         }
 120                 }
 121
 122                 // Test public fields
 123                 [Test]
 124                 public void PublicFields()
 125                 {
 126                         AssertEquals ("#B01", (byte)38, SqlDecimal.MaxPrecision);
 127                         AssertEquals ("#B02", (byte)38, SqlDecimal.MaxScale);
 128
 129                         // FIXME: on windows: Conversion overflow
 130                         AssertEquals  ("#B03a", 1262177448, SqlDecimal.MaxValue.Data [3]);
 131
 132
 133                         AssertEquals ("#B04", 1262177448, SqlDecimal.MinValue.Data [3]);
 134                         Assert ("#B05", SqlDecimal.Null.IsNull);
 135                         Assert ("#B06", !Test1.IsNull);
 136                 }
 137
 138                 // Test properties
 139                 [Test]
 140                 public void Properties()
 141                 {
 142                         byte[] b = Test1.BinData;
 143                         AssertEquals ("#C01", (byte)64, b [0]);
 144
 145                         int[] i = Test1.Data;
 146                         AssertEquals ("#C02", 64646464, i [0]);
 147
 148                         Assert ("#C03", SqlDecimal.Null.IsNull);
 149                         Assert ("#C04", Test1.IsPositive);
 150                         Assert ("#C05", !Test4.IsPositive);
 151                         AssertEquals ("#C06", (byte)8, Test1.Precision);
 152                         AssertEquals ("#C07", (byte)2, Test2.Scale);
 153                         AssertEquals ("#C08", 6464.6464m, Test1.Value);
 154                         AssertEquals ("#C09", (byte)4, Test1.Scale);
 155                         AssertEquals ("#C10", (byte)7, Test2.Precision);
 156                         AssertEquals ("#C11", (byte)1, Test4.Precision);
 157                 }
 158
 159                 // PUBLIC METHODS
 160                 [Test]
 161                 public void ArithmeticMethods()
 162                 {
 163
 164                         // Abs
 165                         AssertEquals ("#D01", (SqlDecimal)6m, SqlDecimal.Abs (Test4));
 166                         AssertEquals ("#D02", new SqlDecimal (6464.6464m).Value, SqlDecimal.Abs (Test1).Value);
 167
 168                         AssertEquals ("#D03", SqlDecimal.Null, SqlDecimal.Abs (SqlDecimal.Null));
 169
 170                         // Add()
 171                         AssertEquals ("#D04", 16464.6464m, SqlDecimal.Add (Test1, Test2).Value);
 172
 173                         try {
 174                                 SqlDecimal test = SqlDecimal.Add (SqlDecimal.MaxValue, SqlDecimal.MaxValue);
 175                                 Fail ("#D05");
 176                         } catch (OverflowException) {
 177                         }
 178
 179                         AssertEquals ("#D07", (SqlDecimal)6465m, SqlDecimal.Ceiling(Test1));
 180                         AssertEquals ("#D08", SqlDecimal.Null, SqlDecimal.Ceiling(SqlDecimal.Null));
 181
 182                         // Divide()
 183                         AssertEquals ("#D09", (SqlDecimal)(-1077.441066m), SqlDecimal.Divide (Test1, Test4));
 184                         AssertEquals ("#D10", 1.54687501546m, SqlDecimal.Divide (Test2, Test1).Value);
 185
 186                         try {
 187                                 SqlDecimal test = SqlDecimal.Divide(Test1, new SqlDecimal(0)).Value;
 188                                 Fail ("#D11");
 189                         } catch(Exception e) {
 190                                 AssertEquals ("#D12", typeof (DivideByZeroException), e.GetType ());
 191                         }
 192
 193                         AssertEquals ("#D13", (SqlDecimal)6464m, SqlDecimal.Floor (Test1));
 194
 195                         // Multiply()
 196                         AssertEquals ("#D14", 64646464.000000m, SqlDecimal.Multiply (Test1, Test2).Value);
 197                         AssertEquals ("#D15", -38787.8784m, SqlDecimal.Multiply (Test1, Test4).Value);
 198
 199                         try {
 200                                 SqlDecimal test = SqlDecimal.Multiply (SqlDecimal.MaxValue, Test1);
 201                                 Fail ("#D16");
 202                         } catch (Exception e) {
 203                                 AssertEquals ("#D17", typeof (OverflowException), e.GetType ());
 204                         }
 205
 206                         // Power
 207                         AssertEquals ("#D18", (SqlDecimal)41791653.0770m, SqlDecimal.Power (Test1, 2));
 208
 209                         // Round
 210                         AssertEquals ("#D19", (SqlDecimal)6464.65m, SqlDecimal.Round (Test1, 2));
 211
 212                         // Subtract()
 213                         AssertEquals ("#D20", -3535.3536m, SqlDecimal.Subtract (Test1, Test3).Value);
 214
 215                         try {
 216                                 SqlDecimal test = SqlDecimal.Subtract(SqlDecimal.MinValue, SqlDecimal.MaxValue);
 217                                 Fail ("#D21");
 218                         } catch (Exception e) {
 219                                 AssertEquals ("#D22", typeof (OverflowException), e.GetType ());
 220                         }
 221
 222                         AssertEquals ("#D23", (SqlInt32)1, SqlDecimal.Sign (Test1));
 223                         AssertEquals ("#D24", new SqlInt32(-1), SqlDecimal.Sign (Test4));
 224                 }
 225
 226                 [Test]
 227                 public void AdjustScale()
 228                 {
 229                         AssertEquals ("#E01", "6464.646400", SqlDecimal.AdjustScale (Test1, 2, false).Value.ToString ());
 230                         AssertEquals ("#E02", "6464.65", SqlDecimal.AdjustScale (Test1, -2, true).Value.ToString ());
 231                         AssertEquals ("#E03", "6464.64", SqlDecimal.AdjustScale (Test1, -2, false).Value.ToString ());
 232                         AssertEquals ("#E01", "10000.000000000000", SqlDecimal.AdjustScale (Test2, 10, false).Value.ToString ());
 233                 }
 234
 235                 [Test]
 236                 public void ConvertToPrecScale()
 237                 {
 238                         AssertEquals ("#F01", new SqlDecimal(6464.6m).Value, SqlDecimal.ConvertToPrecScale (Test1, 5, 1).Value);
 239
 240                         try {
 241                                 SqlDecimal test =  SqlDecimal.ConvertToPrecScale (Test1, 6, 5);
 242                                 Fail ("#F02");
 243                         } catch (Exception e) {
 244                                 AssertEquals ("#F03", typeof (SqlTruncateException), e.GetType ());
 245                         }
 246
 247                         AssertEquals ("#F01", (SqlString)"10000.00", SqlDecimal.ConvertToPrecScale (Test2, 7, 2).ToSqlString ());
 248                 }
 249
 250                 [Test]
 251                 public void CompareTo()
 252                 {
 253                         SqlString TestString = new SqlString ("This is a test");
 254
 255                         Assert ("#G01", Test1.CompareTo (Test3) < 0);
 256                         Assert ("#G02", Test2.CompareTo (Test1) > 0);
 257                         Assert ("#G03", Test2.CompareTo (Test3) == 0);
 258                         Assert ("#G04", Test4.CompareTo (SqlDecimal.Null) > 0);
 259
 260                         try {
 261                                 Test1.CompareTo (TestString);
 262                                 Fail("#G05");
 263                         } catch(Exception e) {
 264                                 AssertEquals ("#G06", typeof (ArgumentException), e.GetType ());
 265                         }
 266                 }
 267
 268                 [Test]
 269                 public void EqualsMethods()
 270                 {
 271                         Assert ("#H01", !Test1.Equals (Test2));
 272                         Assert ("#H02", !Test2.Equals (new SqlString ("TEST")));
 273                         Assert ("#H03", Test2.Equals (Test3));
 274
 275                         // Static Equals()-method
 276                         Assert ("#H05", SqlDecimal.Equals (Test2, Test2).Value);
 277                         Assert ("#H06", !SqlDecimal.Equals (Test1, Test2).Value);
 278
 279                         // NotEquals
 280                         Assert ("#H07", SqlDecimal.NotEquals (Test1, Test2).Value);
 281                         Assert ("#H08", SqlDecimal.NotEquals (Test4, Test1).Value);
 282                         Assert ("#H09", !SqlDecimal.NotEquals (Test2, Test3).Value);
 283                         Assert ("#H10", SqlDecimal.NotEquals (SqlDecimal.Null, Test3).IsNull);
 284                 }
 285
 286                 /* Don't do such environment-dependent test. It will never succeed under Portable.NET and MS.NET
 287                 [Test]
 288                 public void GetHashCodeTest()
 289                 {
 290                         // FIXME: Better way to test HashCode
 291                         AssertEquals ("#I01", -1281249885, Test1.GetHashCode ());
 292                 }
 293                 */
 294
 295                 [Test]
 296                 public void GetTypeTest()
 297                 {
 298                         AssertEquals ("#J01", "System.Data.SqlTypes.SqlDecimal",
 299                                       Test1.GetType ().ToString ());
 300                         AssertEquals ("#J02", "System.Decimal", Test1.Value.GetType ().ToString ());
 301                 }
 302
 303                 [Test]
 304                 public void Greaters()
 305                 {
 306                         // GreateThan ()
 307                         Assert ("#K01", !SqlDecimal.GreaterThan (Test1, Test2).Value);
 308                         Assert ("#K02", SqlDecimal.GreaterThan (Test2, Test1).Value);
 309                         Assert ("#K03", !SqlDecimal.GreaterThan (Test2, Test3).Value);
 310
 311                         // GreaterTharOrEqual ()
 312                         Assert ("#K04", !SqlDecimal.GreaterThanOrEqual (Test1, Test2).Value);
 313                         Assert ("#K05", SqlDecimal.GreaterThanOrEqual (Test2, Test1).Value);
 314                         Assert ("#K06", SqlDecimal.GreaterThanOrEqual (Test2, Test3).Value);
 315                 }
 316
 317                 [Test]
 318                 public void Lessers()
 319                 {
 320                         // LessThan()
 321                         Assert ("#L01", !SqlDecimal.LessThan (Test3, Test2).Value);
 322                         Assert ("#L02", !SqlDecimal.LessThan (Test2, Test1).Value);
 323                         Assert ("#L03", SqlDecimal.LessThan (Test1, Test2).Value);
 324
 325                         // LessThanOrEqual ()
 326                         Assert ("#L04", SqlDecimal.LessThanOrEqual (Test1, Test2).Value);
 327                         Assert ("#L05", !SqlDecimal.LessThanOrEqual (Test2, Test1).Value);
 328                         Assert ("#L06", SqlDecimal.LessThanOrEqual (Test2, Test3).Value);
 329                         Assert ("#L07", SqlDecimal.LessThanOrEqual (Test1, SqlDecimal.Null).IsNull);
 330                 }
 331
 332                 [Test]
 333                 public void Parse()
 334                 {
 335                         try {
 336                                 SqlDecimal.Parse (null);
 337                                 Fail ("#m01");
 338                         } catch (Exception e) {
 339                                 AssertEquals ("#M02", typeof (ArgumentNullException), e.GetType ());
 340                         }
 341
 342                         try {
 343                                 SqlDecimal.Parse ("not-a-number");
 344                                 Fail ("#M03");
 345                         } catch (Exception e) {
 346                                 AssertEquals ("#M04", typeof (FormatException), e.GetType ());
 347                         }
 348
 349                          try {
 350                                 SqlDecimal test = SqlDecimal.Parse ("9e300");
 351                                 Fail ("#M05");
 352                         } catch (FormatException) {
 353                         }
 354
 355                         AssertEquals("#M07", 150m, SqlDecimal.Parse ("150").Value);
 356
 357                         // decimal.Parse() does not pass this string.
 358                         string max  = "99999999999999999999999999999999999999";
 359                         SqlDecimal dx = SqlDecimal.Parse (max);
 360                         AssertEquals ("#M08", max, dx.ToString ());
 361
 362                         try {
 363                                 dx = SqlDecimal.Parse (max + ".0");
 364                                 Fail ("#M09");
 365                         } catch (FormatException) {
 366                         }
 367                 }
 368
 369                 [Test]
 370                 public void Conversions()
 371                 {
 372                         // ToDouble
 373                         AssertEquals ("N01", 6464.6464, Test1.ToDouble ());
 374
 375                         // ToSqlBoolean ()
 376                         AssertEquals ("#N02", new SqlBoolean(1), Test1.ToSqlBoolean ());
 377
 378                         SqlDecimal Test = new SqlDecimal (0);
 379                         Assert ("#N03", !Test.ToSqlBoolean ().Value);
 380
 381                         Test = new SqlDecimal (0);
 382                         Assert ("#N04", !Test.ToSqlBoolean ().Value);
 383                         Assert ("#N05", SqlDecimal.Null.ToSqlBoolean ().IsNull);
 384
 385                         // ToSqlByte ()
 386                         Test = new SqlDecimal (250);
 387                         AssertEquals ("#N06", (byte)250, Test.ToSqlByte ().Value);
 388
 389                         try {
 390                                 SqlByte b = (byte)Test2.ToSqlByte ();
 391                                 Fail ("#N07");
 392                         } catch (Exception e) {
 393                                 AssertEquals ("#N08", typeof (OverflowException), e.GetType ());
 394                         }
 395
 396                         // ToSqlDouble ()
 397                         AssertEquals ("#N09", (SqlDouble)6464.6464, Test1.ToSqlDouble ());
 398
 399                         // ToSqlInt16 ()
 400                         AssertEquals ("#N10", (short)1, new SqlDecimal (1).ToSqlInt16 ().Value);
 401
 402                         try {
 403                                 SqlInt16 test = SqlDecimal.MaxValue.ToSqlInt16().Value;
 404                                 Fail ("#N11");
 405                         } catch (Exception e) {
 406                                 AssertEquals ("#N12", typeof (OverflowException), e.GetType ());
 407                         }
 408
 409                         // ToSqlInt32 ()
 410                         // LAMESPEC: 6464.6464 --> 64646464 ??? with windows
 411                         // MS.NET seems to return the first 32 bit integer (i.e.
 412                         // Data [0]) but we don't have to follow such stupidity.
 413 //                      AssertEquals ("#N13a", (int)64646464, Test1.ToSqlInt32 ().Value);
 414 //                      AssertEquals ("#N13b", (int)1212, new SqlDecimal(12.12m).ToSqlInt32 ().Value);
 415
 416                         try {
 417                                 SqlInt32 test = SqlDecimal.MaxValue.ToSqlInt32 ().Value;
 418                                 Fail ("#N14");
 419                         } catch (Exception e) {
 420                                 AssertEquals ("#N15", typeof (OverflowException), e.GetType ());
 421                         }
 422
 423                         // ToSqlInt64 ()
 424                         AssertEquals ("#N16", (long)6464, Test1.ToSqlInt64 ().Value);
 425
 426                         // ToSqlMoney ()
 427                         AssertEquals ("#N17", (decimal)6464.6464, Test1.ToSqlMoney ().Value);
 428
 429                         try {
 430                                 SqlMoney test = SqlDecimal.MaxValue.ToSqlMoney ().Value;
 431                                 Fail ("#N18");
 432                         } catch (Exception e) {
 433                                 AssertEquals ("#N19", typeof (OverflowException), e.GetType ());
 434                         }
 435
 436                         // ToSqlSingle ()
 437                         AssertEquals ("#N20", (float)6464.6464, Test1.ToSqlSingle ().Value);
 438
 439                         // ToSqlString ()
 440                         AssertEquals ("#N21", "6464.6464", Test1.ToSqlString ().Value);
 441
 442                         // ToString ()
 443                         AssertEquals ("#N22", "6464.6464", Test1.ToString ());
 444                         AssertEquals ("#N23", (SqlDouble)1E+38, SqlDecimal.MaxValue.ToSqlDouble ());
 445
 446                 }
 447
 448                 [Test]
 449                 public void Truncate()
 450                 {
 451 //                      AssertEquals ("#O01", new SqlDecimal (6464.6400m).Value, SqlDecimal.Truncate (Test1, 2).Value);
 452                         AssertEquals ("#O01", 6464.6400m, SqlDecimal.Truncate (Test1, 2).Value);
 453                 }
 454
 455                 // OPERATORS
 456
 457                 [Test]
 458                 public void ArithmeticOperators()
 459                 {
 460                         // "+"-operator
 461                         AssertEquals ("#P01", new SqlDecimal(16464.6464m), Test1 + Test2);
 462
 463                         try {
 464                                 SqlDecimal test = SqlDecimal.MaxValue + SqlDecimal.MaxValue;
 465                                 Fail ("#P02");
 466                         } catch (Exception e) {
 467                                 AssertEquals ("#P03", typeof (OverflowException), e.GetType ());
 468                         }
 469
 470                         // "/"-operator
 471                         AssertEquals ("#P04", (SqlDecimal)1.54687501546m, Test2 / Test1);
 472
 473                         try {
 474                                 SqlDecimal test = Test3 / new SqlDecimal (0);
 475                                 Fail ("#P05");
 476                         } catch (Exception e) {
 477                                 AssertEquals ("#P06", typeof (DivideByZeroException), e.GetType ());
 478                         }
 479
 480                         // "*"-operator
 481                         AssertEquals ("#P07", (SqlDecimal)64646464m, Test1 * Test2);
 482
 483                         try {
 484                                 SqlDecimal test = SqlDecimal.MaxValue * Test1;
 485                                 Fail ("#P08");
 486                         } catch (Exception e) {
 487                                 AssertEquals ("#P09", typeof (OverflowException), e.GetType ());
 488                         }
 489
 490                         // "-"-operator
 491                         AssertEquals ("#P10", (SqlDecimal)3535.3536m, Test2 - Test1);
 492
 493                         try {
 494                                 SqlDecimal test = SqlDecimal.MinValue - SqlDecimal.MaxValue;
 495                                 Fail ("#P11");
 496                         } catch  (Exception e) {
 497                                 AssertEquals ("#P12", typeof (OverflowException), e.GetType ());
 498                         }
 499
 500                         AssertEquals ("#P13", SqlDecimal.Null, SqlDecimal.Null + Test1);
 501                 }
 502
 503                 [Test]
 504                 public void ThanOrEqualOperators()
 505                 {
 506
 507                         // == -operator
 508                         Assert ("#Q01", (Test2 == Test3).Value);
 509                         Assert ("#Q02", !(Test1 == Test2).Value);
 510                         Assert ("#Q03", (Test1 == SqlDecimal.Null).IsNull);
 511
 512                         // != -operator
 513                         Assert ("#Q04", !(Test2 != Test3).Value);
 514                         Assert ("#Q05", (Test1 != Test3).Value);
 515                         Assert ("#Q06", (Test4 != Test3).Value);
 516                         Assert ("#Q07", (Test1 != SqlDecimal.Null).IsNull);
 517
 518                         // > -operator
 519                         Assert ("#Q08", (Test2 > Test1).Value);
 520                         Assert ("#Q09", !(Test1 > Test3).Value);
 521                         Assert ("#Q10", !(Test2 > Test3).Value);
 522                         Assert ("#Q11", (Test1 > SqlDecimal.Null).IsNull);
 523
 524                         // >=  -operator
 525                         Assert ("#Q12", !(Test1 >= Test3).Value);
 526                         Assert ("#Q13", (Test3 >= Test1).Value);
 527                         Assert ("#Q14", (Test2 >= Test3).Value);
 528                         Assert ("#Q15", (Test1 >= SqlDecimal.Null).IsNull);
 529
 530                         // < -operator
 531                         Assert ("#Q16", !(Test2 < Test1).Value);
 532                         Assert ("#Q17", (Test1 < Test3).Value);
 533                         Assert ("#Q18", !(Test2 < Test3).Value);
 534                         Assert ("#Q19", (Test1 < SqlDecimal.Null).IsNull);
 535
 536                         // <= -operator
 537                         Assert ("#Q20", (Test1 <= Test3).Value);
 538                         Assert ("#Q21", !(Test3 <= Test1).Value);
 539                         Assert ("#Q22", (Test2 <= Test3).Value);
 540                         Assert ("#Q23", (Test1 <= SqlDecimal.Null).IsNull);
 541                 }
 542
 543                 [Test]
 544                 public void UnaryNegation()
 545                 {
 546                         AssertEquals ("#R01", 6m, -Test4.Value);
 547                         AssertEquals ("#R02", -6464.6464m, -Test1.Value);
 548                         AssertEquals ("#R03", SqlDecimal.Null, SqlDecimal.Null);
 549                 }
 550
 551                 [Test]
 552                 public void SqlBooleanToSqlDecimal()
 553                 {
 554                         SqlBoolean TestBoolean = new SqlBoolean (true);
 555                         SqlDecimal Result;
 556
 557                         Result = (SqlDecimal)TestBoolean;
 558
 559                         AssertEquals ("#S01", 1m, Result.Value);
 560
 561                         Result = (SqlDecimal)SqlBoolean.Null;
 562                         Assert ("#S02", Result.IsNull);
 563                         AssertEquals ("#S03", SqlDecimal.Null, (SqlDecimal)SqlBoolean.Null);
 564                 }
 565
 566                 [Test]
 567                 public void SqlDecimalToDecimal()
 568                 {
 569                         AssertEquals ("#T01", 6464.6464m, (Decimal)Test1);
 570                 }
 571
 572                 [Test]
 573                 public void SqlDoubleToSqlDecimal()
 574                 {
 575                         SqlDouble Test = new SqlDouble (12E+10);
 576                         AssertEquals ("#U01", 120000000000.00000m, ((SqlDecimal)Test).Value);
 577                 }
 578
 579                 [Test]
 580                 public void SqlSingleToSqlDecimal()
 581                 {
 582                         SqlSingle Test = new SqlSingle (1E+9);
 583                         AssertEquals ("#V01", 1000000000.0000000m, ((SqlDecimal)Test).Value);
 584
 585                         try {
 586                                 SqlDecimal test = (SqlDecimal)SqlSingle.MaxValue;
 587                                 Fail ("#V02");
 588                         } catch (Exception e) {
 589                                 AssertEquals ("#V03", typeof (OverflowException), e.GetType ());
 590                         }
 591                 }
 592
 593                 [Test]
 594                 public void SqlStringToSqlDecimal()
 595                 {
 596                         SqlString TestString = new SqlString ("Test string");
 597                         SqlString TestString100 = new SqlString ("100");
 598
 599                         AssertEquals ("#W01", 100m, ((SqlDecimal)TestString100).Value);
 600
 601                         try {
 602                                 SqlDecimal test = (SqlDecimal)TestString;
 603                                 Fail ("#W02");
 604                         } catch(Exception e) {
 605                                 AssertEquals ("#W03", typeof (FormatException), e.GetType ());
 606                         }
 607
 608                         try {
 609                                 SqlDecimal test = (SqlDecimal)new SqlString("9E+100");
 610                                 Fail ("#W04");
 611                         } catch (Exception e) {
 612                                 AssertEquals ("#W05", typeof (FormatException), e.GetType());
 613                         }
 614                 }
 615
 616                 [Test]
 617                 public void DecimalToSqlDecimal()
 618                 {
 619                         decimal d = 1000.1m;
 620                         AssertEquals ("#X01", (SqlDecimal)1000.1m, (SqlDecimal)d);
 621                 }
 622
 623                 [Test]
 624                 public void ByteToSqlDecimal()
 625                 {
 626                         AssertEquals ("#Y01", 255m, ((SqlDecimal)SqlByte.MaxValue).Value);
 627                 }
 628
 629                 [Test]
 630                 public void SqlIntToSqlDouble()
 631                 {
 632                         SqlInt16 Test64 = new SqlInt16 (64);
 633                         SqlInt32 Test640 = new SqlInt32 (640);
 634                         SqlInt64 Test64000 = new SqlInt64 (64000);
 635                         AssertEquals ("#Z01", 64m, ((SqlDecimal)Test64).Value);
 636                         AssertEquals ("#Z02", 640m,((SqlDecimal)Test640).Value);
 637                         AssertEquals ("#Z03", 64000m, ((SqlDecimal)Test64000).Value);
 638                 }
 639
 640                 [Test]
 641                 public void SqlMoneyToSqlDecimal()
 642                 {
 643                         SqlMoney TestMoney64 = new SqlMoney(64);
 644                         AssertEquals ("#AA01", 64.0000M, ((SqlDecimal)TestMoney64).Value);
 645                 }
 646
 647                 [Test]
 648                 public void ToStringTest ()
 649                 {
 650                         AssertEquals ("#01", "Null", SqlDecimal.Null.ToString ());
 651                         AssertEquals ("#02", "-99999999999999999999999999999999999999", SqlDecimal.MinValue.ToString ());
 652                         AssertEquals ("#03", "99999999999999999999999999999999999999", SqlDecimal.MaxValue.ToString ());
 653                 }
 654
 655                 [Test]
 656                 public void Value ()
 657                 {
 658                         decimal d = decimal.Parse ("9999999999999999999999999999");
 659                 }
 660         }
 661 }
 662