mcs/class/corlib/Test/System/DecimalTest-Microsoft.cs

   1 // DecimalTest-Microsoft.cs - NUnit Test Cases for System.Decimal, ported
   2 // from corefx src/System.Runtime/tests/System/Decimal.cs to NUnit
   3 //
   4 // Copyright (c) Microsoft. All rights reserved.
   5 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
   6 // Copyright 2015 Xamarin Inc
   7 //
   8
   9 using NUnit.Framework;
  10 using System;
  11 using MonoTests.Common;
  12 using System.Globalization;
  13 using System.Runtime.CompilerServices;
  14 using System.Threading;
  15 using System.Collections.Generic;
  16
  17 #pragma warning disable CS1718
  18
  19 namespace MonoTests.System
  20 {
  21         [TestFixture]
  22         public class DecimalTestMicrosoft
  23         {
  24                 [Test]
  25                 public void TestEquals()
  26                 {
  27                     // Boolean Decimal.Equals(Decimal)
  28                     Assert.IsTrue(Decimal.Zero.Equals(Decimal.Zero));
  29                     Assert.IsFalse(Decimal.Zero.Equals(Decimal.One));
  30                     Assert.IsTrue(Decimal.MaxValue.Equals(Decimal.MaxValue));
  31                     Assert.IsTrue(Decimal.MinValue.Equals(Decimal.MinValue));
  32                     Assert.IsFalse(Decimal.MaxValue.Equals(Decimal.MinValue));
  33                     Assert.IsFalse(Decimal.MinValue.Equals(Decimal.MaxValue));
  34                 }
  35
  36                 [Test]
  37                 public void TestEqualsDecDec()
  38                 {
  39                     // Boolean Decimal.Equals(Decimal, Decimal)
  40                     Assert.IsTrue(Decimal.Equals(Decimal.Zero, Decimal.Zero));
  41                     Assert.IsFalse(Decimal.Equals(Decimal.Zero, Decimal.One));
  42                     Assert.IsTrue(Decimal.Equals(Decimal.MaxValue, Decimal.MaxValue));
  43                     Assert.IsTrue(Decimal.Equals(Decimal.MinValue, Decimal.MinValue));
  44                     Assert.IsFalse(Decimal.Equals(Decimal.MinValue, Decimal.MaxValue));
  45                     Assert.IsFalse(Decimal.Equals(Decimal.MaxValue, Decimal.MinValue));
  46                 }
  47
  48                 [Test]
  49                 public void TestEqualsObj()
  50                 {
  51                     // Boolean Decimal.Equals(Object)
  52                     Assert.IsTrue(Decimal.Zero.Equals((object)Decimal.Zero));
  53                     Assert.IsFalse(Decimal.Zero.Equals((object)Decimal.One));
  54                     Assert.IsTrue(Decimal.MaxValue.Equals((object)Decimal.MaxValue));
  55                     Assert.IsTrue(Decimal.MinValue.Equals((object)Decimal.MinValue));
  56                     Assert.IsFalse(Decimal.MinValue.Equals((object)Decimal.MaxValue));
  57                     Assert.IsFalse(Decimal.MaxValue.Equals((object)Decimal.MinValue));
  58                     Assert.IsFalse(Decimal.One.Equals(null));
  59                     Assert.IsFalse(Decimal.One.Equals("one"));
  60                     Assert.IsFalse(Decimal.One.Equals((object)1));
  61                 }
  62
  63                 [Test]
  64                 public void Testop_Equality()
  65                 {
  66                     // Boolean Decimal.op_Equality(Decimal, Decimal)
  67                     Assert.IsTrue(Decimal.Zero == Decimal.Zero);
  68                     Assert.IsFalse(Decimal.Zero == Decimal.One);
  69                     Assert.IsTrue(Decimal.MaxValue == Decimal.MaxValue);
  70                     Assert.IsTrue(Decimal.MinValue == Decimal.MinValue);
  71                     Assert.IsFalse(Decimal.MinValue == Decimal.MaxValue);
  72                     Assert.IsFalse(Decimal.MaxValue == Decimal.MinValue);
  73                 }
  74
  75                 [Test]
  76                 public void Testop_GreaterThan()
  77                 {
  78                     // Boolean Decimal.op_GreaterThan(Decimal, Decimal)
  79                     Assert.IsFalse(Decimal.Zero > Decimal.Zero);
  80                     Assert.IsFalse(Decimal.Zero > Decimal.One);
  81                     Assert.IsTrue(Decimal.One > Decimal.Zero);
  82                     Assert.IsFalse(Decimal.MaxValue > Decimal.MaxValue);
  83                     Assert.IsFalse(Decimal.MinValue > Decimal.MinValue);
  84                     Assert.IsFalse(Decimal.MinValue > Decimal.MaxValue);
  85                     Assert.IsTrue(Decimal.MaxValue > Decimal.MinValue);
  86                 }
  87
  88                 [Test]
  89                 public void Testop_GreaterThanOrEqual()
  90                 {
  91                     // Boolean Decimal.op_GreaterThanOrEqual(Decimal, Decimal)
  92                     Assert.IsTrue(Decimal.Zero >= Decimal.Zero);
  93                     Assert.IsFalse(Decimal.Zero >= Decimal.One);
  94                     Assert.IsTrue(Decimal.One >= Decimal.Zero);
  95                     Assert.IsTrue(Decimal.MaxValue >= Decimal.MaxValue);
  96                     Assert.IsTrue(Decimal.MinValue >= Decimal.MinValue);
  97                     Assert.IsFalse(Decimal.MinValue >= Decimal.MaxValue);
  98                     Assert.IsTrue(Decimal.MaxValue >= Decimal.MinValue);
  99                 }
 100
 101                 [Test]
 102                 public void Testop_Inequality()
 103                 {
 104                     // Boolean Decimal.op_Inequality(Decimal, Decimal)
 105                     Assert.IsFalse(Decimal.Zero != Decimal.Zero);
 106                     Assert.IsTrue(Decimal.Zero != Decimal.One);
 107                     Assert.IsTrue(Decimal.One != Decimal.Zero);
 108                     Assert.IsFalse(Decimal.MaxValue != Decimal.MaxValue);
 109                     Assert.IsFalse(Decimal.MinValue != Decimal.MinValue);
 110                     Assert.IsTrue(Decimal.MinValue != Decimal.MaxValue);
 111                     Assert.IsTrue(Decimal.MaxValue != Decimal.MinValue);
 112                 }
 113
 114                 [Test]
 115                 public void Testop_LessThan()
 116                 {
 117                     // Boolean Decimal.op_LessThan(Decimal, Decimal)
 118                     Assert.IsFalse(Decimal.Zero < Decimal.Zero);
 119                     Assert.IsTrue(Decimal.Zero < Decimal.One);
 120                     Assert.IsFalse(Decimal.One < Decimal.Zero);
 121                     Assert.IsTrue(5m < 15m);
 122                     decimal d5 = 5;
 123                     decimal d3 = 3;
 124                     Assert.IsFalse(d5 < d3);
 125                     Assert.IsFalse(Decimal.MaxValue < Decimal.MaxValue);
 126                     Assert.IsFalse(Decimal.MinValue < Decimal.MinValue);
 127                     Assert.IsTrue(Decimal.MinValue < Decimal.MaxValue);
 128                     Assert.IsFalse(Decimal.MaxValue < Decimal.MinValue);
 129                 }
 130
 131                 [Test]
 132                 public void Testop_LessThanOrEqual()
 133                 {
 134                     // Boolean Decimal.op_LessThanOrEqual(Decimal, Decimal)
 135                     Assert.IsTrue(Decimal.Zero <= Decimal.Zero);
 136                     Assert.IsTrue(Decimal.Zero <= Decimal.One);
 137                     Assert.IsFalse(Decimal.One <= Decimal.Zero);
 138                     Assert.IsTrue(Decimal.MaxValue <= Decimal.MaxValue);
 139                     Assert.IsTrue(Decimal.MinValue <= Decimal.MinValue);
 140                     Assert.IsTrue(Decimal.MinValue <= Decimal.MaxValue);
 141                     Assert.IsFalse(Decimal.MaxValue <= Decimal.MinValue);
 142                 }
 143
 144                 [Test]
 145                 public void TestToByte()
 146                 {
 147                     // Byte Decimal.ToByte(Decimal)
 148                     Assert.AreEqual(0, Decimal.ToByte(0));
 149                     Assert.AreEqual(1, Decimal.ToByte(1));
 150                     Assert.AreEqual(255, Decimal.ToByte(255));
 151
 152                     AssertExtensions.Throws<OverflowException>(() => Decimal.ToByte(256), "Expected an overflow");
 153                 }
 154
 155                 private void VerifyAdd<T>(Decimal d1, Decimal d2, Decimal expected = Decimal.Zero) where T : Exception
 156                 {
 157                     bool expectFailure = typeof(T) != typeof(Exception);
 158
 159                     try
 160                     {
 161                         Decimal result1 = Decimal.Add(d1, d2);
 162                         Decimal result2 = d1 + d2;
 163
 164                         Assert.IsFalse(expectFailure, "Expected an exception to be thrown");
 165                         Assert.AreEqual(result1, result2);
 166                         Assert.AreEqual(expected, result1);
 167                     }
 168                     catch (T)
 169                     {
 170                         Assert.IsTrue(expectFailure, "Didn't expect an exception to be thrown");
 171                     }
 172                 }
 173                 [Test]
 174                 public void TestAdd()
 175                 {
 176                     // Decimal Decimal.Add(Decimal, Decimal)
 177                     // Decimal Decimal.op_Addition(Decimal, Decimal)
 178                     VerifyAdd<Exception>(1, 1, 2);
 179                     VerifyAdd<Exception>(-1, 1, 0);
 180                     VerifyAdd<Exception>(1, -1, 0);
 181                     VerifyAdd<Exception>(Decimal.MaxValue, Decimal.Zero, Decimal.MaxValue);
 182                     VerifyAdd<Exception>(Decimal.MinValue, Decimal.Zero, Decimal.MinValue);
 183                     VerifyAdd<Exception>(79228162514264337593543950330m, 5, Decimal.MaxValue);
 184                     VerifyAdd<Exception>(79228162514264337593543950330m, -5, 79228162514264337593543950325m);
 185                     VerifyAdd<Exception>(-79228162514264337593543950330m, -5, Decimal.MinValue);
 186                     VerifyAdd<Exception>(-79228162514264337593543950330m, 5, -79228162514264337593543950325m);
 187                     VerifyAdd<Exception>(1234.5678m, 0.00009m, 1234.56789m);
 188                     VerifyAdd<Exception>(-1234.5678m, 0.00009m, -1234.56771m);
 189                     VerifyAdd<Exception>(0.1111111111111111111111111111m,
 190                                          0.1111111111111111111111111111m,
 191                                          0.2222222222222222222222222222m);
 192                     VerifyAdd<Exception>(0.5555555555555555555555555555m,
 193                                          0.5555555555555555555555555555m,
 194                                          1.1111111111111111111111111110m);
 195
 196                     // Exceptions
 197                     VerifyAdd<OverflowException>(Decimal.MaxValue, Decimal.MaxValue);
 198                     VerifyAdd<OverflowException>(79228162514264337593543950330m, 6);
 199                     VerifyAdd<OverflowException>(-79228162514264337593543950330m, -6, Decimal.MinValue);
 200                 }
 201
 202                 [Test]
 203                 public void TestCeiling()
 204                 {
 205                     // Decimal Decimal.Ceiling(Decimal)
 206                     Assert.AreEqual(123, Decimal.Ceiling((Decimal)123));
 207                     Assert.AreEqual(124, Decimal.Ceiling((Decimal)123.123));
 208                     Assert.AreEqual(-123, Decimal.Ceiling((Decimal)(-123.123)));
 209                     Assert.AreEqual(124, Decimal.Ceiling((Decimal)123.567));
 210                     Assert.AreEqual(-123, Decimal.Ceiling((Decimal)(-123.567)));
 211                 }
 212
 213                 private void VerifyDivide<T>(Decimal d1, Decimal d2, Decimal expected = Decimal.Zero) where T : Exception
 214                 {
 215                     bool expectFailure = typeof(T) != typeof(Exception);
 216
 217                     try
 218                     {
 219                         Decimal result1 = Decimal.Divide(d1, d2);
 220                         Decimal result2 = d1 / d2;
 221
 222                         Assert.IsFalse(expectFailure, "Expected an exception to be thrown");
 223                         Assert.AreEqual(result1, result2);
 224                         Assert.AreEqual(expected, result1);
 225                     }
 226                     catch (T)
 227                     {
 228                         Assert.IsTrue(expectFailure, "Didn't expect an exception to be thrown");
 229                     }
 230                 }
 231                 [Test]
 232                 public void TestDivide()
 233                 {
 234                     // Decimal Decimal.Divide(Decimal, Decimal)
 235                     // Decimal Decimal.op_Division(Decimal, Decimal)
 236
 237                     // Vanilla cases
 238                     VerifyDivide<Exception>(Decimal.One, Decimal.One, Decimal.One);
 239                     VerifyDivide<Exception>(Decimal.MaxValue, Decimal.MinValue, Decimal.MinusOne);
 240                     VerifyDivide<Exception>(0.9214206543486529434634231456m, Decimal.MaxValue, Decimal.Zero);
 241                     VerifyDivide<Exception>(38214206543486529434634231456m, 0.49214206543486529434634231456m, 77648730371625094566866001277m);
 242                     VerifyDivide<Exception>(-78228162514264337593543950335m, Decimal.MaxValue, -0.987378225516463811113412343m);
 243                     VerifyDivide<Exception>(5m + 10m, 2m, 7.5m);
 244                     VerifyDivide<Exception>(10m, 2m, 5m);
 245
 246                     // Tests near MaxValue (VSWhidbey #389382)
 247                     VerifyDivide<Exception>(792281625142643375935439503.4m, 0.1m, 7922816251426433759354395034m);
 248                     VerifyDivide<Exception>(79228162514264337593543950.34m, 0.1m, 792281625142643375935439503.4m);
 249                     VerifyDivide<Exception>(7922816251426433759354395.034m, 0.1m, 79228162514264337593543950.34m);
 250                     VerifyDivide<Exception>(792281625142643375935439.5034m, 0.1m, 7922816251426433759354395.034m);
 251                     VerifyDivide<Exception>(79228162514264337593543950335m, 10m, 7922816251426433759354395033.5m);
 252                     VerifyDivide<Exception>(79228162514264337567774146561m, 10m, 7922816251426433756777414656.1m);
 253                     VerifyDivide<Exception>(79228162514264337567774146560m, 10m, 7922816251426433756777414656m);
 254                     VerifyDivide<Exception>(79228162514264337567774146559m, 10m, 7922816251426433756777414655.9m);
 255                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.1m, 72025602285694852357767227577m);
 256                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.01m, 78443725261647859003508861718m);
 257                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.001m, 79149013500763574019524425909.091m);
 258                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.0001m, 79220240490215316061937756559.344m);
 259                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.00001m, 79227370240561931974224208092.919m);
 260                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.000001m, 79228083286181051412492537842.462m);
 261                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.0000001m, 79228154591448878448656105469.389m);
 262                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.00000001m, 79228161721982720373716746597.833m);
 263                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.000000001m, 79228162435036175158507775176.492m);
 264                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.0000000001m, 79228162506341521342909798200.709m);
 265                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.00000000001m, 79228162513472055968409229775.316m);
 266                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.000000000001m, 79228162514185109431029765225.569m);
 267                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.0000000000001m, 79228162514256414777292524693.522m);
 268                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.00000000000001m, 79228162514263545311918807699.547m);
 269                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.000000000000001m, 79228162514264258365381436070.742m);
 270                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.0000000000000001m, 79228162514264329670727698908.567m);
 271                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.00000000000000001m, 79228162514264336801262325192.357m);
 272                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.000000000000000001m, 79228162514264337514315787820.736m);
 273                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.0000000000000000001m, 79228162514264337585621134083.574m);
 274                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.00000000000000000001m, 79228162514264337592751668709.857m);
 275                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.000000000000000000001m, 79228162514264337593464722172.486m);
 276                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.0000000000000000000001m, 79228162514264337593536027518.749m);
 277                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.00000000000000000000001m, 79228162514264337593543158053.375m);
 278                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.000000000000000000000001m, 79228162514264337593543871106.837m);
 279                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.0000000000000000000000001m, 79228162514264337593543942412.184m);
 280                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.00000000000000000000000001m, 79228162514264337593543949542.718m);
 281                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.000000000000000000000000001m, 79228162514264337593543950255.772m);
 282                     VerifyDivide<Exception>(7922816251426433759354395033.5m, 0.9999999999999999999999999999m, 7922816251426433759354395034m);
 283                     VerifyDivide<Exception>(79228162514264337593543950335m, 10000000m, 7922816251426433759354.3950335m);
 284                     VerifyDivide<Exception>(7922816251426433759354395033.5m, 1.000001m, 7922808328618105141249253784.2m);
 285                     VerifyDivide<Exception>(7922816251426433759354395033.5m, 1.0000000000000000000000000001m, 7922816251426433759354395032.7m);
 286                     VerifyDivide<Exception>(7922816251426433759354395033.5m, 1.0000000000000000000000000002m, 7922816251426433759354395031.9m);
 287                     VerifyDivide<Exception>(7922816251426433759354395033.5m, 0.9999999999999999999999999999m, 7922816251426433759354395034m);
 288                     VerifyDivide<Exception>(79228162514264337593543950335m, 1.0000000000000000000000000001m, 79228162514264337593543950327m);
 289                     Decimal boundary7 = new Decimal((int)429u, (int)2133437386u, 0, false, 0);
 290                     Decimal boundary71 = new Decimal((int)429u, (int)2133437387u, 0, false, 0);
 291                     Decimal maxValueBy7 = Decimal.MaxValue * 0.0000001m;
 292                     VerifyDivide<Exception>(maxValueBy7, 1m, maxValueBy7);
 293                     VerifyDivide<Exception>(maxValueBy7, 1m, maxValueBy7);
 294                     VerifyDivide<Exception>(maxValueBy7, 0.0000001m, Decimal.MaxValue);
 295                     VerifyDivide<Exception>(boundary7, 1m, boundary7);
 296                     VerifyDivide<Exception>(boundary7, 0.000000100000000000000000001m, 91630438009337286849083695.62m);
 297                     VerifyDivide<Exception>(boundary71, 0.000000100000000000000000001m, 91630438052286959809083695.62m);
 298                     VerifyDivide<Exception>(7922816251426433759354.3950335m, 1m, 7922816251426433759354.3950335m);
 299                     VerifyDivide<Exception>(7922816251426433759354.3950335m, 0.0000001m, 79228162514264337593543950335m);
 300
 301                     //[] DivideByZero exceptions
 302                     VerifyDivide<DivideByZeroException>(Decimal.One, Decimal.Zero);
 303                     VerifyDivide<DivideByZeroException>(Decimal.Zero, Decimal.Zero);
 304                     VerifyDivide<DivideByZeroException>(-5.00m, (-1m) * Decimal.Zero);
 305                     VerifyDivide<DivideByZeroException>(0.0m, -0.00m);
 306
 307                     //[] Overflow exceptions
 308                     VerifyDivide<OverflowException>(79228162514264337593543950335m, -0.9999999999999999999999999m);
 309                     VerifyDivide<OverflowException>(792281625142643.37593543950335m, 0.0000000000000079228162514264337593543950335m);
 310                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.1m);
 311                     VerifyDivide<OverflowException>(7922816251426433759354395034m, 0.1m);
 312                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.9m);
 313                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.99m);
 314                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.999m);
 315                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.9999m);
 316                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.99999m);
 317                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.999999m);
 318                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.9999999m);
 319                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.99999999m);
 320                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.999999999m);
 321                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.9999999999m);
 322                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.99999999999m);
 323                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.999999999999m);
 324                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.9999999999999m);
 325                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.99999999999999m);
 326                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.999999999999999m);
 327                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.9999999999999999m);
 328                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.99999999999999999m);
 329                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.999999999999999999m);
 330                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.9999999999999999999m);
 331                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.99999999999999999999m);
 332                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.999999999999999999999m);
 333                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.9999999999999999999999m);
 334                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.99999999999999999999999m);
 335                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.999999999999999999999999m);
 336                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.9999999999999999999999999m);
 337                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.99999999999999999999999999m);
 338                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.999999999999999999999999999m);
 339                     VerifyDivide<OverflowException>(79228162514264337593543950335m, 0.9999999999999999999999999999m);
 340                     VerifyDivide<OverflowException>(79228162514264337593543950335m, -0.1m);
 341                     VerifyDivide<OverflowException>(79228162514264337593543950335m, -0.9999999999999999999999999m);
 342                     VerifyDivide<OverflowException>(Decimal.MaxValue / 2, 0.5m);
 343                 }
 344
 345                 [Test]
 346                 public void TestFloor()
 347                 {
 348                     // Decimal Decimal.Floor(Decimal)
 349                     Assert.AreEqual(123, Decimal.Floor((Decimal)123));
 350                     Assert.AreEqual(123, Decimal.Floor((Decimal)123.123));
 351                     Assert.AreEqual(-124, Decimal.Floor((Decimal)(-123.123)));
 352                     Assert.AreEqual(123, Decimal.Floor((Decimal)123.567));
 353                     Assert.AreEqual(-124, Decimal.Floor((Decimal)(-123.567)));
 354                 }
 355
 356                 [Test]
 357                 public void TestMaxValue()
 358                 {
 359                     // Decimal Decimal.MaxValue
 360                     Assert.AreEqual(Decimal.MaxValue, 79228162514264337593543950335m);
 361                 }
 362
 363                 [Test]
 364                 public void TestMinusOne()
 365                 {
 366                     // Decimal Decimal.MinusOne
 367                     Assert.AreEqual(Decimal.MinusOne, -1);
 368                 }
 369
 370                 [Test]
 371                 public void TestZero()
 372                 {
 373                     // Decimal Decimal.Zero
 374                     Assert.AreEqual(Decimal.Zero, 0);
 375                 }
 376
 377                 [Test]
 378                 public void TestOne()
 379                 {
 380                     // Decimal Decimal.One
 381                     Assert.AreEqual(Decimal.One, 1);
 382                 }
 383
 384                 [Test]
 385                 public void TestMinValue()
 386                 {
 387                     // Decimal Decimal.MinValue
 388                     Assert.AreEqual(Decimal.MinValue, -79228162514264337593543950335m);
 389                 }
 390
 391                 private void VerifyMultiply<T>(Decimal d1, Decimal d2, Decimal expected = Decimal.Zero) where T : Exception
 392                 {
 393                     bool expectFailure = typeof(T) != typeof(Exception);
 394
 395                     try
 396                     {
 397                         Decimal result1 = Decimal.Multiply(d1, d2);
 398                         Decimal result2 = d1 * d2;
 399
 400                         Assert.IsFalse(expectFailure, "Expected an exception to be thrown");
 401                         Assert.AreEqual(result1, result2);
 402                         Assert.AreEqual(expected, result1);
 403                     }
 404                     catch (T)
 405                     {
 406                         Assert.IsTrue(expectFailure, "Didn't expect an exception to be thrown");
 407                     }
 408                 }
 409
 410                 [Test]
 411                 public void TestMultiply()
 412                 {
 413                     // Decimal Decimal.Multiply(Decimal, Decimal)
 414                     // Decimal Decimal.op_Multiply(Decimal, Decimal)
 415
 416                     VerifyMultiply<Exception>(Decimal.One, Decimal.One, Decimal.One);
 417                     VerifyMultiply<Exception>(7922816251426433759354395033.5m, new Decimal(10), Decimal.MaxValue);
 418                     VerifyMultiply<Exception>(0.2352523523423422342354395033m, 56033525474612414574574757495m, 13182018677937129120135020796m);
 419                     VerifyMultiply<Exception>(46161363632634613634.093453337m, 461613636.32634613634083453337m, 21308714924243214928823669051m);
 420                     VerifyMultiply<Exception>(0.0000000000000345435353453563m, .0000000000000023525235234234m, 0.0000000000000000000000000001m);
 421
 422                     // Near MaxValue
 423                     VerifyMultiply<Exception>(79228162514264337593543950335m, 0.9m, 71305346262837903834189555302m);
 424                     VerifyMultiply<Exception>(79228162514264337593543950335m, 0.99m, 78435880889121694217608510832m);
 425                     VerifyMultiply<Exception>(79228162514264337593543950335m, 0.9999999999999999999999999999m, 79228162514264337593543950327m);
 426                     VerifyMultiply<Exception>(-79228162514264337593543950335m, 0.9m, -71305346262837903834189555302m);
 427                     VerifyMultiply<Exception>(-79228162514264337593543950335m, 0.99m, -78435880889121694217608510832m);
 428                     VerifyMultiply<Exception>(-79228162514264337593543950335m, 0.9999999999999999999999999999m, -79228162514264337593543950327m);
 429
 430                     // Exceptions
 431                     VerifyMultiply<OverflowException>(Decimal.MaxValue, Decimal.MinValue);
 432                     VerifyMultiply<OverflowException>(Decimal.MinValue, 1.1m);
 433                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.1m);
 434                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.01m);
 435                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.001m);
 436                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.0001m);
 437                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.00001m);
 438                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.000001m);
 439                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.0000001m);
 440                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.00000001m);
 441                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.000000001m);
 442                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.0000000001m);
 443                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.00000000001m);
 444                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.000000000001m);
 445                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.0000000000001m);
 446                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.00000000000001m);
 447                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.000000000000001m);
 448                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.0000000000000001m);
 449                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.00000000000000001m);
 450                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.000000000000000001m);
 451                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.0000000000000000001m);
 452                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.00000000000000000001m);
 453                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.000000000000000000001m);
 454                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.0000000000000000000001m);
 455                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.00000000000000000000001m);
 456                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.000000000000000000000001m);
 457                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.0000000000000000000000001m);
 458                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.00000000000000000000000001m);
 459                     VerifyMultiply<OverflowException>(79228162514264337593543950335m, 1.000000000000000000000000001m);
 460                     VerifyMultiply<OverflowException>(Decimal.MaxValue / 2, 2m);
 461                 }
 462
 463                 [Test]
 464                 public void TestNegate()
 465                 {
 466                     // Decimal Decimal.Negate(Decimal)
 467                     Assert.AreEqual(0, Decimal.Negate(0));
 468                     Assert.AreEqual(1, Decimal.Negate(-1));
 469                     Assert.AreEqual(-1, Decimal.Negate(1));
 470                 }
 471
 472                 [Test]
 473                 public void Testop_Decrement()
 474                 {
 475                     // Decimal Decimal.op_Decrement(Decimal)
 476                     Decimal d = 12345;
 477                     Assert.AreEqual(12344, --d);
 478                     d = 12345.678m;
 479                     Assert.AreEqual(12344.678m, --d);
 480                     d = -12345;
 481                     Assert.AreEqual(-12346, --d);
 482                     d = -12345.678m;
 483                     Assert.AreEqual(-12346.678m, --d);
 484                 }
 485
 486                 [Test]
 487                 public void Testop_Increment()
 488                 {
 489                     // Decimal Decimal.op_Increment(Decimal)
 490                     Decimal d = 12345;
 491                     Assert.AreEqual(12346, ++d);
 492                     d = 12345.678m;
 493                     Assert.AreEqual(12346.678m, ++d);
 494                     d = -12345;
 495                     Assert.AreEqual(-12344m, ++d);
 496                     d = -12345.678m;
 497                     Assert.AreEqual(-12344.678m, ++d);
 498                 }
 499
 500                 [Test]
 501                 [SetCulture ("en")]
 502                 public void TestParse()
 503                 {
 504                     // Boolean Decimal.TryParse(String, NumberStyles, IFormatProvider, Decimal)
 505                     Assert.AreEqual(123, Decimal.Parse("123"));
 506                     Assert.AreEqual(-123, Decimal.Parse("-123"));
 507                     Assert.AreEqual(123.123m, Decimal.Parse("123.123"));
 508                     Assert.AreEqual(-123.123m, Decimal.Parse("-123.123"));
 509
 510                     Decimal d;
 511                     Assert.IsTrue(Decimal.TryParse("79228162514264337593543950335", out d));
 512                     Assert.AreEqual(Decimal.MaxValue, d);
 513
 514                     Assert.IsTrue(Decimal.TryParse("-79228162514264337593543950335", out d));
 515                     Assert.AreEqual(Decimal.MinValue, d);
 516
 517                     Assert.IsTrue(Decimal.TryParse("79,228,162,514,264,337,593,543,950,335", NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo, out d));
 518                     Assert.AreEqual(Decimal.MaxValue, d);
 519
 520                     Assert.IsFalse(Decimal.TryParse("ysaidufljasdf", out d));
 521                     Assert.IsFalse(Decimal.TryParse("79228162514264337593543950336", out d));
 522                 }
 523
 524                 private void VerifyRemainder(Decimal d1, Decimal d2, Decimal expectedResult)
 525                 {
 526                     Decimal result1 = Decimal.Remainder(d1, d2);
 527                     Decimal result2 = d1 % d2;
 528
 529                     Assert.AreEqual(result1, result2);
 530                     Assert.AreEqual(expectedResult, result1);
 531                 }
 532
 533                 [Test]
 534                 public void TestRemainder()
 535                 {
 536                     // Decimal Decimal.Remainder(Decimal, Decimal)
 537                     // Decimal Decimal.op_Modulus(Decimal, Decimal)
 538                     Decimal NegativeZero = new Decimal(0, 0, 0, true, 0);
 539                     VerifyRemainder(5m, 3m, 2m);
 540                     VerifyRemainder(5m, -3m, 2m);
 541                     VerifyRemainder(-5m, 3m, -2m);
 542                     VerifyRemainder(-5m, -3m, -2m);
 543                     VerifyRemainder(3m, 5m, 3m);
 544                     VerifyRemainder(3m, -5m, 3m);
 545                     VerifyRemainder(-3m, 5m, -3m);
 546                     VerifyRemainder(-3m, -5m, -3m);
 547                     VerifyRemainder(10m, -3m, 1m);
 548                     VerifyRemainder(-10m, 3m, -1m);
 549                     VerifyRemainder(-2.0m, 0.5m, -0.0m);
 550                     VerifyRemainder(2.3m, 0.531m, 0.176m);
 551                     VerifyRemainder(0.00123m, 3242m, 0.00123m);
 552                     VerifyRemainder(3242m, 0.00123m, 0.00044m);
 553                     VerifyRemainder(17.3m, 3m, 2.3m);
 554                     VerifyRemainder(8.55m, 2.25m, 1.80m);
 555                     VerifyRemainder(0.00m, 3m, 0.00m);
 556                     VerifyRemainder(NegativeZero, 2.2m, NegativeZero);
 557
 558                     // [] Max/Min
 559                     VerifyRemainder(Decimal.MaxValue, Decimal.MaxValue, 0m);
 560                     VerifyRemainder(Decimal.MaxValue, Decimal.MinValue, 0m);
 561                     VerifyRemainder(Decimal.MaxValue, 1, 0m);
 562                     VerifyRemainder(Decimal.MaxValue, 2394713m, 1494647m);
 563                     VerifyRemainder(Decimal.MaxValue, -32768m, 32767m);
 564                     VerifyRemainder(-0.00m, Decimal.MaxValue, -0.00m);
 565                     VerifyRemainder(1.23984m, Decimal.MaxValue, 1.23984m);
 566                     VerifyRemainder(2398412.12983m, Decimal.MaxValue, 2398412.12983m);
 567                     VerifyRemainder(-0.12938m, Decimal.MaxValue, -0.12938m);
 568
 569                     VerifyRemainder(Decimal.MinValue, Decimal.MinValue, NegativeZero);
 570                     VerifyRemainder(Decimal.MinValue, Decimal.MaxValue, NegativeZero);
 571                     VerifyRemainder(Decimal.MinValue, 1, NegativeZero);
 572                     VerifyRemainder(Decimal.MinValue, 2394713m, -1494647m);
 573                     VerifyRemainder(Decimal.MinValue, -32768m, -32767m); // ASURT #90921
 574                     VerifyRemainder(0.0m, Decimal.MinValue, 0.0m);
 575                     VerifyRemainder(1.23984m, Decimal.MinValue, 1.23984m);
 576                     VerifyRemainder(2398412.12983m, Decimal.MinValue, 2398412.12983m);
 577                     VerifyRemainder(-0.12938m, Decimal.MinValue, -0.12938m);
 578
 579                     VerifyRemainder(57675350989891243676868034225m, 7m, 5m); // VSWhidbey #325142
 580                     VerifyRemainder(-57675350989891243676868034225m, 7m, -5m);
 581                     VerifyRemainder(57675350989891243676868034225m, -7m, 5m);
 582                     VerifyRemainder(-57675350989891243676868034225m, -7m, -5m);
 583
 584                     // VSWhidbey #389382
 585                     VerifyRemainder(792281625142643375935439503.4m, 0.1m, 0.0m);
 586                     VerifyRemainder(79228162514264337593543950.34m, 0.1m, 0.04m);
 587                     VerifyRemainder(7922816251426433759354395.034m, 0.1m, 0.034m);
 588                     VerifyRemainder(792281625142643375935439.5034m, 0.1m, 0.0034m);
 589                     VerifyRemainder(79228162514264337593543950335m, 10m, 5m);
 590                     VerifyRemainder(79228162514264337567774146561m, 10m, 1m);
 591                     VerifyRemainder(79228162514264337567774146560m, 10m, 0m);
 592                     VerifyRemainder(79228162514264337567774146559m, 10m, 9m);
 593                 }
 594
 595                 private void VerifySubtract<T>(Decimal d1, Decimal d2, Decimal expected = Decimal.Zero) where T : Exception
 596                 {
 597                     bool expectFailure = typeof(T) != typeof(Exception);
 598
 599                     try
 600                     {
 601                         Decimal result1 = Decimal.Subtract(d1, d2);
 602                         Decimal result2 = d1 - d2;
 603
 604                         Assert.IsFalse(expectFailure, "Expected an exception to be thrown");
 605                         Assert.AreEqual(result1, result2);
 606                         Assert.AreEqual(expected, result1);
 607                     }
 608                     catch (T)
 609                     {
 610                         Assert.IsTrue(expectFailure, "Didn't expect an exception to be thrown");
 611                     }
 612                 }
 613
 614                 [Test]
 615                 public void TestSubtract()
 616                 {
 617                     // Decimal Decimal.Subtract(Decimal, Decimal)
 618                     // Decimal Decimal.op_Subtraction(Decimal, Decimal)
 619
 620                     VerifySubtract<Exception>(1, 1, 0);
 621                     VerifySubtract<Exception>(-1, 1, -2);
 622                     VerifySubtract<Exception>(1, -1, 2);
 623                     VerifySubtract<Exception>(Decimal.MaxValue, Decimal.Zero, Decimal.MaxValue);
 624                     VerifySubtract<Exception>(Decimal.MinValue, Decimal.Zero, Decimal.MinValue);
 625                     VerifySubtract<Exception>(79228162514264337593543950330m, -5, Decimal.MaxValue);
 626                     VerifySubtract<Exception>(79228162514264337593543950330m, 5, 79228162514264337593543950325m);
 627                     VerifySubtract<Exception>(-79228162514264337593543950330m, 5, Decimal.MinValue);
 628                     VerifySubtract<Exception>(-79228162514264337593543950330m, -5, -79228162514264337593543950325m);
 629                     VerifySubtract<Exception>(1234.5678m, 0.00009m, 1234.56771m);
 630                     VerifySubtract<Exception>(-1234.5678m, 0.00009m, -1234.56789m);
 631                     VerifySubtract<Exception>(0.1111111111111111111111111111m, 0.1111111111111111111111111111m, 0);
 632                     VerifySubtract<Exception>(0.2222222222222222222222222222m,
 633                                          0.1111111111111111111111111111m,
 634                                          0.1111111111111111111111111111m);
 635                     VerifySubtract<Exception>(1.1111111111111111111111111110m,
 636                                          0.5555555555555555555555555555m,
 637                                          0.5555555555555555555555555555m);
 638                 }
 639
 640                 [Test]
 641                 public void TestTruncate()
 642                 {
 643                     // Decimal Decimal.Truncate(Decimal)
 644                     Assert.AreEqual(123, Decimal.Truncate((Decimal)123));
 645                     Assert.AreEqual(123, Decimal.Truncate((Decimal)123.123));
 646                     Assert.AreEqual(-123, Decimal.Truncate((Decimal)(-123.123)));
 647                     Assert.AreEqual(123, Decimal.Truncate((Decimal)123.567));
 648                     Assert.AreEqual(-123, Decimal.Truncate((Decimal)(-123.567)));
 649                 }
 650
 651                 [Test]
 652                 public void TestRound()
 653                 {
 654                     // Decimal Decimal.Truncate(Decimal)
 655                     // Assert.AreEqual<Decimal>(123, Decimal.Round((Decimal)123, 2));
 656                     // Assert.AreEqual<Decimal>((Decimal)123.123, Decimal.Round((Decimal)123.123, 3));
 657                     // Assert.AreEqual<Decimal>((Decimal)(-123.1), Decimal.Round((Decimal)(-123.123), 1));
 658                     // Assert.AreEqual<Decimal>(124, Decimal.Round((Decimal)123.567, 0));
 659                     // Assert.AreEqual<Decimal>((Decimal)(-123.567), Decimal.Round((Decimal)(-123.567), 4));
 660                 }
 661
 662                 [Test]
 663                 public void TestCompare()
 664                 {
 665                     // Int32 Decimal.Compare(Decimal, Decimal)
 666                     Assert.IsTrue(Decimal.Compare(Decimal.Zero, Decimal.Zero) == 0);
 667                     Assert.IsTrue(Decimal.Compare(Decimal.Zero, Decimal.One) < 0);
 668                     Assert.IsTrue(Decimal.Compare(Decimal.One, Decimal.Zero) > 0);
 669                     Assert.IsTrue(Decimal.Compare(Decimal.MinusOne, Decimal.Zero) < 0);
 670                     Assert.IsTrue(Decimal.Compare(Decimal.Zero, Decimal.MinusOne) > 0);
 671                     Assert.IsTrue(Decimal.Compare(5, 3) > 0);
 672                     Assert.IsTrue(Decimal.Compare(5, 5) == 0);
 673                     Assert.IsTrue(Decimal.Compare(5, 9) < 0);
 674                     Assert.IsTrue(Decimal.Compare(-123.123m, 123.123m) < 0);
 675                     Assert.IsTrue(Decimal.Compare(Decimal.MaxValue, Decimal.MaxValue) == 0);
 676                     Assert.IsTrue(Decimal.Compare(Decimal.MinValue, Decimal.MinValue) == 0);
 677                     Assert.IsTrue(Decimal.Compare(Decimal.MinValue, Decimal.MaxValue) < 0);
 678                     Assert.IsTrue(Decimal.Compare(Decimal.MaxValue, Decimal.MinValue) > 0);
 679                 }
 680
 681                 [Test]
 682                 public void TestCompareTo()
 683                 {
 684                     // Int32 Decimal.CompareTo(Decimal)
 685                     Decimal d = 456;
 686                     Assert.IsTrue(d.CompareTo(456m) == 0);
 687                     Assert.IsTrue(d.CompareTo(457m) < 0);
 688                     Assert.IsTrue(d.CompareTo(455m) > 0);
 689                 }
 690
 691                 [Test]
 692                 public void TestSystemIComparableCompareTo()
 693                 {
 694                     // Int32 Decimal.System.IComparable.CompareTo(Object)
 695                     IComparable d = (Decimal)248;
 696                     Assert.IsTrue(d.CompareTo(248m) == 0);
 697                     Assert.IsTrue(d.CompareTo(249m) < 0);
 698                     Assert.IsTrue(d.CompareTo(247m) > 0);
 699                     Assert.IsTrue(d.CompareTo(null) > 0);
 700
 701                     AssertExtensions.Throws<ArgumentException>(() => d.CompareTo("248"), "Expected an argument exception");
 702                 }
 703
 704                 [Test]
 705                 public void TestGetHashCode()
 706                 {
 707                     // Int32 Decimal.GetHashCode()
 708                     Assert.AreNotEqual(Decimal.MinusOne.GetHashCode(), Decimal.One.GetHashCode());
 709                 }
 710
 711                 [Test]
 712                 public void TestToSingle()
 713                 {
 714                     // Single Decimal.ToSingle(Decimal)
 715                     Single s = 12345.12f;
 716                     Assert.AreEqual(s, Decimal.ToSingle((Decimal)s));
 717                     Assert.AreEqual(-s, Decimal.ToSingle((Decimal)(-s)));
 718
 719                     s = 1e20f;
 720                     Assert.AreEqual(s, Decimal.ToSingle((Decimal)s));
 721                     Assert.AreEqual(-s, Decimal.ToSingle((Decimal)(-s)));
 722
 723                     s = 1e27f;
 724                     Assert.AreEqual(s, Decimal.ToSingle((Decimal)s));
 725                     Assert.AreEqual(-s, Decimal.ToSingle((Decimal)(-s)));
 726                 }
 727
 728                 [Test]
 729                 public void TestToDouble()
 730                 {
 731                     Double d = Decimal.ToDouble(new Decimal(0, 0, 1, false, 0));
 732
 733                     // Double Decimal.ToDouble(Decimal)
 734                     Double dbl = 123456789.123456;
 735                     Assert.AreEqual(dbl, Decimal.ToDouble((Decimal)dbl));
 736                     Assert.AreEqual(-dbl, Decimal.ToDouble((Decimal)(-dbl)));
 737
 738                     dbl = 1e20;
 739                     Assert.AreEqual(dbl, Decimal.ToDouble((Decimal)dbl));
 740                     Assert.AreEqual(-dbl, Decimal.ToDouble((Decimal)(-dbl)));
 741
 742                     dbl = 1e27;
 743                     Assert.AreEqual(dbl, Decimal.ToDouble((Decimal)dbl));
 744                     Assert.AreEqual(-dbl, Decimal.ToDouble((Decimal)(-dbl)));
 745
 746                     dbl = Int64.MaxValue;
 747                     // Need to pass in the Int64.MaxValue to ToDouble and not dbl because the conversion to double is a little lossy and we want precision
 748                     Assert.AreEqual(dbl, Decimal.ToDouble((Decimal)Int64.MaxValue));
 749                     Assert.AreEqual(-dbl, Decimal.ToDouble((Decimal)(-Int64.MaxValue)));
 750                 }
 751
 752                 [Test]
 753                 public void TestToInt16()
 754                 {
 755                     // Int16 Decimal.ToInt16(Decimal)
 756                     Assert.AreEqual(Int16.MaxValue, Decimal.ToInt16((Decimal)Int16.MaxValue));
 757                     Assert.AreEqual(Int16.MinValue, Decimal.ToInt16((Decimal)Int16.MinValue));
 758                 }
 759
 760                 [Test]
 761                 public void TestToInt32()
 762                 {
 763                     // Int32 Decimal.ToInt32(Decimal)
 764                     Assert.AreEqual(Int32.MaxValue, Decimal.ToInt32((Decimal)Int32.MaxValue));
 765                     Assert.AreEqual(Int32.MinValue, Decimal.ToInt32((Decimal)Int32.MinValue));
 766                 }
 767
 768                 [Test]
 769                 public void TestGetBits()
 770                 {
 771                     // Int32[] Decimal.GetBits(Decimal)
 772                 }
 773
 774                 [Test]
 775                 public void TestToInt64()
 776                 {
 777                     // Int64 Decimal.ToInt64(Decimal)
 778                     Assert.AreEqual(Int64.MaxValue, Decimal.ToInt64((Decimal)Int64.MaxValue));
 779                     Assert.AreEqual(Int64.MinValue, Decimal.ToInt64((Decimal)Int64.MinValue));
 780                 }
 781
 782                 [Test]
 783                 public void TestToSByte()
 784                 {
 785                     // SByte Decimal.ToSByte(Decimal)
 786                     Assert.AreEqual(SByte.MaxValue, Decimal.ToSByte((Decimal)SByte.MaxValue));
 787                     Assert.AreEqual(SByte.MinValue, Decimal.ToSByte((Decimal)SByte.MinValue));
 788                 }
 789
 790                 [Test]
 791                 public void TestToUInt16()
 792                 {
 793                     // UInt16 Decimal.ToUInt16(Decimal)
 794                     Assert.AreEqual(UInt16.MaxValue, Decimal.ToUInt16((Decimal)UInt16.MaxValue));
 795                     Assert.AreEqual(UInt16.MinValue, Decimal.ToUInt16((Decimal)UInt16.MinValue));
 796                 }
 797
 798                 [Test]
 799                 public void TestToUInt32()
 800                 {
 801                     // UInt32 Decimal.ToUInt32(Decimal)
 802                     Assert.AreEqual(UInt32.MaxValue, Decimal.ToUInt32((Decimal)UInt32.MaxValue));
 803                     Assert.AreEqual(UInt32.MinValue, Decimal.ToUInt32((Decimal)UInt32.MinValue));
 804                 }
 805
 806                 [Test]
 807                 public void TestToUInt64()
 808                 {
 809                     // UInt64 Decimal.ToUInt64(Decimal)
 810                     Assert.AreEqual(UInt64.MaxValue, Decimal.ToUInt64((Decimal)UInt64.MaxValue));
 811                     Assert.AreEqual(UInt64.MinValue, Decimal.ToUInt64((Decimal)UInt64.MinValue));
 812                 }
 813
 814                 [Test]
 815                 [SetCulture ("en")]
 816                 public void TestToString()
 817                 {
 818                     // String Decimal.ToString()
 819                     Decimal d1 = 6310.23m;
 820                     Assert.AreEqual("6310.23", d1.ToString());
 821
 822                     Decimal d2 = -8249.000003m;
 823                     Assert.AreEqual("-8249.000003", d2.ToString());
 824
 825                     Assert.AreEqual("79228162514264337593543950335", Decimal.MaxValue.ToString());
 826                     Assert.AreEqual("-79228162514264337593543950335", Decimal.MinValue.ToString());
 827                 }
 828
 829                 [Test]
 830                 public void Testctor()
 831                 {
 832                     Decimal d;
 833                     // Void Decimal..ctor(Double)
 834                     d = new Decimal((Double)123456789.123456);
 835                     Assert.AreEqual(d, (Decimal)123456789.123456);
 836
 837                     // Void Decimal..ctor(Int32)
 838                     d = new Decimal((Int32)Int32.MaxValue);
 839                     Assert.AreEqual(d, Int32.MaxValue);
 840
 841                     // Void Decimal..ctor(Int64)
 842                     d = new Decimal((Int64)Int64.MaxValue);
 843                     Assert.AreEqual(d, Int64.MaxValue);
 844
 845                     // Void Decimal..ctor(Single)
 846                     d = new Decimal((Single)123.123);
 847                     Assert.AreEqual(d, (Decimal)123.123);
 848
 849                     // Void Decimal..ctor(UInt32)
 850                     d = new Decimal((UInt32)UInt32.MaxValue);
 851                     Assert.AreEqual(d, UInt32.MaxValue);
 852
 853                     // Void Decimal..ctor(UInt64)
 854                     d = new Decimal((UInt64)UInt64.MaxValue);
 855                     Assert.AreEqual(d, UInt64.MaxValue);
 856
 857                     // Void Decimal..ctor(Int32, Int32, Int32, Boolean, Byte)
 858                     d = new Decimal(1, 1, 1, false, 0);
 859                     Decimal d2 = 3;
 860                     d2 += UInt32.MaxValue;
 861                     d2 += UInt64.MaxValue;
 862                     Assert.AreEqual(d, d2);
 863
 864                     // Void Decimal..ctor(Int32[])
 865                     d = new Decimal(new Int32[] { 1, 1, 1, 0 });
 866                     Assert.AreEqual(d, d2);
 867                 }
 868
 869                 [Test]
 870                 [SetCulture ("en")]
 871                 public void TestNumberBufferLimit()
 872                 {
 873                     Decimal dE = 1234567890123456789012345.6785m;
 874                     string s1 = "1234567890123456789012345.678456";
 875                     Decimal d1 = Decimal.Parse(s1);
 876                     Assert.AreEqual(d1, dE);
 877                     return;
 878                 }
 879         }
 880 }