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(BigDecimal, ConstructFromStringIsSameValueAsFromInt) {
//    using bi = math::bigdecimal;
//    EXPECT_THAT(bi("1000000"), bi(1000000));
//  }
//

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

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

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

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

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

TEST(BigDecimal, ConstructWithScaleEqualsWithout) {
  math::bigdecimal scl(100, -2);
  EXPECT_THAT(scl.to_string(), "100");
}

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

TEST(BigDecimal, AddTwoDecimalsSameScale) {
  using bd = math::bigdecimal;
  bd a("1000.10");
  bd b("1000.01");
  EXPECT_THAT(a.scale(), b.scale());
  EXPECT_THAT((a+b).to_string(), "2000.11");
}

TEST(BigDecimal, AddTwoDecimalsDifferentScalesUsesHigherScale) {
  using bd = math::bigdecimal;
  bd a("1000.10");
  bd b("1000");
  EXPECT_THAT(a.scale(), testing::Gt(b.scale()));
  EXPECT_THAT((a+b).to_string(), "2000.10");
}

TEST(BigDecimal, AddNumberWithInversePreservesScale) {
  math::bigdecimal a("1.001");
  EXPECT_THAT((a+(-a)).to_string(), "0.000");
}

TEST(BigDecimal, SubtractTwoDecimalsDifferentScalesUsesHigherScale) {
  using bd = math::bigdecimal;
  bd a("900.10");
  bd b("1000");
  EXPECT_THAT(a.scale(), testing::Gt(b.scale()));
  EXPECT_THAT((a-b).to_string(), "-99.90");
  EXPECT_THAT((b-a).to_string(), "99.90");
}

TEST(BigDecimal, MultiplicationIncreasesScale) {
  math::bigdecimal bd("1.1");
  auto out = bd * bd;
  EXPECT_THAT(out.scale(), bd.scale() + bd.scale());
  EXPECT_THAT(out.to_string(), "1.21");
}

TEST(BigDecimal, MultiplicationNegativeScaleCountersPositiveScale) {
  math::bigdecimal a("0.01");
  math::bigdecimal b("100", -2);
  EXPECT_THAT((a*b).to_string(), "1");
}

TEST(BigDecimal, MultiplicationCreateNewOffsetCell) {
  math::bigdecimal C(1, 5);
  EXPECT_THAT((C*C).to_string(), "1.0000000000");
}

TEST(BigDecimal, MultiplicationNegativeToPositiveScale) {
  math::bigdecimal C(1, 5);
  math::bigdecimal D(100, -2);
  EXPECT_THAT((D*C).to_string(), "100.000");
}

TEST(BigDecimal, MultiplicationFromDroppedToNonDropScale) {
  math::bigdecimal C(1, 5);
  math::bigdecimal E(1000000000, -9);
  EXPECT_THAT((E*C).to_string(), "1000000000");
}

TEST(BigDecimal, MultiplicationFromDroppedToLowerScale) {
  math::bigdecimal D(100, -2);
  math::bigdecimal E(1000000000, -9);
  EXPECT_THAT((E*D).to_string(), "100000000000");
}

TEST(BigDecimal, MultiplicationFromNonDropToDroppedScale) {
  math::bigdecimal F(10000, -4);
  math::bigdecimal G(100000, -5);
  EXPECT_THAT((G*F).to_string(), "1000000000");
}

TEST(BigDecimal, DivideHigherScaleByLowerScale) {
  math::bigdecimal a("1", 2);
  math::bigdecimal b("1", 1);
  EXPECT_THAT((a/b).to_string(), "1.0");
}

TEST(BigDecimal, DivideLowerScaleByHigherScale) {
  math::bigdecimal a("10", 1);
  math::bigdecimal b("1", 2);
  EXPECT_THAT((a/b).to_string(), "10");
}

TEST(BigDecimal, DivideByLargerNumberGivesDecimalIfScaleAllows) {
  math::bigdecimal a("1" ,  0);
  math::bigdecimal b("1" ,  1);
  math::bigdecimal c("10",  0);
  math::bigdecimal d("10", -1);
  EXPECT_THAT((a/c).to_string(), "0");
  EXPECT_THAT((a/d).to_string(), "0.1");
  EXPECT_THAT((b/c).to_string(), "0.1");
  EXPECT_THAT((b/d).to_string(), "0.10");
}