public void Signum()
{
BigDecimal sign = new BigDecimal(123E-104);
Assert.True(sign.Sign == 1, "123E-104 is not positive in signum()");
sign = BigDecimal.Parse("-1234.3959");
Assert.True(sign.Sign == -1, "-1234.3959 is not negative in signum()");
sign = new BigDecimal(000D);
Assert.True(sign.Sign == 0, "000D is not zero in signum()");
}
public void Abs()
{
BigDecimal big = BigDecimal.Parse("-1234");
BigDecimal bigabs = BigMath.Abs(big);
Assert.True(bigabs.ToString().Equals("1234"), "the absolute value of -1234 is not 1234");
big = new BigDecimal(BigInteger.Parse("2345"), 2);
bigabs = BigMath.Abs(big);
Assert.True(bigabs.ToString().Equals("23.45"), "the absolute value of 23.45 is not 23.45");
}
public void Negate()
{
BigDecimal negate1 = new BigDecimal(value2, 7);
Assert.True((-negate1).ToString().Equals("-1233.4560000"), "the negate of 1233.4560000 is not -1233.4560000");
negate1 = BigDecimal.Parse("-23465839");
Assert.True((-negate1).ToString().Equals("23465839"), "the negate of -23465839 is not 23465839");
negate1 = new BigDecimal(-3.456E6);
Assert.True((-(-negate1)).Equals(negate1), "the negate of -3.456E6 is not 3.456E6");
}
public void ToInt64()
{
BigDecimal long1 = new BigDecimal(value2.Negate(), 0);
Assert.IsTrue(long1.ToInt64() == -12334560000L, "the long value of 12334560000 is not 12334560000");
long1 = new BigDecimal(-1345.348E-123D);
Assert.IsTrue(long1.ToInt64() == 0, "the long value of -1345.348E-123D is not zero");
long1 = BigDecimal.Parse("31323423423419083091823091283933");
// ran JDK and found representation for the above was
// -5251313250005125155
Assert.IsTrue(long1.ToInt64() == -5251313250005125155L, "the long value of 31323423423419083091823091283933 is wrong");
}
public void ToInt32()
{
BigDecimal int1 = new BigDecimal(value, 3);
Assert.IsTrue(int1.ToInt32() == 12345, "the int value of 12345.908 is not 12345");
int1 = BigDecimal.Parse("1.99");
Assert.IsTrue(int1.ToInt32() == 1, "the int value of 1.99 is not 1");
int1 = BigDecimal.Parse("23423419083091823091283933");
// ran JDK and found representation for the above was -249268259
Assert.IsTrue(int1.ToInt32() == -249268259, "the int value of 23423419083091823091283933 is wrong");
int1 = new BigDecimal(-1235D);
Assert.IsTrue(int1.ToInt32() == -1235, "the int value of -1235 is not -1235");
}
public void TestToString()
{
BigDecimal toString1 = BigDecimal.Parse("1234.000");
Assert.IsTrue(toString1.ToString().Equals("1234.000"), "the ToString representation of 1234.000 is wrong");
toString1 = BigDecimal.Parse("-123.4E-5");
Assert.IsTrue(toString1.ToString().Equals("-0.001234"),
"the ToString representation of -123.4E-5 is wrong: " + toString1);
toString1 = BigDecimal.Parse("-1.455E-20");
Assert.IsTrue(toString1.ToString().Equals("-1.455E-20"), "the ToString representation of -1.455E-20 is wrong");
toString1 = new BigDecimal(value2, 4);
Assert.IsTrue(toString1.ToString().Equals("1233456.0000"), "the ToString representation of 1233456.0000 is wrong");
}
public void UnscaledValue()
{
BigDecimal unsVal = BigDecimal.Parse("-2839485.000");
Assert.IsTrue(unsVal.UnscaledValue.ToString().Equals("-2839485000"), "the unscaledValue of -2839485.000 is wrong");
unsVal = new BigDecimal(123E10);
Assert.IsTrue(unsVal.UnscaledValue.ToString().Equals("1230000000000"), "the unscaledValue of 123E10 is wrong");
unsVal = BigDecimal.Parse("-4.56E-13");
Assert.IsTrue(unsVal.UnscaledValue.ToString().Equals("-456"),
"the unscaledValue of -4.56E-13 is wrong: " + unsVal.UnscaledValue);
unsVal = new BigDecimal(value, 3);
Assert.IsTrue(unsVal.UnscaledValue.ToString().Equals("12345908"), "the unscaledValue of 12345.908 is wrong");
}
public void ParseString()
{
BigDecimal big = BigDecimal.Parse("345.23499600293850");
Assert.IsTrue(big.ToString().Equals("345.23499600293850") && big.Scale == 14,
"the BigDecimal value is not initialized properly");
big = BigDecimal.Parse("-12345");
Assert.IsTrue(big.ToString().Equals("-12345") && big.Scale == 0, "the BigDecimal value is not initialized properly");
big = BigDecimal.Parse("123.");
Assert.IsTrue(big.ToString().Equals("123") && big.Scale == 0, "the BigDecimal value is not initialized properly");
BigDecimal.Parse("1.234E02");
}
public void CompareToBigDecimal()
{
BigDecimal comp1 = BigDecimal.Parse("1.00");
BigDecimal comp2 = new BigDecimal(1.000000D);
Assert.IsTrue(comp1.CompareTo(comp2) == 0, "1.00 and 1.000000 should be equal");
BigDecimal comp3 = BigDecimal.Parse("1.02");
Assert.IsTrue(comp3.CompareTo(comp1) == 1, "1.02 should be bigger than 1.00");
BigDecimal comp4 = new BigDecimal(0.98D);
Assert.IsTrue(comp4.CompareTo(comp1) == -1, "0.98 should be less than 1.00");
}
public void AddBigDecimal()
{
BigDecimal add1 = BigDecimal.Parse("23.456");
BigDecimal add2 = BigDecimal.Parse("3849.235");
BigDecimal sum = add1.Add(add2);
Assert.IsTrue(sum.UnscaledValue.ToString().Equals("3872691") && sum.Scale == 3,
"the sum of 23.456 + 3849.235 is wrong");
Assert.IsTrue(sum.ToString().Equals("3872.691"), "the sum of 23.456 + 3849.235 is not printed correctly");
BigDecimal add3 = new BigDecimal(12.34E02D);
Assert.IsTrue((add1.Add(add3)).ToString().Equals("1257.456"), "the sum of 23.456 + 12.34E02 is not printed correctly");
}
public void DivideBigDecimalII()
{
BigDecimal divd1 = new BigDecimal(value2, 4);
BigDecimal divd2 = BigDecimal.Parse("0.0023");
BigDecimal divd3 = divd1.Divide(divd2, 3, RoundingMode.HalfUp);
Assert.IsTrue(divd3.ToString().Equals("536285217.391") && divd3.Scale == 3, "1233456/0.0023 is not correct");
divd2 = new BigDecimal(1345.5E-02D);
divd3 = divd1.Divide(divd2, 0, RoundingMode.Down);
Assert.IsTrue(divd3.ToString().Equals("91672") && divd3.Scale == 0,
"1233456/13.455 is not correct or does not have the correct scale");
divd2 = new BigDecimal(0000D);
Assert.Throws <ArithmeticException>(() => divd1.Divide(divd2, 4, RoundingMode.Down));
}
public void DivideBigDecimalI()
{
BigDecimal divd1 = new BigDecimal(value, 2);
BigDecimal divd2 = BigDecimal.Parse("2.335");
BigDecimal divd3 = divd1.Divide(divd2, RoundingMode.Up);
Assert.IsTrue(divd3.ToString().Equals("52873.27") && divd3.Scale == divd1.Scale, "123459.08/2.335 is not correct");
Assert.IsTrue(divd3.UnscaledValue.ToString().Equals("5287327"),
"the unscaledValue representation of 123459.08/2.335 is not correct");
divd2 = new BigDecimal(123.4D);
divd3 = divd1.Divide(divd2, RoundingMode.Down);
Assert.IsTrue(divd3.ToString().Equals("1000.47") && divd3.Scale == 2, "123459.08/123.4 is not correct");
divd2 = new BigDecimal(000D);
Assert.Throws <ArithmeticException>(() => divd1.Divide(divd2, RoundingMode.Down));
}
public void ToBigInteger()
{
BigDecimal sub1 = BigDecimal.Parse("-29830.989");
BigInteger result = sub1.ToBigInteger();
Assert.IsTrue(result.ToString().Equals("-29830"), "the bigInteger equivalent of -29830.989 is wrong");
sub1 = new BigDecimal(-2837E10);
result = sub1.ToBigInteger();
Assert.IsTrue(result.ToDouble() == -2837E10, "the bigInteger equivalent of -2837E10 is wrong");
sub1 = new BigDecimal(2.349E-10);
result = sub1.ToBigInteger();
Assert.IsTrue(result.Equals(BigInteger.Zero), "the bigInteger equivalent of 2.349E-10 is wrong");
sub1 = new BigDecimal(value2, 6);
result = sub1.ToBigInteger();
Assert.IsTrue(result.ToString().Equals("12334"), "the bigInteger equivalent of 12334.560000 is wrong");
}
public void StripTrailingZero()
{
BigDecimal sixhundredtest = BigDecimal.Parse("600.0");
Assert.IsTrue(((sixhundredtest.StripTrailingZeros()).Scale == -2), "stripTrailingZero failed for 600.0");
/* Single digit, no trailing zero, odd number */
BigDecimal notrailingzerotest = BigDecimal.Parse("1");
Assert.IsTrue(((notrailingzerotest.StripTrailingZeros()).Scale == 0), "stripTrailingZero failed for 1");
/* Zero */
//regression for HARMONY-4623, NON-BUG DIFF with RI
BigDecimal zerotest = BigDecimal.Parse("0.0000");
Assert.IsTrue(((zerotest.StripTrailingZeros()).Scale == 0), "stripTrailingZero failed for 0.0000");
}
public void BigDecimalSerialization()
{
// Regression for HARMONY-1896
char[] input = { '1', '5', '6', '7', '8', '7', '.', '0', '0' };
BigDecimal bd = BigDecimal.Parse(input, 0, 9);
MemoryStream bos = new MemoryStream();
BinaryFormatter oos = new BinaryFormatter();
oos.Serialize(bos, bd);
MemoryStream bis = new MemoryStream(bos.ToArray());
BigDecimal nbd = (BigDecimal)oos.Deserialize(bis);
Assert.AreEqual(bd.ToInt32(), nbd.ToInt32());
Assert.AreEqual(bd.ToDouble(), nbd.ToDouble(), 0.0);
Assert.AreEqual(bd.ToString(), nbd.ToString());
}
/**
* Returns a new {@code BigDecimal} instance with the same value as {@code
* this} but with a unscaled value where the trailing zeros have been
* removed. If the unscaled value of {@code this} has n trailing zeros, then
* the scale and the precision of the result has been reduced by n.
*
* @return a new {@code BigDecimal} instance equivalent to this where the
* trailing zeros of the unscaled value have been removed.
*/
public static BigDecimal StripTrailingZeros(BigDecimal value)
{
int i = 1; // 1 <= i <= 18
int lastPow = BigDecimal.TenPow.Length - 1;
long newScale = value.Scale;
if (value.IsZero)
{
return(BigDecimal.Parse("0"));
}
BigInteger strippedBI = value.UnscaledValue;
BigInteger quotient;
BigInteger remainder;
// while the number is even...
while (!BigInteger.TestBit(strippedBI, 0))
{
// To divide by 10^i
quotient = DivideAndRemainder(strippedBI, BigDecimal.TenPow[i], out remainder);
// To look the remainder
if (remainder.Sign == 0)
{
// To adjust the scale
newScale -= i;
if (i < lastPow)
{
// To set to the next power
i++;
}
strippedBI = quotient;
}
else
{
if (i == 1)
{
// 'this' has no more trailing zeros
break;
}
// To set to the smallest power of ten
i = 1;
}
}
return(new BigDecimal(strippedBI, BigDecimal.ToIntScale(newScale)));
}
public void Scale()
{
BigDecimal scale1 = new BigDecimal(value2, 8);
Assert.IsTrue(scale1.Scale == 8, "the scale of the number 123.34560000 is wrong");
BigDecimal scale2 = BigDecimal.Parse("29389.");
Assert.IsTrue(scale2.Scale == 0, "the scale of the number 29389. is wrong");
BigDecimal scale3 = new BigDecimal(3.374E13);
Assert.IsTrue(scale3.Scale == 0, "the scale of the number 3.374E13 is wrong");
BigDecimal scale4 = BigDecimal.Parse("-3.45E-203");
// note the scale is calculated as 15 digits of 345000.... + exponent -
// 1. -1 for the 3
Assert.IsTrue(scale4.Scale == 205, "the scale of the number -3.45E-203 is wrong: " + scale4.Scale);
scale4 = BigDecimal.Parse("-345.4E-200");
Assert.IsTrue(scale4.Scale == 201, "the scale of the number -345.4E-200 is wrong");
}
public void ToSingle()
{
BigDecimal fl1 = BigDecimal.Parse("234563782344567");
Assert.IsTrue(fl1.ToSingle() == 234563782344567f, "the float representation of bigDecimal 234563782344567");
BigDecimal fl2 = new BigDecimal(2.345E37);
Assert.IsTrue(fl2.ToSingle() == 2.345E37F, "the float representation of bigDecimal 2.345E37");
fl2 = new BigDecimal(-1.00E-44);
Assert.IsTrue(fl2.ToSingle() == -1.00E-44F, "the float representation of bigDecimal -1.00E-44");
fl2 = new BigDecimal(-3E12);
Assert.IsTrue(fl2.ToSingle() == -3E12F, "the float representation of bigDecimal -3E12");
fl2 = new BigDecimal(Double.MaxValue);
Assert.IsTrue(fl2.ToSingle() == Single.PositiveInfinity,
"A number can't be represented by float should return infinity");
fl2 = new BigDecimal(-Double.MaxValue);
Assert.IsTrue(fl2.ToSingle() == Single.NegativeInfinity,
"A number can't be represented by float should return infinity");
}
public void EqualsObject()
{
BigDecimal equal1 = new BigDecimal(1.00D);
BigDecimal equal2 = BigDecimal.Parse("1.0");
Assert.IsFalse(equal1.Equals(equal2), "1.00 and 1.0 should not be equal");
equal2 = new BigDecimal(1.01D);
Assert.IsFalse(equal1.Equals(equal2), "1.00 and 1.01 should not be equal");
equal2 = BigDecimal.Parse("1.00");
Assert.IsFalse(equal1.Equals(equal2), "1.00D and 1.00 should not be equal");
BigInteger val = BigInteger.Parse("100");
equal1 = BigDecimal.Parse("1.00");
equal2 = new BigDecimal(val, 2);
Assert.IsTrue(equal1.Equals(equal2), "1.00(string) and 1.00(bigInteger) should be equal");
equal1 = new BigDecimal(100D);
equal2 = BigDecimal.Parse("2.34576");
Assert.IsFalse(equal1.Equals(equal2), "100D and 2.34576 should not be equal");
Assert.IsFalse(equal1.Equals("23415"), "bigDecimal 100D does not equal string 23415");
}
public void MathContextConstruction()
{
String a = "-12380945E+61";
BigDecimal aNumber = BigDecimal.Parse(a);
int precision = 6;
RoundingMode rm = RoundingMode.HalfDown;
MathContext mcIntRm = new MathContext(precision, rm);
MathContext mcStr = MathContext.Parse("precision=6 roundingMode=HALFDOWN");
MathContext mcInt = new MathContext(precision);
BigDecimal res = BigMath.Abs(aNumber, mcInt);
Assert.Equal(res, BigDecimal.Parse("1.23809E+68"));
Assert.Equal(mcIntRm, mcStr);
Assert.Equal(mcInt.Equals(mcStr), false);
Assert.Equal(mcIntRm.GetHashCode(), mcStr.GetHashCode());
Assert.Equal(mcIntRm.ToString(), "precision=6 roundingMode=HalfDown");
}
public void MovePointRightI()
{
BigDecimal movePtRight = BigDecimal.Parse("-1.58796521458");
BigDecimal alreadyMoved = movePtRight.MovePointRight(8);
Assert.IsTrue(alreadyMoved.Scale == 3 && alreadyMoved.ToString().Equals("-158796521.458"),
"move point right 8 failed");
movePtRight = new BigDecimal(value, 2);
alreadyMoved = movePtRight.MovePointRight(4);
Assert.IsTrue(alreadyMoved.Scale == 0 && alreadyMoved.ToString().Equals("1234590800"), "move point right 4 failed");
movePtRight = new BigDecimal(134E12);
alreadyMoved = movePtRight.MovePointRight(2);
Assert.IsTrue(alreadyMoved.Scale == 0 && alreadyMoved.ToString().Equals("13400000000000000"),
"move point right 2 failed");
movePtRight = new BigDecimal(-3.4E-10);
alreadyMoved = movePtRight.MovePointRight(5);
Assert.IsTrue(alreadyMoved.Scale == movePtRight.Scale - 5 && alreadyMoved.ToDouble() == -0.000034,
"move point right 5 failed");
alreadyMoved = alreadyMoved.MovePointRight(-5);
Assert.IsTrue(alreadyMoved.Equals(movePtRight), "move point right -5 failed");
}
public void MathContextConstruction()
{
String a = "-12380945E+61";
BigDecimal aNumber = BigDecimal.Parse(a);
int precision = 6;
RoundingMode rm = RoundingMode.HalfDown;
MathContext mcIntRm = new MathContext(precision, rm);
MathContext mcStr = MathContext.Parse("precision=6 roundingMode=HALFDOWN");
MathContext mcInt = new MathContext(precision);
BigDecimal res = aNumber.Abs(mcInt);
Assert.AreEqual(res, BigDecimal.Parse("1.23809E+68"), "MathContext Constructor with int precision failed");
Assert.AreEqual(mcIntRm, mcStr, "Equal MathContexts are not Equal ");
Assert.AreEqual(mcInt.Equals(mcStr), false, "Different MathContext are reported as Equal ");
Assert.AreEqual(mcIntRm.GetHashCode(), mcStr.GetHashCode(), "Equal MathContexts have different hashcodes ");
Assert.AreEqual(mcIntRm.ToString(), "precision=6 roundingMode=HalfDown",
"MathContext.ToString() returning incorrect value");
}
public void MovePointLeftI()
{
BigDecimal movePtLeft = BigDecimal.Parse("123456265.34");
BigDecimal alreadyMoved = movePtLeft.MovePointLeft(5);
Assert.IsTrue(alreadyMoved.Scale == 7 && alreadyMoved.ToString().Equals("1234.5626534"), "move point left 5 failed");
movePtLeft = new BigDecimal(value2.Negate(), 0);
alreadyMoved = movePtLeft.MovePointLeft(12);
Assert.IsTrue(alreadyMoved.Scale == 12 && alreadyMoved.ToString().Equals("-0.012334560000"),
"move point left 12 failed");
movePtLeft = new BigDecimal(123E18);
alreadyMoved = movePtLeft.MovePointLeft(2);
Assert.IsTrue(alreadyMoved.Scale == movePtLeft.Scale + 2 && alreadyMoved.ToDouble() == 1.23E18,
"move point left 2 failed");
movePtLeft = new BigDecimal(1.123E-12);
alreadyMoved = movePtLeft.MovePointLeft(3);
Assert.IsTrue(alreadyMoved.Scale == movePtLeft.Scale + 3 && alreadyMoved.ToDouble() == 1.123E-15,
"move point left 3 failed");
movePtLeft = new BigDecimal(value, 2);
alreadyMoved = movePtLeft.MovePointLeft(-2);
Assert.IsTrue(alreadyMoved.Scale == movePtLeft.Scale - 2 && alreadyMoved.ToString().Equals("12345908"),
"move point left -2 failed");
}
public void TestGetHashCode()
{
// anything that is equal must have the same hashCode
BigDecimal hash = BigDecimal.Parse("1.00");
BigDecimal hash2 = new BigDecimal(1.00D);
Assert.IsTrue(hash.GetHashCode() != hash2.GetHashCode() && !hash.Equals(hash2),
"the hashCode of 1.00 and 1.00D is equal");
hash2 = BigDecimal.Parse("1.0");
Assert.IsTrue(hash.GetHashCode() != hash2.GetHashCode() && !hash.Equals(hash2),
"the hashCode of 1.0 and 1.00 is equal");
BigInteger val = BigInteger.Parse("100");
hash2 = new BigDecimal(val, 2);
Assert.IsTrue(hash.GetHashCode() == hash2.GetHashCode() && hash.Equals(hash2),
"hashCode of 1.00 and 1.00(bigInteger) is not equal");
hash = new BigDecimal(value, 2);
hash2 = BigDecimal.Parse("-1233456.0000");
Assert.IsTrue(hash.GetHashCode() != hash2.GetHashCode() && !hash.Equals(hash2),
"hashCode of 123459.08 and -1233456.0000 is not equal");
hash2 = new BigDecimal(value.Negate(), 2);
Assert.IsTrue(hash.GetHashCode() != hash2.GetHashCode() && !hash.Equals(hash2),
"hashCode of 123459.08 and -123459.08 is not equal");
}
public void SubtractBigDecimal()
{
BigDecimal sub1 = BigDecimal.Parse("13948");
BigDecimal sub2 = BigDecimal.Parse("2839.489");
BigDecimal result = sub1.Subtract(sub2);
Assert.IsTrue(result.ToString().Equals("11108.511") && result.Scale == 3, "13948 - 2839.489 is wrong: " + result);
BigDecimal result2 = sub2.Subtract(sub1);
Assert.IsTrue(result2.ToString().Equals("-11108.511") && result2.Scale == 3, "2839.489 - 13948 is wrong");
Assert.IsTrue(result.Equals(result2.Negate()), "13948 - 2839.489 is not the negative of 2839.489 - 13948");
sub1 = new BigDecimal(value, 1);
sub2 = BigDecimal.Parse("0");
result = sub1.Subtract(sub2);
Assert.IsTrue(result.Equals(sub1), "1234590.8 - 0 is wrong");
sub1 = new BigDecimal(1.234E-03);
sub2 = new BigDecimal(3.423E-10);
result = sub1.Subtract(sub2);
Assert.IsTrue(result.ToDouble() == 0.0012339996577, "1.234E-03 - 3.423E-10 is wrong, " + result.ToDouble());
sub1 = new BigDecimal(1234.0123);
sub2 = new BigDecimal(1234.0123000);
result = sub1.Subtract(sub2);
Assert.IsTrue(result.ToDouble() == 0.0, "1234.0123 - 1234.0123000 is wrong, " + result.ToDouble());
}
public void ParseStringPlusMinusExp()
{
Assert.Throws <FormatException>(() => BigDecimal.Parse("+35e+-2"));
Assert.Throws <FormatException>(() => BigDecimal.Parse("-35e-+2"));
}
public void ParseStringEmpty()
{
Assert.Throws <FormatException>(() => BigDecimal.Parse(""));
}
public void ParseCharArrayPlusMinusExp()
{
Assert.Throws <FormatException>(() => BigDecimal.Parse("+35e+-2".ToCharArray()));
Assert.Throws <FormatException>(() => BigDecimal.Parse("-35e-+2".ToCharArray()));
}
public void SetScaleII()
{
BigDecimal setScale1 = new BigDecimal(2.323E102);
BigDecimal setScale2 = setScale1.SetScale(4);
Assert.IsTrue(setScale2.Scale == 4, "the number 2.323E102 after setting scale is wrong");
Assert.IsTrue(setScale2.ToDouble() == 2.323E102, "the representation of the number 2.323E102 is wrong");
setScale1 = BigDecimal.Parse("-1.253E-12");
setScale2 = setScale1.SetScale(17, RoundingMode.Ceiling);
Assert.IsTrue(setScale2.Scale == 17, "the number -1.253E-12 after setting scale is wrong");
Assert.IsTrue(setScale2.ToString().Equals("-1.25300E-12"),
"the representation of the number -1.253E-12 after setting scale is wrong, " + setScale2);
// testing rounding Mode ROUND_CEILING
setScale1 = new BigDecimal(value, 4);
setScale2 = setScale1.SetScale(1, RoundingMode.Ceiling);
Assert.IsTrue(setScale2.ToString().Equals("1234.6") && setScale2.Scale == 1,
"the number 1234.5908 after setting scale to 1/ROUND_CEILING is wrong");
BigDecimal setNeg = new BigDecimal(value.Negate(), 4);
setScale2 = setNeg.SetScale(1, RoundingMode.Ceiling);
Assert.IsTrue(setScale2.ToString().Equals("-1234.5") && setScale2.Scale == 1,
"the number -1234.5908 after setting scale to 1/ROUND_CEILING is wrong");
// testing rounding Mode ROUND_DOWN
setScale2 = setNeg.SetScale(1, RoundingMode.Down);
Assert.IsTrue(setScale2.ToString().Equals("-1234.5") && setScale2.Scale == 1,
"the number -1234.5908 after setting scale to 1/ROUND_DOWN is wrong");
setScale1 = new BigDecimal(value, 4);
setScale2 = setScale1.SetScale(1, RoundingMode.Down);
Assert.IsTrue(setScale2.ToString().Equals("1234.5") && setScale2.Scale == 1,
"the number 1234.5908 after setting scale to 1/ROUND_DOWN is wrong");
// testing rounding Mode ROUND_FLOOR
setScale2 = setScale1.SetScale(1, RoundingMode.Floor);
Assert.IsTrue(setScale2.ToString().Equals("1234.5") && setScale2.Scale == 1,
"the number 1234.5908 after setting scale to 1/ROUND_FLOOR is wrong");
setScale2 = setNeg.SetScale(1, RoundingMode.Floor);
Assert.IsTrue(setScale2.ToString().Equals("-1234.6") && setScale2.Scale == 1,
"the number -1234.5908 after setting scale to 1/ROUND_FLOOR is wrong");
// testing rounding Mode ROUND_HALF_DOWN
setScale2 = setScale1.SetScale(3, RoundingMode.HalfDown);
Assert.IsTrue(setScale2.ToString().Equals("1234.591") && setScale2.Scale == 3,
"the number 1234.5908 after setting scale to 3/ROUND_HALF_DOWN is wrong");
setScale1 = new BigDecimal(BigInteger.Parse("12345000"), 5);
setScale2 = setScale1.SetScale(1, RoundingMode.HalfDown);
Assert.IsTrue(setScale2.ToString().Equals("123.4") && setScale2.Scale == 1,
"the number 123.45908 after setting scale to 1/ROUND_HALF_DOWN is wrong");
setScale2 = BigDecimal.Parse("-1234.5000").SetScale(0, RoundingMode.HalfDown);
Assert.IsTrue(setScale2.ToString().Equals("-1234") && setScale2.Scale == 0,
"the number -1234.5908 after setting scale to 0/ROUND_HALF_DOWN is wrong");
// testing rounding Mode ROUND_HALF_EVEN
setScale1 = new BigDecimal(1.2345789D);
setScale2 = setScale1.SetScale(4, RoundingMode.HalfEven);
Assert.IsTrue(setScale2.ToDouble() == 1.2346D && setScale2.Scale == 4,
"the number 1.2345789 after setting scale to 4/ROUND_HALF_EVEN is wrong");
setNeg = new BigDecimal(-1.2335789D);
setScale2 = setNeg.SetScale(2, RoundingMode.HalfEven);
Assert.IsTrue(setScale2.ToDouble() == -1.23D && setScale2.Scale == 2,
"the number -1.2335789 after setting scale to 2/ROUND_HALF_EVEN is wrong");
setScale2 = BigDecimal.Parse("1.2345000").SetScale(3,
RoundingMode.HalfEven);
Assert.IsTrue(setScale2.ToDouble() == 1.234D && setScale2.Scale == 3,
"the number 1.2345789 after setting scale to 3/ROUND_HALF_EVEN is wrong");
setScale2 = BigDecimal.Parse("-1.2345000").SetScale(3,
RoundingMode.HalfEven);
Assert.IsTrue(setScale2.ToDouble() == -1.234D && setScale2.Scale == 3,
"the number -1.2335789 after setting scale to 3/ROUND_HALF_EVEN is wrong");
// testing rounding Mode ROUND_HALF_UP
setScale1 = BigDecimal.Parse("134567.34650");
setScale2 = setScale1.SetScale(3, RoundingMode.HalfUp);
Assert.IsTrue(setScale2.ToString().Equals("134567.347") && setScale2.Scale == 3,
"the number 134567.34658 after setting scale to 3/ROUND_HALF_UP is wrong");
setNeg = BigDecimal.Parse("-1234.4567");
setScale2 = setNeg.SetScale(0, RoundingMode.HalfUp);
Assert.IsTrue(setScale2.ToString().Equals("-1234") && setScale2.Scale == 0,
"the number -1234.4567 after setting scale to 0/ROUND_HALF_UP is wrong");
Assert.Throws <ArithmeticException>(() => setScale1.SetScale(3, RoundingMode.Unnecessary));
// testing rounding Mode ROUND_UP
setScale1 = BigDecimal.Parse("100000.374");
setScale2 = setScale1.SetScale(2, RoundingMode.Up);
Assert.IsTrue(setScale2.ToString().Equals("100000.38") && setScale2.Scale == 2,
"the number 100000.374 after setting scale to 2/ROUND_UP is wrong");
setNeg = new BigDecimal(-134.34589D);
setScale2 = setNeg.SetScale(2, RoundingMode.Up);
Assert.IsTrue(setScale2.ToDouble() == -134.35D && setScale2.Scale == 2,
"the number -134.34589 after setting scale to 2/ROUND_UP is wrong");
Assert.Throws <ArgumentException>(() => setScale1.SetScale(0, -123));
}
