Add coverage for those last few hard-to-get places.

src/biginteger.cpp

@@ -133,7 +133,7 @@ biginteger math::operator/(biginteger rhs, biginteger const & lhs) {
 
 biginteger math::operator%(biginteger rhs, biginteger const & lhs) {
   if (lhs == biginteger::ZERO) { throw std::domain_error("cannot divide by 0"); }
-  else if (detail::compare(lhs.data, biginteger::ONE.data) == 0 ||
+  else if (lhs == biginteger::ONE ||
            rhs == biginteger::ZERO) { return biginteger::ZERO; }
   else {
     auto cmp = detail::compare(rhs.data, lhs.data);

test/biginteger_test.cpp

@@ -40,3 +40,40 @@ TEST(BigIntegerTest, ModuloNegativesIsNegative) {
   math::biginteger mod{13};
   EXPECT_THAT((bi%mod), -((-bi)%(-mod)));
 }
+
+
+using BigIntPair = std::tuple<math::biginteger, math::biginteger>;
+
+class BigIntModuloTest : public testing::TestWithParam<BigIntPair> {};
+
+TEST_P(BigIntModuloTest, IsZero) {
+  auto & ZERO = math::biginteger::ZERO;
+  auto pair = GetParam();
+  EXPECT_THAT(std::get<0>(pair)%std::get<1>(pair), ZERO);
+}
+
+class BigIntegerLtTest : public testing::TestWithParam<BigIntPair> {};
+
+TEST_P(BigIntegerLtTest, IsLessThan) {
+  auto pair = GetParam();
+  EXPECT_THAT(std::get<0>(pair), testing::Lt(std::get<1>(pair)));
+}
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"
+INSTANTIATE_TEST_CASE_P(SmallNum, BigIntegerLtTest,
+                        testing::Values(BigIntPair{-1,  1},
+                                        BigIntPair{ 0,  1},
+                                        BigIntPair{-2, -1}));
+INSTANTIATE_TEST_CASE_P(LargeNum, BigIntegerLtTest,
+                        testing::Values(BigIntPair{ 1000000000,  1000000001},
+                                        BigIntPair{-1000000001, -1000000000}));
+
+INSTANTIATE_TEST_CASE_P(ZeroModAny, BigIntModuloTest,
+                        testing::Combine(testing::Values(0),
+                        testing::Values(1, 2, 10, 100, -4, 1000000000, -1000000000)));
+
+INSTANTIATE_TEST_CASE_P(AnyModOne, BigIntModuloTest,
+                        testing::Combine(testing::Values(1, 2, 10, 100, -4, 1000000000, -1000000000),
+                                         testing::Values(1)));
+#pragma clang diagnostic pop

test/bignumber_integral_test.cpp

@@ -25,9 +25,9 @@ TYPED_TEST(BigIntLikeTest, DefaultConstructorCreatesZero) {
   EXPECT_THAT(BigNumber().to_string(), "0");
 }
 
-TYPED_TEST(BigIntLikeTest, ConstructFromStringIsSameValueAsFromInt) {
-  EXPECT_THAT(BigNumber("1000000"),
-              BigNumber(1000000));
+TYPED_TEST(BigIntLikeTest, StringAndNumberConstructorsEqual) {
+  EXPECT_THAT(BigNumber( "1000000"), BigNumber( 1000000));
+  EXPECT_THAT(BigNumber("-1000000"), BigNumber(-1000000));
 }
 
 TYPED_TEST(BigIntLikeTest, AddPastBounds) {
@@ -50,11 +50,31 @@ TYPED_TEST(BigIntLikeTest, AddNegativeSmallerGivesPositive) {
   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");
@@ -125,6 +145,12 @@ TYPED_TEST(BigIntLikeTest, DivideByOneReturnsValue) {
   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};
@@ -152,3 +178,8 @@ TYPED_TEST(BigIntLikeTest, DivisionWithLargeNumbers) {
   EXPECT_THAT((big/999999999ULL).to_string(),
                    "999999999");
 }
+
+TYPED_TEST(BigIntLikeTest, ZeroDividedByAnyReturnsZero) {
+  auto & ZERO = BigNumber::ZERO;
+  EXPECT_THAT(ZERO/25, ZERO);
+}