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

   1 //\r
   2 // SqlMoneyTest.cs - NUnit Test Cases for System.Data.SqlTypes.SqlMoney\r
   3 //\r
   4 // Authors:\r
   5 //   Ville Palo (vi64pa@koti.soon.fi)\r
   6 //   Martin Willemoes Hansen (mwh@sysrq.dk)\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 SqlMoneyTest : Assertion {\r
  45 \r
  46                 private SqlMoney Test1;\r
  47                 private SqlMoney Test2;\r
  48                 private SqlMoney Test3;\r
  49                 private SqlMoney 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 SqlMoney (6464.6464d);\r
  56                         Test2 = new SqlMoney (90000.0m);\r
  57                         Test3 = new SqlMoney (90000.0m);\r
  58                         Test4 = new SqlMoney (-45000.0m);\r
  59                 }\r
  60 \r
  61                 // Test constructor\r
  62                 [Test]\r
  63                 public void Create()\r
  64                 {\r
  65                         try {\r
  66                                 SqlMoney Test = new SqlMoney (1000000000000000m);\r
  67                                 Fail ("#B01");\r
  68                         } catch (Exception e) {\r
  69                                 AssertEquals ("#A02", typeof (OverflowException),\r
  70                                               e.GetType ());\r
  71                         }\r
  72 \r
  73                         SqlMoney CreationTest = new SqlMoney ((decimal)913.3);\r
  74                         AssertEquals ("A03", 913.3000m, CreationTest.Value);\r
  75 \r
  76                         try {\r
  77                                 SqlMoney Test = new SqlMoney (1e200);\r
  78                                 Fail ("#B04");\r
  79                         } catch (Exception e) {\r
  80                                 AssertEquals ("#A05", typeof (OverflowException),\r
  81                                               e.GetType ());\r
  82                         }\r
  83                         \r
  84                         SqlMoney CreationTest2 = new SqlMoney ((double)913.3);\r
  85                         AssertEquals ("A06", 913.3000m, CreationTest2.Value);\r
  86 \r
  87                         SqlMoney CreationTest3 = new SqlMoney ((int)913);\r
  88                         AssertEquals ("A07", 913.0000m, CreationTest3.Value);\r
  89 \r
  90                         SqlMoney CreationTest4 = new SqlMoney ((long)913.3);\r
  91                         AssertEquals ("A08", 913.0000m, CreationTest4.Value);\r
  92                 }\r
  93 \r
  94                 // Test public fields\r
  95                 [Test]\r
  96                 public void PublicFields()\r
  97                 {\r
  98                         // FIXME: There is a error in msdn docs, it says thath MaxValue\r
  99                         // is 922,337,203,685,475.5807 when the actual value is\r
 100                         //    922,337,203,685,477.5807\r
 101                         AssertEquals ("#B01", 922337203685477.5807m, SqlMoney.MaxValue.Value);\r
 102                         AssertEquals ("#B02", -922337203685477.5808m, SqlMoney.MinValue.Value);\r
 103                         Assert ("#B03", SqlMoney.Null.IsNull);\r
 104                         AssertEquals ("#B04", 0m, SqlMoney.Zero.Value);\r
 105                 }\r
 106 \r
 107                 // Test properties\r
 108                 [Test]\r
 109                 public void Properties()\r
 110                 {\r
 111                         AssertEquals ("#C01", 90000.0000m, Test2.Value);\r
 112                         AssertEquals ("#C02", -45000.0000m, Test4.Value);\r
 113                         Assert ("#C03", SqlMoney.Null.IsNull);\r
 114                 }\r
 115 \r
 116                 // PUBLIC METHODS\r
 117 \r
 118                 [Test]\r
 119                 public void ArithmeticMethods()\r
 120                 {\r
 121                         SqlMoney TestMoney2 = new SqlMoney (2);\r
 122 \r
 123                         // Add\r
 124                         AssertEquals ("#D01", (SqlMoney)96464.6464m, SqlMoney.Add (Test1, Test2));\r
 125                         AssertEquals ("#D02", (SqlMoney)180000m, SqlMoney.Add (Test2, Test2));\r
 126                         AssertEquals ("#D03", (SqlMoney)45000m, SqlMoney.Add (Test2, Test4));\r
 127                         \r
 128                         try {\r
 129                                 SqlMoney test = SqlMoney.Add(SqlMoney.MaxValue, Test2);\r
 130                                 Fail ("#D04");\r
 131                         } catch (Exception e) {\r
 132                                 AssertEquals ("#D05", typeof (OverflowException), e.GetType ());\r
 133                         }\r
 134 \r
 135                         // Divide\r
 136                         AssertEquals ("#D06", (SqlMoney)45000m, SqlMoney.Divide (Test2, TestMoney2));\r
 137                         try {\r
 138                                 SqlMoney test = SqlMoney.Divide (Test2, SqlMoney.Zero);\r
 139                                 Fail ("#D07");\r
 140                         } catch (Exception e) {\r
 141                                 AssertEquals ("#D08", typeof (DivideByZeroException), \r
 142                                               e.GetType());\r
 143                         }\r
 144                                                         \r
 145                         // Multiply\r
 146                         AssertEquals ("#D09", (SqlMoney)581818176m, SqlMoney.Multiply (Test1, Test2));\r
 147                         AssertEquals ("#D10", (SqlMoney)(-4050000000m), SqlMoney.Multiply (Test3, Test4));\r
 148 \r
 149                         try {\r
 150                                 SqlMoney test = SqlMoney.Multiply (SqlMoney.MaxValue, Test2);\r
 151                                 Fail ("#D11");\r
 152                         } catch (Exception e) {\r
 153                                 AssertEquals ("#D12", typeof (OverflowException), e.GetType ());\r
 154                         }\r
 155                                       \r
 156                         // Subtract\r
 157                         AssertEquals ("#D13", (SqlMoney)0m, SqlMoney.Subtract (Test2, Test3));\r
 158                         AssertEquals ("#D14", (SqlMoney)83535.3536m, SqlMoney.Subtract (Test2, Test1));\r
 159                         \r
 160                         try {\r
 161                                 SqlMoney test = SqlMoney.Subtract (SqlMoney.MinValue, Test2);\r
 162                         } catch (Exception e) {\r
 163                                 AssertEquals ("#D15", typeof (OverflowException), e.GetType ());\r
 164                         }\r
 165                 }\r
 166 \r
 167                 [Test]\r
 168                 public void CompareTo()\r
 169                 {\r
 170                         Assert ("#E01", Test1.CompareTo (Test2) < 0);\r
 171                         Assert ("#E02", Test3.CompareTo (Test1) > 0);\r
 172                         Assert ("#E03", Test3.CompareTo (Test2) == 0);\r
 173                         Assert ("#E04", Test3.CompareTo (SqlMoney.Null) > 0);\r
 174                 }\r
 175 \r
 176                 [Test]\r
 177                 public void EqualsMethods()\r
 178                 {\r
 179                         Assert ("#F01", !Test1.Equals (Test2));\r
 180                         Assert ("#F02", Test2.Equals (Test3));\r
 181                         Assert ("#F03", !SqlMoney.Equals (Test1, Test2).Value);\r
 182                         Assert ("#F04", SqlMoney.Equals (Test3, Test2).Value);\r
 183                 }\r
 184 \r
 185                 [Test]\r
 186                 public void GetHashCodeTest()\r
 187                 {\r
 188                         // FIXME: Better way to test HashCode\r
 189                         AssertEquals ("#G01", Test3.GetHashCode (), Test2.GetHashCode ());\r
 190                         Assert ("#G02", Test2.GetHashCode () !=  Test1.GetHashCode ());\r
 191                 }\r
 192 \r
 193                 [Test]\r
 194                 public void GetTypeTest()\r
 195                 {\r
 196                         AssertEquals ("#H01", "System.Data.SqlTypes.SqlMoney", \r
 197                                       Test1.GetType ().ToString ());\r
 198                 }\r
 199 \r
 200                 [Test]\r
 201                 public void Greaters()\r
 202                 {\r
 203                         // GreateThan ()\r
 204                         Assert ("#I01", !SqlMoney.GreaterThan (Test1, Test2).Value);\r
 205                         Assert ("#I02", SqlMoney.GreaterThan (Test2, Test1).Value);\r
 206                         Assert ("#I03", !SqlMoney.GreaterThan (Test2, Test3).Value);\r
 207                         Assert ("#I04", SqlMoney.GreaterThan (Test2, SqlMoney.Null).IsNull);\r
 208 \r
 209                         // GreaterTharOrEqual ()\r
 210                         Assert ("#I05", !SqlMoney.GreaterThanOrEqual (Test1, Test2).Value);\r
 211                         Assert ("#I06", SqlMoney.GreaterThanOrEqual (Test2, Test1).Value);\r
 212                         Assert ("#I07", SqlMoney.GreaterThanOrEqual (Test3, Test2).Value);\r
 213                         Assert ("#I08", SqlMoney.GreaterThanOrEqual (Test3, SqlMoney.Null).IsNull);\r
 214                 }\r
 215 \r
 216                 [Test]\r
 217                 public void Lessers()\r
 218                 {\r
 219                         // LessThan()\r
 220                         Assert ("#J01", !SqlMoney.LessThan (Test2, Test3).Value);\r
 221                         Assert ("#J02", !SqlMoney.LessThan (Test2, Test1).Value);\r
 222                         Assert ("#J03", SqlMoney.LessThan (Test1, Test2).Value);\r
 223                         Assert ("#J04", SqlMoney.LessThan (SqlMoney.Null, Test2).IsNull);\r
 224 \r
 225                         // LessThanOrEqual ()\r
 226                         Assert ("#J05", SqlMoney.LessThanOrEqual (Test1, Test2).Value);\r
 227                         Assert ("#J06", !SqlMoney.LessThanOrEqual (Test2, Test1).Value);\r
 228                         Assert ("#J07", SqlMoney.LessThanOrEqual (Test2, Test2).Value);\r
 229                         Assert ("#J08", SqlMoney.LessThanOrEqual (Test2, SqlMoney.Null).IsNull);\r
 230                 }\r
 231 \r
 232                 [Test]\r
 233                 public void NotEquals()\r
 234                 {\r
 235                         Assert ("#K01", SqlMoney.NotEquals (Test1, Test2).Value);\r
 236                         Assert ("#K02", SqlMoney.NotEquals (Test2, Test1).Value);\r
 237                         Assert ("#K03", !SqlMoney.NotEquals (Test2, Test3).Value);\r
 238                         Assert ("#K04", !SqlMoney.NotEquals (Test3, Test2).Value);\r
 239                         Assert ("#K05", SqlMoney.NotEquals (SqlMoney.Null, Test2).IsNull);\r
 240                 }\r
 241 \r
 242                 [Test]\r
 243                 public void Parse()\r
 244                 {\r
 245                         try {\r
 246                                 SqlMoney.Parse (null);\r
 247                                 Fail ("#L01");\r
 248                         } catch (Exception e) {\r
 249                                 AssertEquals ("#L02", typeof (ArgumentNullException), e.GetType ());\r
 250                         }\r
 251 \r
 252                         try {\r
 253                                 SqlMoney.Parse ("not-a-number");\r
 254                                 Fail ("#L03");\r
 255                         } catch (Exception e) {\r
 256 \r
 257                                 AssertEquals ("#L04", typeof (FormatException), e.GetType ());\r
 258                         }\r
 259 \r
 260                          try {\r
 261                                 SqlMoney.Parse ("1000000000000000");\r
 262                                 Fail ("#L05");\r
 263                         } catch (Exception e) {\r
 264                                 AssertEquals ("#L06", typeof (OverflowException), e.GetType ());\r
 265                         }\r
 266 \r
 267                         AssertEquals("#L07", 150.0000M, SqlMoney.Parse ("150").Value);\r
 268                 }\r
 269 \r
 270                 [Test]\r
 271                 public void Conversions()\r
 272                 {                     \r
 273                         SqlMoney TestMoney100 = new SqlMoney (100);\r
 274 \r
 275                         // ToDecimal\r
 276                         AssertEquals ("#M01", (decimal)6464.6464, Test1.ToDecimal ());\r
 277 \r
 278                         // ToDouble\r
 279                         AssertEquals ("#M02", (double)6464.6464, Test1.ToDouble ());\r
 280 \r
 281                         // ToInt32\r
 282                         AssertEquals ("#M03", (int)90000, Test2.ToInt32 ());\r
 283                         AssertEquals ("#M04", (int)6465, Test1.ToInt32 ());\r
 284 \r
 285                         // ToInt64\r
 286                         AssertEquals ("#M05", (long)90000, Test2.ToInt64 ());\r
 287                         AssertEquals ("#M06", (long)6465, Test1.ToInt64 ());\r
 288 \r
 289                         // ToSqlBoolean ()\r
 290                         Assert ("#M07", Test1.ToSqlBoolean ().Value);\r
 291                         Assert ("#M08", !SqlMoney.Zero.ToSqlBoolean ().Value);\r
 292                         Assert ("#M09", SqlMoney.Null.ToSqlBoolean ().IsNull);\r
 293 \r
 294                         // ToSqlByte ()\r
 295                         AssertEquals ("#M10", (byte)100, TestMoney100.ToSqlByte ().Value);\r
 296 \r
 297                         try {\r
 298                                 SqlByte b = (byte)Test2.ToSqlByte ();\r
 299                                 Fail ("#M11");\r
 300                         } catch (Exception e) {\r
 301                                 AssertEquals ("#M12", typeof (OverflowException), e.GetType ());\r
 302                         }\r
 303 \r
 304                         // ToSqlDecimal ()\r
 305                         AssertEquals ("#M13", (decimal)6464.6464, Test1.ToSqlDecimal ().Value);\r
 306                         AssertEquals ("#M14", -45000.0000m, Test4.ToSqlDecimal ().Value);\r
 307 \r
 308                         // ToSqlInt16 ()\r
 309                         AssertEquals ("#M15", (short)6465, Test1.ToSqlInt16 ().Value);\r
 310 \r
 311                         try {\r
 312                                 SqlInt16 test = SqlMoney.MaxValue.ToSqlInt16().Value;\r
 313                                 Fail ("#M17");\r
 314                         } catch (Exception e) {\r
 315                                 AssertEquals ("#M18", typeof (OverflowException), e.GetType ());\r
 316                         }        \r
 317 \r
 318                         // ToSqlInt32 ()\r
 319                         AssertEquals ("#M19", (int)6465, Test1.ToSqlInt32 ().Value);\r
 320                         AssertEquals ("#M20", (int)(-45000), Test4.ToSqlInt32 ().Value);\r
 321 \r
 322                         try {\r
 323                                 SqlInt32 test = SqlMoney.MaxValue.ToSqlInt32 ().Value;\r
 324                                 Fail ("#M21");\r
 325                         } catch (Exception e) { \r
 326                                 AssertEquals ("#M22", typeof (OverflowException), e.GetType ());\r
 327                         }\r
 328 \r
 329                         // ToSqlInt64 ()\r
 330                         AssertEquals ("#M23", (long)6465, Test1.ToSqlInt64 ().Value);\r
 331                         AssertEquals ("#M24", (long)(-45000), Test4.ToSqlInt64 ().Value);\r
 332 \r
 333                         // ToSqlSingle ()\r
 334                         AssertEquals ("#M25", (float)6464.6464, Test1.ToSqlSingle ().Value);\r
 335 \r
 336                         // ToSqlString ()\r
 337                         AssertEquals ("#M26", "6464.6464", Test1.ToSqlString ().Value);\r
 338                         AssertEquals ("#M27", "90000.0000", Test2.ToSqlString ().Value);\r
 339 \r
 340                         // ToString ()\r
 341                         AssertEquals ("#M28", "6464.6464", Test1.ToString ());\r
 342                         AssertEquals ("#M29", "90000.0000", Test2.ToString ());\r
 343                 }\r
 344 \r
 345                 // OPERATORS\r
 346 \r
 347                 [Test]\r
 348                 public void ArithmeticOperators()\r
 349                 {\r
 350                         // "+"-operator\r
 351                         AssertEquals ("#N01", (SqlMoney)96464.6464m, Test1 + Test2);\r
 352      \r
 353                         try {\r
 354                                 SqlMoney test = SqlMoney.MaxValue + SqlMoney.MaxValue;\r
 355                                 Fail ("#N02");\r
 356                         } catch (Exception e) {\r
 357                                 AssertEquals ("#N03", typeof (OverflowException), e.GetType ());\r
 358                         }\r
 359 \r
 360                         // "/"-operator\r
 361                         AssertEquals ("#N04", (SqlMoney)13.9219m, Test2 / Test1);\r
 362 \r
 363                         try {\r
 364                                 SqlMoney test = Test3 / SqlMoney.Zero;\r
 365                                 Fail ("#N05");\r
 366                         } catch (Exception e) {\r
 367                                 AssertEquals ("#N06", typeof (DivideByZeroException), e.GetType ());\r
 368                         }\r
 369 \r
 370                         // "*"-operator\r
 371                         AssertEquals ("#N07", (SqlMoney)581818176m, Test1 * Test2);\r
 372 \r
 373                         try {\r
 374                                 SqlMoney test = SqlMoney.MaxValue * Test1;\r
 375                                 Fail ("#N08");\r
 376                         } catch (Exception e) {\r
 377                                 AssertEquals ("#N09", typeof (OverflowException), e.GetType ());\r
 378                         }\r
 379 \r
 380                         // "-"-operator\r
 381                         AssertEquals ("#N10", (SqlMoney)83535.3536m, Test2 - Test1);\r
 382 \r
 383                         try {\r
 384                                 SqlMoney test = SqlMoney.MinValue - SqlMoney.MaxValue;\r
 385                                 Fail ("#N11");\r
 386                         } catch  (Exception e) {\r
 387                                 AssertEquals ("#N12", typeof (OverflowException), e.GetType ());\r
 388                         }\r
 389                 }\r
 390 \r
 391                 [Test]\r
 392                 public void ThanOrEqualOperators()\r
 393                 {\r
 394                         // == -operator\r
 395                         Assert ("#O01", (Test2 == Test2).Value);\r
 396                         Assert ("#O02", !(Test1 == Test2).Value);\r
 397                         Assert ("#O03", (Test1 == SqlMoney.Null).IsNull);\r
 398                         \r
 399                         // != -operator\r
 400                         Assert ("#O04", !(Test2 != Test3).Value);\r
 401                         Assert ("#O05", (Test1 != Test3).Value);\r
 402                         Assert ("#O06", (Test1 != Test4).Value);\r
 403                         Assert ("#O07", (Test1 != SqlMoney.Null).IsNull);\r
 404 \r
 405                         // > -operator\r
 406                         Assert ("#O08", (Test1 > Test4).Value);\r
 407                         Assert ("#O09", (Test2 > Test1).Value);\r
 408                         Assert ("#O10", !(Test2 > Test3).Value);\r
 409                         Assert ("#O11", (Test1 > SqlMoney.Null).IsNull);\r
 410 \r
 411                         // >=  -operator\r
 412                         Assert ("#O12", !(Test1 >= Test3).Value);\r
 413                         Assert ("#O13", (Test3 >= Test1).Value);\r
 414                         Assert ("#O14", (Test2 >= Test3).Value);\r
 415                         Assert ("#O15", (Test1 >= SqlMoney.Null).IsNull);\r
 416 \r
 417                         // < -operator\r
 418                         Assert ("#O16", !(Test2 < Test1).Value);\r
 419                         Assert ("#O17", (Test1 < Test3).Value);\r
 420                         Assert ("#O18", !(Test2 < Test3).Value);\r
 421                         Assert ("#O19", (Test1 < SqlMoney.Null).IsNull);\r
 422 \r
 423                         // <= -operator\r
 424                         Assert ("#O20", (Test1 <= Test3).Value);\r
 425                         Assert ("#O21", !(Test3 <= Test1).Value);\r
 426                         Assert ("#O22", (Test2 <= Test3).Value);\r
 427                         Assert ("#O23", (Test1 <= SqlMoney.Null).IsNull);\r
 428                 }\r
 429 \r
 430                 [Test]\r
 431                 public void UnaryNegation()\r
 432                 {\r
 433 \r
 434                         AssertEquals ("#P01", (decimal)(-6464.6464), -(Test1).Value);\r
 435                         AssertEquals ("#P02", 45000.0000M, -(Test4).Value);\r
 436                 }\r
 437 \r
 438                 [Test]\r
 439                 public void SqlBooleanToSqlMoney()\r
 440                 {\r
 441                         SqlBoolean TestBoolean = new SqlBoolean (true);\r
 442 \r
 443                         AssertEquals ("#Q01", 1.0000M, ((SqlMoney)TestBoolean).Value);\r
 444                         Assert ("#Q02", ((SqlDecimal)SqlBoolean.Null).IsNull);\r
 445                 }\r
 446                 \r
 447                 [Test]\r
 448                 public void SqlDecimalToSqlMoney()\r
 449                 {\r
 450                         SqlDecimal TestDecimal = new SqlDecimal (4000);\r
 451                         SqlDecimal TestDecimal2 = new SqlDecimal (1E+20);\r
 452 \r
 453                         SqlMoney TestMoney = (SqlMoney)TestDecimal;\r
 454                         AssertEquals ("#R01", 4000.0000M,TestMoney.Value);\r
 455 \r
 456                         try {\r
 457                                 SqlMoney test = (SqlMoney)TestDecimal2;\r
 458                                 Fail ("#R02");\r
 459                         } catch (Exception e) {\r
 460                                 AssertEquals ("#R03", typeof (OverflowException), e.GetType ());\r
 461                         }\r
 462                 }\r
 463              \r
 464                 [Test]\r
 465                 public void SqlDoubleToSqlMoney()\r
 466                 {\r
 467                         SqlDouble TestDouble = new SqlDouble (1E+9);\r
 468                         SqlDouble TestDouble2 = new SqlDouble (1E+20);\r
 469                         \r
 470                         SqlMoney TestMoney = (SqlMoney)TestDouble;\r
 471                         AssertEquals ("#S01", 1000000000.0000m, TestMoney.Value);\r
 472 \r
 473                         try {\r
 474                                 SqlMoney test = (SqlMoney)TestDouble2;\r
 475                                 Fail ("#S02");\r
 476                         } catch (Exception e) {\r
 477                                 AssertEquals ("#S03", typeof (OverflowException), e.GetType ());\r
 478                         }\r
 479                 }\r
 480 \r
 481                 [Test]\r
 482                 public void SqlMoneyToDecimal()\r
 483                 {\r
 484                         AssertEquals ("#T01", (decimal)6464.6464, (decimal)Test1);\r
 485                         AssertEquals ("#T02", -45000.0000M, (decimal)Test4);\r
 486                 }\r
 487 \r
 488                 [Test]\r
 489                 public void SqlSingleToSqlMoney()\r
 490                 {\r
 491                         SqlSingle TestSingle = new SqlSingle (1e10);\r
 492                         SqlSingle TestSingle2 = new SqlSingle (1e20);\r
 493 \r
 494                         AssertEquals ("#U01", 10000000000.0000m, ((SqlMoney)TestSingle).Value);\r
 495 \r
 496                         try {\r
 497                                 SqlMoney test = (SqlMoney)TestSingle2;\r
 498                                 Fail ("#U02");\r
 499                         } catch (Exception e) {\r
 500                                 AssertEquals ("#U03", typeof (OverflowException), e.GetType());\r
 501                         }\r
 502                 }\r
 503 \r
 504                 [Test]\r
 505                 public void SqlStringToSqlMoney()\r
 506                 {\r
 507                         SqlString TestString = new SqlString ("Test string");\r
 508                         SqlString TestString100 = new SqlString ("100");\r
 509 \r
 510                         AssertEquals ("#V01", 100.0000M, ((SqlMoney)TestString100).Value);\r
 511 \r
 512                         try {\r
 513                                 SqlMoney test = (SqlMoney)TestString;\r
 514                                 Fail ("#V02");\r
 515                         } catch(Exception e) {\r
 516                                 AssertEquals ("#V03", typeof (FormatException), e.GetType ());\r
 517                         }\r
 518                 }\r
 519 \r
 520                 [Test]\r
 521                 public void DecimalToSqlMoney()\r
 522                 {\r
 523                         decimal TestDecimal = 1e10m;\r
 524                         decimal TestDecimal2 = 1e20m;\r
 525                         AssertEquals ("#W01", 10000000000.0000M, ((SqlMoney)TestDecimal).Value);\r
 526                         \r
 527                         try {\r
 528                                 SqlMoney test = (SqlMoney)TestDecimal2;\r
 529                                 Fail ("#W02");\r
 530                         } catch (Exception e) {\r
 531                                 AssertEquals ("#W03", typeof (OverflowException), e.GetType ());\r
 532                         }                       \r
 533                 }\r
 534 \r
 535                 [Test]\r
 536                 public void SqlByteToSqlMoney() \r
 537                 {\r
 538                         SqlByte TestByte = new SqlByte ((byte)200);               \r
 539                         AssertEquals ("#X01", 200.0000m, ((SqlMoney)TestByte).Value);\r
 540                 }\r
 541 \r
 542                 [Test]\r
 543                 public void IntsToSqlMoney()\r
 544                 {\r
 545                         SqlInt16 TestInt16 = new SqlInt16 (5000);\r
 546                         SqlInt32 TestInt32 = new SqlInt32 (5000);\r
 547                         SqlInt64 TestInt64 = new SqlInt64 (5000);\r
 548                         \r
 549                         AssertEquals ("#Y01", 5000.0000m, ((SqlMoney)TestInt16).Value);\r
 550                         AssertEquals ("#Y02", 5000.0000m, ((SqlMoney)TestInt32).Value);\r
 551                         AssertEquals ("#Y03", 5000.0000m, ((SqlMoney)TestInt64).Value);\r
 552 \r
 553                         try {\r
 554                                 SqlMoney test = (SqlMoney)SqlInt64.MaxValue;\r
 555                                 Fail ("#Y04");\r
 556                         } catch (Exception e) {\r
 557                                 AssertEquals ("#Y05", typeof (OverflowException), e.GetType ());\r
 558                         }\r
 559                 }\r
 560         }\r
 561 }\r
 562 \r