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