cpp-bignumber/test/bignumber_integral_test.cpp

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

#include "bignumber_test_printers.h"
#include "xcode_gtest_helper.h"

template <typename T> class BigIntLikeTest : public testing::Test {
public:
  T typeget_;
};
#define BigNumber decltype(this->typeget_)

typedef testing::Types<math::biginteger, math::bigdecimal> IntLikeBigNumbers;
TYPED_TEST_SUITE(BigIntLikeTest, IntLikeBigNumbers);

TYPED_TEST(BigIntLikeTest, DefaultConstructorCreatesZero) {
  EXPECT_THAT(BigNumber(), 0);
  EXPECT_THAT(BigNumber().to_string(), "0");
}

TYPED_TEST(BigIntLikeTest, StringAndNumberConstructorsEqual) {
  EXPECT_THAT(BigNumber("1000000"), BigNumber(1000000));
  EXPECT_THAT(BigNumber("-1000000"), BigNumber(-1000000));
}

TYPED_TEST(BigIntLikeTest, AddPastBounds) {
  BigNumber bi{999999999ULL};
  EXPECT_THAT((bi + 1).to_string(), "1000000000");
}

TYPED_TEST(BigIntLikeTest, AddReciprocalIsZero) {
  BigNumber bi{1000};
  EXPECT_THAT((bi + (-bi)).to_string(), "0");
}

TYPED_TEST(BigIntLikeTest, AddNegativeLargerGivesNegative) {
  BigNumber bi{1000};
  EXPECT_THAT((bi + (-1001)).to_string(), "-1");
}

TYPED_TEST(BigIntLikeTest, AddNegativeSmallerGivesPositive) {
  BigNumber bi{1000};
  EXPECT_THAT((bi + (-999)).to_string(), "1");
}

TYPED_TEST(BigIntLikeTest, AddNumberZeroGivesOriginal) {
  BigNumber bi{1000};
  EXPECT_THAT(bi + 0, bi);
}

TYPED_TEST(BigIntLikeTest, AddZeroNumberGivesOriginal) {
  BigNumber bi{1000};
  EXPECT_THAT(0 + bi, bi);
}

TYPED_TEST(BigIntLikeTest, SubSelfIsZero) {
  BigNumber bi{1000};
  EXPECT_THAT((bi - bi).to_string(), "0");
}

TYPED_TEST(BigIntLikeTest, SubtractZeroGivesOriginal) {
  BigNumber bi{1000};
  EXPECT_THAT(bi - 0, bi);
}

TYPED_TEST(BigIntLikeTest, ZeroMinusNumberEqualsReciprocal) {
  BigNumber bi{1000};
  EXPECT_THAT((0 - bi).to_string(), (-bi).to_string());
}

TYPED_TEST(BigIntLikeTest, NegativeMinusNegativeIncreateAbs) {
  BigNumber bi{-1000};
  EXPECT_THAT((bi - 100).to_string(), "-1100");
}

TYPED_TEST(BigIntLikeTest, SubLargerGivesNegative) {
  BigNumber bi{1000};
  EXPECT_THAT((bi - 1001).to_string(), "-1");
}

TYPED_TEST(BigIntLikeTest, SubSmallerGivesPositive) {
  BigNumber bi{1000};
  EXPECT_THAT((bi - 999).to_string(), "1");
}

TYPED_TEST(BigIntLikeTest, SubUnderflowBorrows) {
  BigNumber bi{1000000000ULL};
  EXPECT_THAT((bi - 1).to_string(), "999999999");
}

TYPED_TEST(BigIntLikeTest, MultiplyZeroReturnsZero) {
  auto & ZERO = BigNumber::ZERO;
  BigNumber bi{999999999ULL};
  EXPECT_THAT(bi * ZERO, ZERO);
  EXPECT_THAT(ZERO * bi, ZERO);
}

TYPED_TEST(BigIntLikeTest, MultiplyOneReturnsValue) {
  auto & ONE = BigNumber::ONE;
  BigNumber bi{999999999ULL};
  EXPECT_THAT((bi * ONE).to_string(), "999999999");
  EXPECT_THAT((ONE * bi).to_string(), "999999999");
}

TYPED_TEST(BigIntLikeTest, MultiplyNegativeOneReturnsInverse) {
  auto & NEGATIVE_ONE = BigNumber::NEGATIVE_ONE;
  BigNumber bi{999999999ULL};
  EXPECT_THAT((bi * NEGATIVE_ONE).to_string(), "-999999999");
  EXPECT_THAT((NEGATIVE_ONE * bi).to_string(), "-999999999");
}

TYPED_TEST(BigIntLikeTest, MultiplyOverflowsIntoNextCell) {
  BigNumber bi{999999999ULL};
  EXPECT_THAT((bi * bi).to_string(), "999999998000000001");
}

TYPED_TEST(BigIntLikeTest, MultiplyCarryIntoNextCell) {
  BigNumber bi{999999999ULL};
  BigNumber big{bi * bi};
  EXPECT_THAT((big * big).to_string(), "999999996000000005999999996000000001");
}

TYPED_TEST(BigIntLikeTest, MultiplyNoOverflow) {
  BigNumber bi{1000};
  EXPECT_THAT((bi * bi).to_string(), "1000000");
}

TYPED_TEST(BigIntLikeTest, DivideByZeroThrows) {
  auto & ZERO = BigNumber::ZERO;
  BigNumber bi{1000};
  EXPECT_THROW(bi / ZERO, std::domain_error);
}

TYPED_TEST(BigIntLikeTest, DivideByOneReturnsValue) {
  auto & ONE = BigNumber::ONE;
  BigNumber bi{1000};
  EXPECT_THAT(bi / ONE, bi);
}

TYPED_TEST(BigIntLikeTest, DivideBySelfReturnsOne) {
  auto & ONE = BigNumber::ONE;
  BigNumber bi{1000};
  EXPECT_THAT(bi / bi, ONE);
}

TYPED_TEST(BigIntLikeTest, DivideByNegativeOneReturnsInverse) {
  auto & NEGATIVE_ONE = BigNumber::NEGATIVE_ONE;
  BigNumber bi{1000};
  EXPECT_THAT((bi / NEGATIVE_ONE).to_string(), "-1000");
}

TYPED_TEST(BigIntLikeTest, DivisionWithMultipleMultSubSteps) {
  BigNumber bi{1112};
  EXPECT_THAT((bi / 2).to_string(), "556");
}

TYPED_TEST(BigIntLikeTest, DivisionDroppingNumberOfCells) {
  BigNumber bi{1000000000ULL};
  EXPECT_THAT((bi / 2).to_string(), "500000000");
}

TYPED_TEST(BigIntLikeTest, DivisionByBiggerNumberIsZero) {
  BigNumber bi{1000ULL};
  EXPECT_THAT((bi / 1001).to_string(), "0");
}

TYPED_TEST(BigIntLikeTest, DivisionWithLargeNumbers) {
  BigNumber big{"999999998000000001"};
  EXPECT_THAT(big.to_string(), "999999998000000001");
  EXPECT_THAT((big / 999999999ULL).to_string(), "999999999");
}

TYPED_TEST(BigIntLikeTest, ZeroDividedByAnyReturnsZero) {
  auto & ZERO = BigNumber::ZERO;
  EXPECT_THAT(ZERO / 25, ZERO);
}