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

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

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

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

TEST(BigDecimalTest, 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(BigDecimalTest, NegativeScaleLosesLowerDigits) {
  math::bigdecimal dec("123", -2);
  EXPECT_THAT(dec.to_string(), "100");
}

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

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

TEST(BigDecimalTest, AddTwoDecimalsSameScale) {
  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, AddTwoDecimalsDifferentScalesUsesHigherScale) {
  math::bigdecimal a("1000.10");
  math::bigdecimal b("1000");
  EXPECT_THAT(a.scale(), testing::Gt(b.scale()));
  EXPECT_THAT((a+b).to_string(), "2000.10");
}

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

TEST(BigDecimalTest, SubtractTwoDecimalsDifferentScalesUsesHigherScale) {
  math::bigdecimal a("900.10");
  math::bigdecimal 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(BigDecimalTest, MultiplicationIncreasesScale) {
  math::bigdecimal bd("1.1");
  math::bigdecimal out = bd * bd;
  EXPECT_THAT(out.scale(), bd.scale() + bd.scale());
  EXPECT_THAT(out.to_string(), "1.21");
}

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

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

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

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

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

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

TEST(BigDecimalTest, DivideHigherScaleByLowerScaleGainsDigits) {
  math::bigdecimal a("1", 1);
  math::bigdecimal b("1", 0);
  EXPECT_THAT((a/b).to_string(), "1.0");
}

TEST(BigDecimalTest, DivideLowerScaleByHigherScaleLosesDigits) {
  math::bigdecimal a("1", 0);
  math::bigdecimal b("1", 1);
  EXPECT_THAT((a/b).to_string(), "0");
}

TEST(BigDecimalTest, DivideRemainderLostWhenLackingScale) {
  math::bigdecimal a("1" ,  0);
  math::bigdecimal c("10",  0);
  EXPECT_THAT((a/c).to_string(), "0");
}

TEST(BigDecimalTest, DivideRemainderKeptWithScale) {
  math::bigdecimal a("1" , 1);
  math::bigdecimal d("10", 0);
  EXPECT_THAT((a/d).to_string(), "0.1");
}

TEST(BigDecimalTest, NewDivisionScaleIsDifferenceOfComponentScales) {
  math::bigdecimal b("1" ,  1);
  math::bigdecimal d("10", -1);
  EXPECT_THAT((b/d).scale(), b.scale() - d.scale());
  EXPECT_THAT((b/d).to_string(), "0.10");
}