From b6372d40f0ad73529fe23f44dafd16c521bfd091 Mon Sep 17 00:00:00 2001
From: Vasily Nemkov <V.Nemkov@gmail.com>
Date: Sun, 1 Dec 2019 22:23:17 +0300
Subject: [PATCH] More accurate and complex test for BitWriter and BitReader

---
 dbms/src/IO/tests/gtest_bit_io.cpp | 71 ++++++++++++++++++++++--------
 1 file changed, 53 insertions(+), 18 deletions(-)

diff --git a/dbms/src/IO/tests/gtest_bit_io.cpp b/dbms/src/IO/tests/gtest_bit_io.cpp
index 85df2580783..82b943dc2e4 100644
--- a/dbms/src/IO/tests/gtest_bit_io.cpp
+++ b/dbms/src/IO/tests/gtest_bit_io.cpp
@@ -36,11 +36,11 @@ std::string bin(const T & value, size_t bits = sizeof(T)*8)
             .to_string().substr(MAX_BITS - bits, bits);
 }
 
+// gets N low bits of value
 template <typename T>
 T getBits(UInt8 bits, const T & value)
 {
-    const T mask = ((static_cast<T>(1) << static_cast<T>(bits)) - 1);
-    return value & mask;
+    return value & maskLowBits<T>(bits);
 }
 
 template <typename T>
@@ -88,7 +88,7 @@ struct TestCaseParameter
     std::vector<std::pair<UInt8, UInt64>> bits_and_vals;
     std::string expected_buffer_binary;
 
-    explicit TestCaseParameter(std::vector<std::pair<UInt8, UInt64>> vals, std::string binary = std::string{})
+    TestCaseParameter(std::vector<std::pair<UInt8, UInt64>> vals, std::string binary = std::string{})
         : bits_and_vals(std::move(vals)),
           expected_buffer_binary(binary)
     {}
@@ -135,36 +135,71 @@ TEST_P(BitIO, WriteAndRead)
 
         BitReader reader(read_buffer);
 
+        int bitpos = 0;
         int item = 0;
         for (const auto & bv : bits_and_vals)
         {
             SCOPED_TRACE(::testing::Message()
                          << "item #" << item << ", width: " << static_cast<UInt32>(bv.first)
-                         << ", value: " << bin(bv.second)
-                         << ".\n\n\nBuffer memory:\n" << dumpContents(data));
+                         << ", value: " << bv.second << "(" << bin(bv.second) << ")"
+                         << ", at bit position: " << std::dec << bitpos
+                         << ".\nBuffer memory:\n" << dumpContents(data));
 
             //EXPECT_EQ(getBits(bv.first, bv.second), reader.peekBits(bv.first));
             EXPECT_EQ(getBits(bv.first, bv.second), reader.readBits(bv.first));
 
             ++item;
+            bitpos += bv.first;
         }
     }
 }
 
 INSTANTIATE_TEST_CASE_P(Simple,
-        BitIO,
-        ::testing::Values(
-            TestCaseParameter(
-                {{9, 0xFFFFFFFF}, {9, 0x00}, {9, 0xFFFFFFFF}, {9, 0x00}, {9, 0xFFFFFFFF}},
-                "11111111 10000000 00111111 11100000 00001111 11111000 "),
-            TestCaseParameter(
-                {{7, 0x3f}, {7, 0x3f}, {7, 0x3f}, {7, 0x3f}, {7, 0x3f}, {7, 0x3f}, {7, 0x3f}, {7, 0x3f}, {7, 0x3f}, {3, 0xFFFF}},
-                "01111110 11111101 11111011 11110111 11101111 11011111 10111111 01111111 11000000 "),
-            TestCaseParameter({{33, 0xFF110d0b07050300}, {33, 0xAAEE29251f1d1713}}),
-            TestCaseParameter({{33, BIT_PATTERN}, {33, BIT_PATTERN}}),
-            TestCaseParameter({{24, 0xFFFFFFFF}},
-                "11111111 11111111 11111111 ")
-),);
+    BitIO,
+    ::testing::ValuesIn(std::initializer_list<TestCaseParameter>{
+        {
+            {{9, 0xFFFFFFFF}, {9, 0x00}, {9, 0xFFFFFFFF}, {9, 0x00}, {9, 0xFFFFFFFF}},
+            "11111111 10000000 00111111 11100000 00001111 11111000 "
+        },
+        {
+            {{7, 0x3f}, {7, 0x3f}, {7, 0x3f}, {7, 0x3f}, {7, 0x3f}, {7, 0x3f}, {7, 0x3f}, {7, 0x3f}, {7, 0x3f}, {3, 0xFFFF}},
+            "01111110 11111101 11111011 11110111 11101111 11011111 10111111 01111111 11000000 "
+        },
+        {
+            {{33, 0xFF110d0b07050300}, {33, 0xAAEE29251f1d1713}}
+        },
+        {
+            {{33, BIT_PATTERN}, {33, BIT_PATTERN}}
+        },
+        {
+            {{24, 0xFFFFFFFF}},
+            "11111111 11111111 11111111 "
+        },
+        {
+            // Note that we take only N lower bits of the number: {3, 0b01011} => 011
+            {{5, 0b01010}, {3, 0b111}, {7, 0b11001100}, {6, 0}, {5, 0b11111111}, {4, 0}, {3, 0b101}, {2, 0}, {1, 0b11111111}},
+            "01010111 10011000 00000111 11000010 10010000 "
+        },
+        {
+            {{64, BIT_PATTERN}, {56, BIT_PATTERN} , {4, 0b1111}, {4, 0}, // 128
+             {8, 0b11111111}, {64, BIT_PATTERN}, {48, BIT_PATTERN}, {8, 0}}, // 256
+            "11101011 11101111 10111010 11101111 10101111 10111010 11101011 10101001 " // 64
+            "11101111 10111010 11101111 10101111 10111010 11101011 10101001 11110000 " // 128
+            "11111111 11101011 11101111 10111010 11101111 10101111 10111010 11101011 " // 192
+            "10101001 10111010 11101111 10101111 10111010 11101011 10101001 00000000 " // 256
+        },
+        {
+            {{64, BIT_PATTERN}, {56, BIT_PATTERN} , {4, 0b1111}, {4, 0}, // 128
+             {8, 0b11111111}, {64, BIT_PATTERN}, {48, BIT_PATTERN}, {8, 0}, //256
+             {32, BIT_PATTERN}, {12, 0xff}, {8, 0}, {12, 0xAEff}},
+            "11101011 11101111 10111010 11101111 10101111 10111010 11101011 10101001 " // 64
+            "11101111 10111010 11101111 10101111 10111010 11101011 10101001 11110000 " // 128
+            "11111111 11101011 11101111 10111010 11101111 10101111 10111010 11101011 " // 192
+            "10101001 10111010 11101111 10101111 10111010 11101011 10101001 00000000 " // 256
+            "10101111 10111010 11101011 10101001 00001111 11110000 00001110 11111111 " // 320
+        }
+    }),
+);
 
 TestCaseParameter primes_case(UInt8 repeat_times, UInt64 pattern)
 {