Implemented more general version of ForwardDiff/RevereseDiff.

webrtc/base/mod_ops_unittest.cc

Index: webrtc/base/mod_ops_unittest.cc
diff --git a/webrtc/base/mod_ops_unittest.cc b/webrtc/base/mod_ops_unittest.cc
index 13e638fb6e87ca62500aca0064bfba0447f62ea6..76484bc16b9da82c4875036565ef3a198ed57014 100644
--- a/webrtc/base/mod_ops_unittest.cc
+++ b/webrtc/base/mod_ops_unittest.cc
@@ -21,15 +21,15 @@ class TestModOps : public ::testing::Test {
 
 TEST_F(TestModOps, Add) {
   const int D = 100;
-  EXPECT_EQ(1u, Add<D>(0, 1));
-  EXPECT_EQ(0u, Add<D>(0, D));
+  ASSERT_EQ(1u, Add<D>(0, 1));
+  ASSERT_EQ(0u, Add<D>(0, D));
   for (int i = 0; i < D; ++i)
-    EXPECT_EQ(0u, Add<D>(i, D - i));
+    ASSERT_EQ(0u, Add<D>(i, D - i));
 
   int t = 37;
   uint8_t a = t;
   for (int i = 0; i < 256; ++i) {
-    EXPECT_EQ(a, static_cast<uint8_t>(t));
+    ASSERT_EQ(a, static_cast<uint8_t>(t));
     t = Add<256>(t, 1);
     ++a;
   }
@@ -39,22 +39,22 @@ TEST_F(TestModOps, AddLarge) {
   // NOLINTNEXTLINE
   const unsigned long D = ulmax - 10ul;  // NOLINT
   unsigned long l = D - 1ul;             // NOLINT
-  EXPECT_EQ(D - 2ul, Add<D>(l, l));
-  EXPECT_EQ(9ul, Add<D>(l, ulmax));
-  EXPECT_EQ(10ul, Add<D>(0ul, ulmax));
+  ASSERT_EQ(D - 2ul, Add<D>(l, l));
+  ASSERT_EQ(9ul, Add<D>(l, ulmax));
+  ASSERT_EQ(10ul, Add<D>(0ul, ulmax));
 }
 
 TEST_F(TestModOps, Subtract) {
   const int D = 100;
-  EXPECT_EQ(99u, Subtract<D>(0, 1));
-  EXPECT_EQ(0u, Subtract<D>(0, D));
+  ASSERT_EQ(99u, Subtract<D>(0, 1));
+  ASSERT_EQ(0u, Subtract<D>(0, D));
   for (int i = 0; i < D; ++i)
-    EXPECT_EQ(0u, Subtract<D>(i, D + i));
+    ASSERT_EQ(0u, Subtract<D>(i, D + i));
 
   int t = 37;
   uint8_t a = t;
   for (int i = 0; i < 256; ++i) {
-    EXPECT_EQ(a, static_cast<uint8_t>(t));
+    ASSERT_EQ(a, static_cast<uint8_t>(t));
     t = Subtract<256>(t, 1);
     --a;
   }
@@ -64,44 +64,44 @@ TEST_F(TestModOps, SubtractLarge) {
   // NOLINTNEXTLINE
   const unsigned long D = ulmax - 10ul;  // NOLINT
   unsigned long l = D - 1ul;             // NOLINT
-  EXPECT_EQ(0ul, Subtract<D>(l, l));
-  EXPECT_EQ(D - 11ul, Subtract<D>(l, ulmax));
-  EXPECT_EQ(D - 10ul, Subtract<D>(0ul, ulmax));
+  ASSERT_EQ(0ul, Subtract<D>(l, l));
+  ASSERT_EQ(D - 11ul, Subtract<D>(l, ulmax));
+  ASSERT_EQ(D - 10ul, Subtract<D>(0ul, ulmax));
 }
 
 TEST_F(TestModOps, ForwardDiff) {
-  EXPECT_EQ(0u, ForwardDiff(4711u, 4711u));
+  ASSERT_EQ(0u, ForwardDiff(4711u, 4711u));
 
   uint8_t x = 0;
   uint8_t y = 255;
   for (int i = 0; i < 256; ++i) {
-    EXPECT_EQ(255u, ForwardDiff(x, y));
+    ASSERT_EQ(255u, ForwardDiff(x, y));
     ++x;
     ++y;
   }
 
   int yi = 255;
   for (int i = 0; i < 256; ++i) {
-    EXPECT_EQ(255u, ForwardDiff<uint8_t>(x, yi));
+    ASSERT_EQ(255u, ForwardDiff<uint8_t>(x, yi));
     ++x;
     ++yi;
   }
 }
 
 TEST_F(TestModOps, ReverseDiff) {
-  EXPECT_EQ(0u, ReverseDiff(4711u, 4711u));
+  ASSERT_EQ(0u, ReverseDiff(4711u, 4711u));
 
   uint8_t x = 0;
   uint8_t y = 255;
   for (int i = 0; i < 256; ++i) {
-    EXPECT_EQ(1u, ReverseDiff(x, y));
+    ASSERT_EQ(1u, ReverseDiff(x, y));
     ++x;
     ++y;
   }
 
   int yi = 255;
   for (int i = 0; i < 256; ++i) {
-    EXPECT_EQ(1u, ReverseDiff<uint8_t>(x, yi));
+    ASSERT_EQ(1u, ReverseDiff<uint8_t>(x, yi));
     ++x;
     ++yi;
   }
@@ -110,37 +110,37 @@ TEST_F(TestModOps, ReverseDiff) {
 TEST_F(TestModOps, AheadOrAt) {
   uint8_t x = 0;
   uint8_t y = 0;
-  EXPECT_TRUE(AheadOrAt(x, y));
+  ASSERT_TRUE(AheadOrAt(x, y));
   ++x;
-  EXPECT_TRUE(AheadOrAt(x, y));
-  EXPECT_FALSE(AheadOrAt(y, x));
+  ASSERT_TRUE(AheadOrAt(x, y));
+  ASSERT_FALSE(AheadOrAt(y, x));
   for (int i = 0; i < 256; ++i) {
-    EXPECT_TRUE(AheadOrAt(x, y));
+    ASSERT_TRUE(AheadOrAt(x, y));
     ++x;
     ++y;
   }
 
   x = 128;
   y = 0;
-  EXPECT_TRUE(AheadOrAt(x, y));
-  EXPECT_FALSE(AheadOrAt(y, x));
+  ASSERT_TRUE(AheadOrAt(x, y));
+  ASSERT_FALSE(AheadOrAt(y, x));
 
   x = 129;
-  EXPECT_FALSE(AheadOrAt(x, y));
-  EXPECT_TRUE(AheadOrAt(y, x));
-  EXPECT_TRUE(AheadOrAt<uint16_t>(x, y));
-  EXPECT_FALSE(AheadOrAt<uint16_t>(y, x));
+  ASSERT_FALSE(AheadOrAt(x, y));
+  ASSERT_TRUE(AheadOrAt(y, x));
+  ASSERT_TRUE(AheadOrAt<uint16_t>(x, y));
+  ASSERT_FALSE(AheadOrAt<uint16_t>(y, x));
 }
 
 TEST_F(TestModOps, AheadOf) {
   uint8_t x = 0;
   uint8_t y = 0;
-  EXPECT_FALSE(AheadOf(x, y));
+  ASSERT_FALSE(AheadOf(x, y));
   ++x;
-  EXPECT_TRUE(AheadOf(x, y));
-  EXPECT_FALSE(AheadOf(y, x));
+  ASSERT_TRUE(AheadOf(x, y));
+  ASSERT_FALSE(AheadOf(y, x));
   for (int i = 0; i < 256; ++i) {
-    EXPECT_TRUE(AheadOf(x, y));
+    ASSERT_TRUE(AheadOf(x, y));
     ++x;
     ++y;
   }
@@ -148,25 +148,55 @@ TEST_F(TestModOps, AheadOf) {
   x = 128;
   y = 0;
   for (int i = 0; i < 128; ++i) {
-    EXPECT_TRUE(AheadOf(x, y));
-    EXPECT_FALSE(AheadOf(y, x));
+    ASSERT_TRUE(AheadOf(x, y));
+    ASSERT_FALSE(AheadOf(y, x));
     x++;
     y++;
   }
 
   for (int i = 0; i < 128; ++i) {
-    EXPECT_FALSE(AheadOf(x, y));
-    EXPECT_TRUE(AheadOf(y, x));
+    ASSERT_FALSE(AheadOf(x, y));
+    ASSERT_TRUE(AheadOf(y, x));
     x++;
     y++;
   }
 
   x = 129;
   y = 0;
-  EXPECT_FALSE(AheadOf(x, y));
-  EXPECT_TRUE(AheadOf(y, x));
-  EXPECT_TRUE(AheadOf<uint16_t>(x, y));
-  EXPECT_FALSE(AheadOf<uint16_t>(y, x));
+  ASSERT_FALSE(AheadOf(x, y));
+  ASSERT_TRUE(AheadOf(y, x));
+  ASSERT_TRUE(AheadOf<uint16_t>(x, y));
+  ASSERT_FALSE(AheadOf<uint16_t>(y, x));
+}
+
+TEST_F(TestModOps, ForwardDiffWithDivisor) {
+  const uint8_t kDivisor = 211;
+
+  for (uint8_t i = 0; i < kDivisor - 1; ++i) {
+    ASSERT_EQ(0, (ForwardDiff<uint8_t, kDivisor>(i, i)));
+    ASSERT_EQ(1, (ForwardDiff<uint8_t, kDivisor>(i, i + 1)));
+    ASSERT_EQ(kDivisor - 1, (ForwardDiff<uint8_t, kDivisor>(i + 1, i)));
+  }
+
+  for (uint8_t i = 1; i < kDivisor; ++i) {
+    ASSERT_EQ(i, (ForwardDiff<uint8_t, kDivisor>(0, i)));
+    ASSERT_EQ(kDivisor - i, (ForwardDiff<uint8_t, kDivisor>(i, 0)));
+  }
+}
+
+TEST_F(TestModOps, ReverseDiffWithDivisor) {
+  const uint8_t kDivisor = 241;
+
+  for (uint8_t i = 0; i < kDivisor - 1; ++i) {
+    ASSERT_EQ(0, (ReverseDiff<uint8_t, kDivisor>(i, i)));
+    ASSERT_EQ(kDivisor - 1, (ReverseDiff<uint8_t, kDivisor>(i, i + 1)));
+    ASSERT_EQ(1, (ReverseDiff<uint8_t, kDivisor>(i + 1, i)));
+  }
+
+  for (uint8_t i = 1; i < kDivisor; ++i) {
+    ASSERT_EQ(kDivisor - i, (ReverseDiff<uint8_t, kDivisor>(0, i)));
+    ASSERT_EQ(i, (ReverseDiff<uint8_t, kDivisor>(i, 0)));
+  }
 }
 
 }  // namespace webrtc