Add tests for lastbit.h.

src/CMakeLists.txt

@@ -40,6 +40,7 @@ include_directories(lib/)
 set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 add_subdirectory(lib/pokerstove/peval)
 add_subdirectory(lib/pokerstove/penum)
+add_subdirectory(lib/pokerstove/util)
 add_subdirectory(programs/ps-colex)
 add_subdirectory(programs/ps-eval)
-add_subdirectory(programs/ps-lut)
+add_subdirectory(programs/ps-lut)

src/lib/pokerstove/util/CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 2.8)
+
+set (CMAKE_CXX_FLAGS "-Wno-deprecated-register")
+
+# build the test 
+file(GLOB test_sources *.test.cpp)
+add_executable(util_tests ${test_sources})
+target_link_libraries(util_tests peval gtest gtest_main)
+
+# there are no libraries, only headers
+
+add_test(TestUtil ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/util_tests)

src/lib/pokerstove/util/lastbit.test.cpp

@@ -0,0 +1,104 @@
+#include <gtest/gtest.h>
+#include "lastbit.h"
+
+TEST(FirstBitTest, firstbit64) {
+    // firstbit arg is uint64_t
+    // There are no overloads, so we don't have to worry about which
+    // one is being tested.
+    EXPECT_EQ(0, firstbit(0));
+    EXPECT_EQ(0, firstbit(1));
+    EXPECT_EQ(1, firstbit(2));
+    EXPECT_EQ(1, firstbit(3));
+    EXPECT_EQ(2, firstbit(4));
+    EXPECT_EQ(4, firstbit(31));
+    EXPECT_EQ(5, firstbit(32));
+
+    for (int i = 1; i < 64; i++) {
+        EXPECT_EQ(i - 1, firstbit((1uLL << i) - 1));
+        EXPECT_EQ(i,     firstbit((1uLL << i)));
+    }
+}
+
+TEST(LastBitTest, lastbit32) {
+    // There are uint16_t, uint32_t and uint64_t overloads of lastbit.
+    // Explicitly cast arg so we know which we are testing.
+    EXPECT_EQ(0, lastbit(uint32_t(0)));
+    EXPECT_EQ(0, lastbit(uint32_t(1)));
+    EXPECT_EQ(1, lastbit(uint32_t(2)));
+    EXPECT_EQ(0, lastbit(uint32_t(3)));
+    EXPECT_EQ(2, lastbit(uint32_t(4)));
+    EXPECT_EQ(0, lastbit(uint32_t(31)));
+    EXPECT_EQ(5, lastbit(uint32_t(32)));
+    EXPECT_EQ(2, lastbit(uint32_t(36)));
+
+    for (int i = 1; i < 32; i++) {
+        EXPECT_EQ(0, lastbit(uint32_t((1u << i) - 1)));
+        EXPECT_EQ(i, lastbit(uint32_t((1u << i))));
+        EXPECT_EQ(0, lastbit(uint32_t((1u << i) + 1)));
+        // Set a higher bit also.
+        if (i < 30)
+            EXPECT_EQ(i, lastbit(uint32_t((1u << i) | (1u << (i + 2)))));
+    }
+}
+
+TEST(LastBitTest, lastbit16) {
+    // There are uint16_t, uint32_t and uint64_t overloads of lastbit.
+    // Explicitly cast arg so we know which we are testing.
+    EXPECT_EQ(0, lastbit(uint16_t(0)));
+    EXPECT_EQ(0, lastbit(uint16_t(1)));
+    EXPECT_EQ(1, lastbit(uint16_t(2)));
+    EXPECT_EQ(0, lastbit(uint16_t(3)));
+    EXPECT_EQ(2, lastbit(uint16_t(4)));
+    EXPECT_EQ(0, lastbit(uint16_t(31)));
+    EXPECT_EQ(5, lastbit(uint16_t(32)));
+    EXPECT_EQ(2, lastbit(uint16_t(36)));
+
+    for (int i = 1; i < 16; i++) {
+        EXPECT_EQ(0, lastbit(uint16_t((1u << i) - 1)));
+        EXPECT_EQ(i, lastbit(uint16_t((1u << i))));
+        EXPECT_EQ(0, lastbit(uint16_t((1u << i) + 1)));
+        if (i < 14)
+            EXPECT_EQ(i, lastbit(uint16_t((1u << i) | (1u << (i + 2)))));
+    }
+}
+
+TEST(LastBitTest, lastbit64) {
+    // There are uint16_t, uint32_t and uint64_t overloads of lastbit.
+    // Explicitly cast arg so we know which we are testing.
+    EXPECT_EQ(0, lastbit(uint64_t(0)));
+    EXPECT_EQ(0, lastbit(uint64_t(1)));
+    EXPECT_EQ(1, lastbit(uint64_t(2)));
+    EXPECT_EQ(0, lastbit(uint64_t(3)));
+    EXPECT_EQ(2, lastbit(uint64_t(4)));
+    EXPECT_EQ(0, lastbit(uint64_t(31)));
+    EXPECT_EQ(5, lastbit(uint64_t(32)));
+    EXPECT_EQ(2, lastbit(uint64_t(36)));
+
+    for (int i = 1; i < 64; i++) {
+        EXPECT_EQ(0, lastbit(uint64_t((1uLL << i) - 1)));
+        EXPECT_EQ(i, lastbit(uint64_t((1uLL << i))));
+        EXPECT_EQ(0, lastbit(uint64_t((1uLL << i) + 1)));
+        if (i < 62)
+            EXPECT_EQ(i, lastbit(uint64_t((1uLL << i) | (1uLL << (i + 2)))));
+    }
+}
+
+TEST(LastBit64Test, lastbit64) {
+    // No overloads for this function.
+    EXPECT_EQ(0, lastbit64(0));
+    EXPECT_EQ(0, lastbit64(1));
+    EXPECT_EQ(1, lastbit64(2));
+    EXPECT_EQ(0, lastbit64(3));
+    EXPECT_EQ(2, lastbit64(4));
+    EXPECT_EQ(0, lastbit64(31));
+    EXPECT_EQ(5, lastbit64(32));
+    EXPECT_EQ(2, lastbit64(36));
+
+    for (int i = 1; i < 64; i++) {
+        EXPECT_EQ(0, lastbit64((1uLL << i) - 1));
+        EXPECT_EQ(i, lastbit64((1uLL << i)));
+        EXPECT_EQ(0, lastbit64((1uLL << i) + 1));
+        if (i < 62)
+            EXPECT_EQ(i, lastbit64((1uLL << i) | (1uLL << (i + 2))));
+    }
+}