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