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

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