cpp-bignumber/test/bignumber_integral_test.cpp

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

#include <gmock/gmock.h>

#include "biginteger.h"
#include "bigdecimal.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_CASE(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);
}