Renaming test type

test/bigdecimal_test.cpp

@@ -9,28 +9,28 @@
 
 #include "bigdecimal.h"
 
-TEST(BigDecimal, ConstructFromStringIsSameValueAsFromInt) {
+TEST(BigDecimalTest, ConstructFromStringIsSameValueAsFromInt) {
   EXPECT_THAT(math::bigdecimal("1000000"),
               math::bigdecimal(1000000));
 }
 
-TEST(BigDecimal, ConstructIntegerAsDecimal) {
+TEST(BigDecimalTest, ConstructIntegerAsDecimal) {
   EXPECT_THAT(math::bigdecimal("1000.00").to_string(), "1000.00");
 }
 
-TEST(BigDecimal, ConstructDecimal) {
+TEST(BigDecimalTest, ConstructDecimal) {
   EXPECT_THAT(math::bigdecimal("1000.10").to_string(), "1000.10");
   EXPECT_THAT(math::bigdecimal("1000.01").to_string(), "1000.01");
 }
 
-TEST(BigDecimal, RescaleHigherAddsDigits) {
+TEST(BigDecimalTest, RescaleHigherAddsDigits) {
   math::bigdecimal dec(100);
   EXPECT_THAT(dec.scale(), 0);
   dec.rescale(2);
   EXPECT_THAT(dec.to_string(), "100.00");
 }
 
-TEST(BigDecimal, RescaleLowerCanBeLossy) {
+TEST(BigDecimalTest, RescaleLowerCanBeLossy) {
   math::bigdecimal dec("100.10");
   EXPECT_THAT(dec.scale(), 2);
   dec.rescale(0);
@@ -38,41 +38,41 @@ TEST(BigDecimal, RescaleLowerCanBeLossy) {
   EXPECT_THAT(dec.to_string(), "100.00");
 }
 
-TEST(BigDecimal, NegativeScaleLosesLowerDigits) {
+TEST(BigDecimalTest, NegativeScaleLosesLowerDigits) {
   math::bigdecimal dec("123", -2);
   EXPECT_THAT(dec.to_string(), "100");
 }
 
-TEST(BigDecimal, ConstructWithScaleEqualsWithout) {
+TEST(BigDecimalTest, ConstructWithScaleEqualsWithout) {
   math::bigdecimal scl(100, -2);
   EXPECT_THAT(scl.to_string(), "100");
 }
 
-TEST(BigDecimal, ScaleBelowNegSegDoesntLoseAnything) {
+TEST(BigDecimalTest, ScaleBelowNegSegDoesntLoseAnything) {
   math::bigdecimal dec("1000000000", -9);
   EXPECT_THAT(dec.to_string(), "1000000000");
 }
 
-TEST(BigDecimal, AddTwoDecimalsSameScale) {
+TEST(BigDecimalTest, AddTwoDecimalsSameScale) {
   math::bigdecimal a("1000.10");
   math::bigdecimal b("1000.01");
   EXPECT_THAT(a.scale(), b.scale());
   EXPECT_THAT((a+b).to_string(), "2000.11");
 }
 
-TEST(BigDecimal, AddTwoDecimalsDifferentScalesUsesHigherScale) {
+TEST(BigDecimalTest, AddTwoDecimalsDifferentScalesUsesHigherScale) {
   math::bigdecimal a("1000.10");
   math::bigdecimal b("1000");
   EXPECT_THAT(a.scale(), testing::Gt(b.scale()));
   EXPECT_THAT((a+b).to_string(), "2000.10");
 }
 
-TEST(BigDecimal, AddNumberWithInversePreservesScale) {
+TEST(BigDecimalTest, AddNumberWithInversePreservesScale) {
   math::bigdecimal a("1.001");
   EXPECT_THAT((a+(-a)).to_string(), "0.000");
 }
 
-TEST(BigDecimal, SubtractTwoDecimalsDifferentScalesUsesHigherScale) {
+TEST(BigDecimalTest, SubtractTwoDecimalsDifferentScalesUsesHigherScale) {
   math::bigdecimal a("900.10");
   math::bigdecimal b("1000");
   EXPECT_THAT(a.scale(), testing::Gt(b.scale()));
@@ -80,61 +80,61 @@ TEST(BigDecimal, SubtractTwoDecimalsDifferentScalesUsesHigherScale) {
   EXPECT_THAT((b-a).to_string(), "99.90");
 }
 
-TEST(BigDecimal, MultiplicationIncreasesScale) {
+TEST(BigDecimalTest, MultiplicationIncreasesScale) {
   math::bigdecimal bd("1.1");
   math::bigdecimal out = bd * bd;
   EXPECT_THAT(out.scale(), bd.scale() + bd.scale());
   EXPECT_THAT(out.to_string(), "1.21");
 }
 
-TEST(BigDecimal, MultiplicationNegativeScaleCountersPositiveScale) {
+TEST(BigDecimalTest, MultiplicationNegativeScaleCountersPositiveScale) {
   math::bigdecimal a("0.01");
   math::bigdecimal b("100", -2);
   EXPECT_THAT((a*b).to_string(), "1");
 }
 
-TEST(BigDecimal, MultiplicationCreateNewOffsetCell) {
+TEST(BigDecimalTest, MultiplicationCreateNewOffsetCell) {
   math::bigdecimal C(1, 5);
   EXPECT_THAT((C*C).to_string(), "1.0000000000");
 }
 
-TEST(BigDecimal, MultiplicationNegativeToPositiveScale) {
+TEST(BigDecimalTest, MultiplicationNegativeToPositiveScale) {
   math::bigdecimal C(1, 5);
   math::bigdecimal D(100, -2);
   EXPECT_THAT((D*C).to_string(), "100.000");
 }
 
-TEST(BigDecimal, MultiplicationFromDroppedToNonDropScale) {
+TEST(BigDecimalTest, MultiplicationFromDroppedToNonDropScale) {
   math::bigdecimal C(1, 5);
   math::bigdecimal E(1000000000, -9);
   EXPECT_THAT((E*C).to_string(), "1000000000");
 }
 
-TEST(BigDecimal, MultiplicationFromDroppedToLowerScale) {
+TEST(BigDecimalTest, MultiplicationFromDroppedToLowerScale) {
   math::bigdecimal D(100, -2);
   math::bigdecimal E(1000000000, -9);
   EXPECT_THAT((E*D).to_string(), "100000000000");
 }
 
-TEST(BigDecimal, MultiplicationFromNonDropToDroppedScale) {
+TEST(BigDecimalTest, MultiplicationFromNonDropToDroppedScale) {
   math::bigdecimal F(10000, -4);
   math::bigdecimal G(100000, -5);
   EXPECT_THAT((G*F).to_string(), "1000000000");
 }
 
-TEST(BigDecimal, DivideHigherScaleByLowerScale) {
+TEST(BigDecimalTest, DivideHigherScaleByLowerScale) {
   math::bigdecimal a("1", 2);
   math::bigdecimal b("1", 1);
   EXPECT_THAT((a/b).to_string(), "1.0");
 }
 
-TEST(BigDecimal, DivideLowerScaleByHigherScale) {
+TEST(BigDecimalTest, DivideLowerScaleByHigherScale) {
   math::bigdecimal a("10", 1);
   math::bigdecimal b("1", 2);
   EXPECT_THAT((a/b).to_string(), "10");
 }
 
-TEST(BigDecimal, DivideByLargerNumberGivesDecimalIfScaleAllows) {
+TEST(BigDecimalTest, DivideByLargerNumberGivesDecimalIfScaleAllows) {
   math::bigdecimal a("1" ,  0);
   math::bigdecimal b("1" ,  1);
   math::bigdecimal c("10",  0);

test/biginteger_test.cpp

@@ -9,33 +9,33 @@
 
 #include "biginteger.h"
 
-TEST(BigInteger, ModuloZeroThrows) {
+TEST(BigIntegerTest, ModuloZeroThrows) {
   math::biginteger bi{1000};
   EXPECT_THROW(bi%0, std::domain_error);
 }
 
-TEST(BigInteger, ModuloBiggerIsSameValue) {
+TEST(BigIntegerTest, ModuloBiggerIsSameValue) {
   math::biginteger bi{1000};
   EXPECT_THAT(bi%2000, bi);
 }
 
-TEST(BigInteger, ModuloSameNumberIsZero) {
+TEST(BigIntegerTest, ModuloSameNumberIsZero) {
   math::biginteger bi{1000};
   EXPECT_THAT(bi%1000, 0);
 }
 
-TEST(BigInteger, ModuloDivisorIsZero) {
+TEST(BigIntegerTest, ModuloDivisorIsZero) {
   math::biginteger bi{1000};
   EXPECT_THAT(bi%100, 0);
 }
 
-TEST(BigInteger, ModuloDiffSignIsInverseElement) {
+TEST(BigIntegerTest, ModuloDiffSignIsInverseElement) {
   math::biginteger bi{1000};
   math::biginteger mod{13};
   EXPECT_THAT((bi%mod)+((-bi)%mod), mod);
 }
 
-TEST(BigInteger, ModuloNegativesIsNegative) {
+TEST(BigIntegerTest, ModuloNegativesIsNegative) {
   math::biginteger bi{1000};
   math::biginteger mod{13};
   EXPECT_THAT((bi%mod), -((-bi)%(-mod)));

test/bignumber_integral_test.cpp

@@ -152,35 +152,3 @@ TYPED_TEST(BigIntLikeTest, DivisionWithLargeNumbers) {
   EXPECT_THAT((big/999999999ULL).to_string(),
                    "999999999");
 }
-//
-//  TYPED_TEST(BigIntLikeTest, ModuloZeroThrows) {
-//    BigNumber bi{1000};
-//    EXPECT_THROW(bi%0, std::domain_error);
-//  }
-//
-//  TYPED_TEST(BigIntLikeTest, ModuloBiggerIsSameValue) {
-//    BigNumber bi{1000};
-//    EXPECT_THAT(bi%2000, bi);
-//  }
-//
-//  TYPED_TEST(BigIntLikeTest, ModuloSameNumberIsZero) {
-//    BigNumber bi{1000};
-//    EXPECT_THAT(bi%1000, 0);
-//  }
-//
-//  TYPED_TEST(BigIntLikeTest, ModuloDivisorIsZero) {
-//    BigNumber bi{1000};
-//    EXPECT_THAT(bi%100, 0);
-//  }
-//
-//  TYPED_TEST(BigIntLikeTest, ModuloDiffSignIsInverseElement) {
-//    BigNumber bi{1000};
-//    BigNumber mod{13};
-//    EXPECT_THAT((bi%mod)+((-bi)%mod), mod);
-//  }
-//
-//  TYPED_TEST(BigIntLikeTest, ModuloNegativesIsNegative) {
-//    BigNumber bi{1000};
-//    BigNumber mod{13};
-//    EXPECT_THAT((bi%mod), -((-bi)%(-mod)));
-//  }