cpp-bignumber/test/biginteger_test.cpp

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

#include <gmock/gmock.h>

#include "biginteger.h"

TEST(BigInteger, ConstructFromStringIsSameValueAsFromInt) {
  EXPECT_THAT(math::biginteger("1000000"),
              math::biginteger(1000000));
}

TEST(BigInteger, AddPastBounds) {
  math::biginteger bi{999999999ULL};
  EXPECT_THAT((bi+1).to_string(), "1000000000");
}

TEST(BigInteger, AddReciprocalIsZero) {
  math::biginteger bi{1000};
  EXPECT_THAT((bi+(-bi)).to_string(), "0");
}

TEST(BigInteger, AddNegativeLargerGivesNegative) {
  math::biginteger bi{1000};
  EXPECT_THAT((bi+(-1001)).to_string(), "-1");
}

TEST(BigInteger, AddNegativeSmallerGivesPositive) {
  math::biginteger bi{1000};
  EXPECT_THAT((bi+(-999)).to_string(), "1");
}

TEST(BigInteger, SubSelfIsZero) {
  math::biginteger bi{1000};
  EXPECT_THAT((bi-bi).to_string(), "0");
}

TEST(BigInteger, NegativeMinusNegativeIncreateAbs) {
  math::biginteger bi{-1000};
  EXPECT_THAT((bi-100).to_string(), "-1100");
}

TEST(BigInteger, SubLargerGivesNegative) {
  math::biginteger bi{1000};
  EXPECT_THAT((bi-1001).to_string(), "-1");
}

TEST(BigInteger, SubSmallerGivesPositive) {
  math::biginteger bi{1000};
  EXPECT_THAT((bi-999).to_string(), "1");
}

TEST(BigInteger, SubUnderflowBorrows) {
  math::biginteger bi{1000000000ULL};
  EXPECT_THAT((bi-1).to_string(), "999999999");
}

TEST(BigInteger, MultiplyZeroReturnsZero) {
  auto &ZERO =  math::biginteger::ZERO;
  math::biginteger bi{999999999ULL};
  EXPECT_THAT(bi*ZERO, ZERO);
  EXPECT_THAT(ZERO*bi, ZERO);
}

TEST(BigInteger, MultiplyOneReturnsValue) {
  auto &ONE =  math::biginteger::ONE;
  math::biginteger bi{999999999ULL};
  EXPECT_THAT((bi*ONE).to_string(), "999999999");
  EXPECT_THAT((ONE*bi).to_string(), "999999999");
}

TEST(BigInteger, MultiplyNegativeOneReturnsInverse) {
  auto &NEGATIVE_ONE =  math::biginteger::NEGATIVE_ONE;
  math::biginteger bi{999999999ULL};
  EXPECT_THAT((bi*NEGATIVE_ONE).to_string(), "-999999999");
  EXPECT_THAT((NEGATIVE_ONE*bi).to_string(), "-999999999");
}

TEST(BigInteger, MultiplyOverflowsIntoNextCell) {
  math::biginteger bi{999999999ULL};
  EXPECT_THAT((bi*bi).to_string(), "999999998000000001");
}

TEST(BigInteger, MultiplyCarryIntoNextCell) {
  math::biginteger bi{999999999ULL};
  math::biginteger big{bi*bi};
  EXPECT_THAT((big*big).to_string(),
                   "999999996000000005999999996000000001");
}

TEST(BigInteger, MultiplyNoOverflow) {
  math::biginteger bi{1000};
  EXPECT_THAT((bi*bi).to_string(), "1000000");
}

TEST(BigInteger, DivideByZeroThrows) {
  auto &ZERO =  math::biginteger::ZERO;
  math::biginteger bi{1000};
  EXPECT_THROW(bi/ZERO, std::domain_error);
}

TEST(BigInteger, DivideByOneReturnsValue) {
  auto &ONE =  math::biginteger::ONE;
  math::biginteger bi{1000};
  EXPECT_THAT(bi/ONE, bi);
}

TEST(BigInteger, DivideByNegativeOneReturnsInverse) {
  auto &NEGATIVE_ONE =  math::biginteger::NEGATIVE_ONE;
  math::biginteger bi{1000};
  EXPECT_THAT((bi/NEGATIVE_ONE).to_string(), "-1000");
}

TEST(BigInteger, DivisionWithMultipleMultSubSteps) {
  math::biginteger bi{1112};
  EXPECT_THAT((bi/2).to_string(), "556");
}

TEST(BigInteger, DivisionDroppingNumberOfCells) {
  math::biginteger bi{1000000000ULL};
  EXPECT_THAT((bi/2).to_string(), "500000000");
}

TEST(BigInteger, DivisionByBiggerNumberIsZero) {
  math::biginteger bi{1000ULL};
  EXPECT_THAT((bi/1001).to_string(), "0");
}

TEST(BigInteger, DivisionWithLargeNumbers) {
  math::biginteger big{"999999998000000001"};
  EXPECT_THAT(big.to_string(), "999999998000000001");
  EXPECT_THAT((big/999999999ULL).to_string(), "999999999");
}

TEST(BigInteger, ModuloZeroThrows) {
  math::biginteger bi{1000};
  EXPECT_THROW(bi%0, std::domain_error);
}

TEST(BigInteger, ModuloBiggerIsSameValue) {
  math::biginteger bi{1000};
  EXPECT_THAT(bi%2000, bi);
}

TEST(BigInteger, ModuloSameNumberIsZero) {
  math::biginteger bi{1000};
  EXPECT_THAT(bi%1000, 0);
}

TEST(BigInteger, ModuloDivisorIsZero) {
  math::biginteger bi{1000};
  EXPECT_THAT(bi%100, 0);
}

TEST(BigInteger, ModuloDiffSignIsInverseElement) {
  math::biginteger bi{1000};
  math::biginteger mod{13};
  EXPECT_THAT((bi%mod)+((-bi)%mod), mod);
}

TEST(BigInteger, ModuloNegativesIsNegative) {
  math::biginteger bi{1000};
  math::biginteger mod{13};
  EXPECT_THAT((bi%mod), -((-bi)%(-mod)));
}