cpp-bignumber/test/bigdecimal_test.cpp

//
//  bigdecimal_test.cpp
//  bigdecimal
//
//  Created by Sam Jaffe on 5/18/18.
//

#include <gmock/gmock.h>

#include "bigdecimal.h"

TEST(BigDecimalTest, ConstructIntegerAsDecimal) {
  EXPECT_THAT(math::bigdecimal(1000, 2).to_string(), "1000.00");
}

TEST(BigDecimalTest, ConstructDecimal) {
  EXPECT_THAT(math::bigdecimal("1000.10").to_string(), "1000.10");
  EXPECT_THAT(math::bigdecimal("1000.0000000001").to_string(), "1000.0000000001");
}

TEST(BigDecimalTest, ConstructIntWithScaleAndStep) {
  EXPECT_THAT(math::bigdecimal(1000000000, -2).to_string(), "1000000000");
}

TEST(BigDecimalTest, RescalePositiveAddsDecimalPlaces) {
  math::bigdecimal dec(100);
  EXPECT_THAT(dec.scale(), 0);
  dec.rescale(2);
  EXPECT_THAT(dec.to_string(), "100.00");
}

TEST(BigDecimalTest, RescaleNegativeDropsLowerOrderElements) {
  math::bigdecimal dec(111);
  EXPECT_THAT(dec.scale(), 0);
  dec.rescale(-2);
  EXPECT_THAT(dec.to_string(), "100");
}

TEST(BigDecimalTest, RescaleDownPermanantlyDropsLowOrderElements) {
  math::bigdecimal dec("100.10");
  EXPECT_THAT(dec.scale(), 2);
  dec.rescale(0);
  dec.rescale(2);
  EXPECT_THAT(dec.to_string(), "100.00");
}

TEST(BigDecimalTest, ScaleCtorCanBeLossy) {
  math::bigdecimal dec("123", -2);
  EXPECT_THAT(dec.to_string(), "100");
}

TEST(BigDecimalTest, NonLossyScaleCtorEqualsNoScaleCtor) {
  math::bigdecimal scl(100, -2);
  math::bigdecimal nc(100);
  EXPECT_THAT(scl, nc);
}

TEST(BigDecimalTest, ScaleBelowNegSegDoesntLoseAnything) {
  math::bigdecimal dec("1000000000", -9);
  EXPECT_THAT(dec.to_string(), "1000000000");
}

TEST(BigDecimalTest, AddingEqualScalesDoesNotAddTrailingDigitsOrLoseData) {
  math::bigdecimal a("1000.10");
  math::bigdecimal b("1000.01");
  EXPECT_THAT(a.scale(), b.scale());
  EXPECT_THAT((a+b).to_string(), "2000.11");
}

TEST(BigDecimalTest, AdditionNormalizeScaleToHighest) {
  math::bigdecimal a("1000.10");
  math::bigdecimal b("1000");
  EXPECT_THAT(a.scale(), testing::Gt(b.scale()));
  EXPECT_THAT((a+b).scale(), a.scale());
}

TEST(BigDecimalTest, InverseOfNumberCarriesSameScale) {
  math::bigdecimal a("1.001");
  EXPECT_THAT(a.scale(), (-a).scale());
}

TEST(BigDecimalTest, SubtractionNormalizeScaleToHighest) {
  math::bigdecimal a("900.10");
  math::bigdecimal b("1000");
  EXPECT_THAT(a.scale(), testing::Gt(b.scale()));
  EXPECT_THAT((a-b).scale(), a.scale());
  EXPECT_THAT((b-a).scale(), a.scale());
}

struct ArithTuple { math::bigdecimal lhs, rhs; std::string expected; };
struct BigDecPair { math::bigdecimal lhs, rhs; };
void PrintTo(BigDecPair const & tup, std::ostream * out) {
  (*out) << "{ lhs = " << tup.lhs.to_string() << "(" << tup.lhs.scale() << "), rhs = " << tup.rhs.to_string() << "(" << tup.rhs.scale() << ") }";
}

class MultiplicationScaleTest : public testing::TestWithParam<ArithTuple> {};

TEST_P(MultiplicationScaleTest, ScaleIsSumOfOperAndMultipScales) {
  auto tup = GetParam();
  auto out = tup.lhs * tup.rhs;
  EXPECT_THAT(out.scale(), tup.lhs.scale() + tup.rhs.scale());
  EXPECT_THAT(out.to_string(), tup.expected);
}

class DivisionScaleTest : public testing::TestWithParam<ArithTuple> {};

TEST_P(DivisionScaleTest, ScaleIsDifferenceOfNumAndDenomScales) {
  auto tup = GetParam();
  auto out = tup.lhs / tup.rhs;
  EXPECT_THAT(out.scale(), tup.lhs.scale() - tup.rhs.scale());
  EXPECT_THAT(out.to_string(), tup.expected);
}

class EqTest : public testing::TestWithParam<BigDecPair> {};

TEST_P(EqTest, DecimalsAreEqualEvenIfScalesAreNot) {
  EXPECT_THAT(GetParam().lhs, GetParam().rhs);
}

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"
INSTANTIATE_TEST_CASE_P(BigDecimal, MultiplicationScaleTest,
                        testing::Values(ArithTuple{{1, 1}, { 1,  0},  "1.0"},
                                        ArithTuple{{1, 0}, { 1,  1},  "1.0"},
                                        ArithTuple{{1, 0}, {10,  0}, "10"  },
                                        ArithTuple{{1, 1}, {10,  0}, "10.0"},
                                        ArithTuple{{1, 1}, {10, -1}, "10", },
                                        ArithTuple{{"1.1"}, {"1.1"}, "1.21"},
                                        ArithTuple{{"0.01"}, {100, -2}, "1"},
                                        ArithTuple{{1, 5}, {1,  5}, "1.0000000000"},
                                        ArithTuple{{1, 5}, {1000000000, -9}, "1000000000"},
                                        ArithTuple{{100, -2}, {1000000000, -9}, "100000000000"},
                                        ArithTuple{{10000, -4}, {100000, -5}, "1000000000"}));

INSTANTIATE_TEST_CASE_P(BigDecimal, DivisionScaleTest,
                        testing::Values(ArithTuple{{1, 1}, { 1,  0}, "1.0" },
                                        ArithTuple{{1, 0}, { 1,  1}, "0"   },
                                        ArithTuple{{1, 0}, {10,  0}, "0"   },
                                        ArithTuple{{1, 1}, {10,  0}, "0.1" },
                                        ArithTuple{{1, 1}, {10, -1}, "0.10"},
                                        ArithTuple{{"1.1"}, {"1.1"}, "1"},
                                        ArithTuple{{"0.01"}, {100, -2}, "0.0001"},
                                        ArithTuple{{1, 5}, {1,  5}, "1"},
                                        ArithTuple{{1, 5}, {1000000000, -9}, "0.00000000100000"},
                                        ArithTuple{{100, -2}, {1000000000, -9}, "0.0000001"},
                                        ArithTuple{{10000, -4}, {100000, -5}, "0.1"}));

INSTANTIATE_TEST_CASE_P(BigDecimal, EqTest,
                        testing::Values(BigDecPair{{  0}, {  0,  4}},
                                        BigDecPair{{100}, {100, -2}},
                                        BigDecPair{{1000000000, -4}, {1000000000, -9}},
                                        BigDecPair{{"0.1", 1}, {"0.10", 2}}));

#pragma clang diagnostic pop