cpp-bignumber/test/bigdecimal_integral_test.cpp

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

#include <gmock/gmock.h>

#include "bigdecimal.h"

TEST(BigDecimal_Integral, ConstructFromStringIsSameValueAsFromInt) {
  EXPECT_THAT(math::bigdecimal("1000000"),
              math::bigdecimal(1000000));
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

TEST(BigDecimal_Integral, DivisionWithLargeNumbers) {
  math::bigdecimal big{"999999998000000001"};
  EXPECT_THAT(big.to_string(), "999999998000000001");
  EXPECT_THAT((big/999999999ULL).to_string(),
                   "999999999");
}
//
//  TEST(BigDecimal_Integral, ModuloZeroThrows) {
//    math::bigdecimal bi{1000};
//    EXPECT_THROW(bi%0, std::domain_error);
//  }
//
//  TEST(BigDecimal_Integral, ModuloBiggerIsSameValue) {
//    math::bigdecimal bi{1000};
//    EXPECT_THAT(bi%2000, bi);
//  }
//
//  TEST(BigDecimal_Integral, ModuloSameNumberIsZero) {
//    math::bigdecimal bi{1000};
//    EXPECT_THAT(bi%1000, 0);
//  }
//
//  TEST(BigDecimal_Integral, ModuloDivisorIsZero) {
//    math::bigdecimal bi{1000};
//    EXPECT_THAT(bi%100, 0);
//  }
//
//  TEST(BigDecimal_Integral, ModuloDiffSignIsInverseElement) {
//    math::bigdecimal bi{1000};
//    math::bigdecimal mod{13};
//    EXPECT_THAT((bi%mod)+((-bi)%mod), mod);
//  }
//
//  TEST(BigDecimal_Integral, ModuloNegativesIsNegative) {
//    math::bigdecimal bi{1000};
//    math::bigdecimal mod{13};
//    EXPECT_THAT((bi%mod), -((-bi)%(-mod)));
//  }