Move tests to use catch instead of googletest

.gitmodules

@@ -1,3 +1,3 @@
-[submodule "third_party/googletest"]
-	path = third_party/googletest
-	url = https://github.com/google/googletest.git
+[submodule "third_party/Catch2"]
+	path = third_party/Catch2
+	url = https://github.com/catchorg/Catch2.git

.travis.yml

@@ -40,4 +40,4 @@ script:
   - cmake .. -DRDKAFKA_ROOT_DIR=../librdkafka/install/ -DKAFKA_TEST_INSTANCE=localhost:9092
   - make examples
   - make tests
-  - ctest -V
+  - ./tests/cppkafka_tests

CMakeLists.txt

@@ -62,30 +62,14 @@ if(DOXYGEN_FOUND)
 endif(DOXYGEN_FOUND)
 
 if(NOT CPPKAFKA_DISABLE_TESTS)
-    set(GOOGLETEST_ROOT ${CMAKE_SOURCE_DIR}/third_party/googletest)
-    if(EXISTS "${GOOGLETEST_ROOT}/CMakeLists.txt")
-        set(GOOGLETEST_INCLUDE ${GOOGLETEST_ROOT}/googletest/include)
-        set(GOOGLETEST_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/googletest)
-        set(GOOGLETEST_LIBRARY ${GOOGLETEST_BINARY_DIR}/googletest)
-
-        include(ExternalProject)
-
-        ExternalProject_Add(
-        googletest
-        DOWNLOAD_COMMAND ""
-        SOURCE_DIR ${GOOGLETEST_ROOT}
-        BINARY_DIR ${GOOGLETEST_BINARY_DIR}
-        CMAKE_CACHE_ARGS "-DBUILD_GTEST:bool=ON" "-DBUILD_GMOCK:bool=OFF"
-                        "-Dgtest_force_shared_crt:bool=ON"
-        INSTALL_COMMAND ""
-        )
+    set(CATCH_ROOT ${CMAKE_SOURCE_DIR}/third_party/Catch2)
+    if(EXISTS ${CATCH_ROOT}/CMakeLists.txt)
+        set(CATCH_INCLUDE ${CATCH_ROOT}/single_include)
 
         enable_testing()
         add_subdirectory(tests)
-        # Make sure we build googletest before anything else
-        add_dependencies(cppkafka googletest)
     else()
-        message(STATUS "Disabling tests because submodule googletest isn't pulled out")
+        message(STATUS "Disabling tests because submodule Catch2 isn't checked out")
     endif()
 endif()
 

tests/CMakeLists.txt

@@ -1,31 +1,31 @@
-include_directories(${GOOGLETEST_INCLUDE})
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../include/)
+include_directories(SYSTEM ${CATCH_INCLUDE})
 include_directories(SYSTEM ${Boost_INCLUDE_DIRS} ${RDKAFKA_INCLUDE_DIR})
 
-link_directories(${GOOGLETEST_LIBRARY})
-link_libraries(cppkafka ${RDKAFKA_LIBRARY} gtest gtest_main pthread)
-
 set(KAFKA_TEST_INSTANCE "kafka-vm:9092" 
     CACHE STRING "The kafka instance to which to connect to run tests")
 add_custom_target(tests)
 
-macro(create_test test_name)
-    add_executable(${test_name}_test EXCLUDE_FROM_ALL "${test_name}_test.cpp")
-    add_test(${test_name} ${test_name}_test)
-    add_dependencies(tests ${test_name}_test)
-    add_dependencies(${test_name}_test cppkafka)
-    target_link_libraries(${test_name}_test cppkafka-test)
-endmacro()
-
 include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 add_library(cppkafka-test EXCLUDE_FROM_ALL test_utils.cpp)
-add_dependencies(cppkafka-test cppkafka)
+target_link_libraries(cppkafka-test cppkafka ${RDKAFKA_LIBRARY} pthread)
 
 add_definitions("-DKAFKA_TEST_INSTANCE=\"${KAFKA_TEST_INSTANCE}\"")
-create_test(consumer)
-create_test(producer)
-create_test(kafka_handle_base)
-create_test(topic_partition_list)
-create_test(configuration)
-create_test(buffer)
-create_test(compacted_topic_processor)
+
+add_executable(
+    cppkafka_tests
+    EXCLUDE_FROM_ALL
+    buffer_test.cpp
+    compacted_topic_processor_test.cpp
+    configuration_test.cpp
+    topic_partition_list_test.cpp
+    kafka_handle_base_test.cpp
+    producer_test.cpp
+    consumer_test.cpp
+
+    # Main file
+    test_main.cpp
+)
+target_link_libraries(cppkafka_tests cppkafka-test)
+add_dependencies(tests cppkafka_tests)
+add_test(cppkafka cppkafka_tests)

tests/buffer_test.cpp

@@ -1,7 +1,7 @@
 #include <string>
 #include <vector>
 #include <sstream>
-#include <gtest/gtest.h>
+#include <catch.hpp>
 #include "cppkafka/buffer.h"
 
 using std::string;
@@ -10,69 +10,59 @@ using std::ostringstream;
 
 using namespace cppkafka;
 
-class BufferTest : public testing::Test {
-public:
-
-};
+TEST_CASE("conversions", "[buffer]") {
+    const string data = "Hello world!";
+    const Buffer buffer(data);
+    const Buffer empty_buffer;
 
-TEST_F(BufferTest, OperatorBool) {
-    string data = "Hello world!";
-    Buffer buffer1(data);
-    Buffer buffer2;
 
-    EXPECT_TRUE(buffer1);
-    EXPECT_FALSE(buffer2);
-}
+    SECTION("bool conversion") {
+        CHECK(!!buffer == true);
+        CHECK(!!empty_buffer == false);
+    }
 
-TEST_F(BufferTest, StringConversion) {
-    string data = "Hello world!";
-    Buffer buffer(data);
-    string buffer_as_string = buffer;
-    EXPECT_EQ(data, buffer_as_string);
-}
+    SECTION("string conversion") {
+        CHECK(static_cast<string>(buffer) == data);
+        CHECK(static_cast<string>(empty_buffer).empty());
+    }
 
-TEST_F(BufferTest, StringConversionOnEmptyBuffer) {
-    Buffer buffer;
-    EXPECT_EQ("", static_cast<string>(buffer));
+    SECTION("vector conversion") {
+        const vector<char> buffer_as_vector = buffer;
+        CHECK(string(buffer_as_vector.begin(), buffer_as_vector.end()) == data);
+    }
 }
 
-TEST_F(BufferTest, VectorConversion) {
-    string data = "Hello world!";
-    Buffer buffer(data);
-    vector<char> buffer_as_vector = buffer;
-    EXPECT_EQ(data, string(buffer_as_vector.begin(), buffer_as_vector.end()));
-}
-
-TEST_F(BufferTest, VectorConstruction) {
+TEST_CASE("construction", "[buffer]") {
     const string str_data = "Hello world!";
     const vector<uint8_t> data(str_data.begin(), str_data.end());
-    Buffer buffer(data);
-    EXPECT_EQ(str_data, buffer);
+    const Buffer buffer(data);
+    CHECK(str_data == buffer);
 }
 
-TEST_F(BufferTest, Equality) {
-    string data = "Hello world!";
-    Buffer buffer1(data);
-    Buffer buffer2(data);
 
-    EXPECT_EQ(buffer1, buffer2);
-}
+TEST_CASE("comparison", "[buffer]") {
+    const string data = "Hello world!";
+    const Buffer buffer1(data);
+    const Buffer buffer2(data);
+    const Buffer empty_buffer;
 
-TEST_F(BufferTest, InEquality) {
-    string data1 = "Hello world!";
-    string data2 = "Hello worldz";
-    Buffer buffer1(data1);
-    Buffer buffer2(data2);
+    SECTION("equality") {
+        CHECK(buffer1 == buffer2);
+        CHECK(buffer2 == buffer1);
+    }
 
-    EXPECT_NE(buffer1, buffer2);
+    SECTION("inequality") {
+        CHECK(buffer1 != empty_buffer);
+        CHECK(empty_buffer != buffer1);
+    }
 }
 
-TEST_F(BufferTest, OutputOperator) {
-    string data = "Hello \x7fwor\x03ld!";
-    string pretty_string = "Hello \\x7fwor\\x03ld!";
-    Buffer buffer(data);
+TEST_CASE("stream extraction", "[buffer]") {
+    const string data = "Hello \x7fwor\x03ld!";
+    const string pretty_string = "Hello \\x7fwor\\x03ld!";
+    const Buffer buffer(data);
 
     ostringstream output;
     output << buffer;
-    EXPECT_EQ(pretty_string, output.str());
+    CHECK(output.str() == pretty_string );
 }

tests/compacted_topic_processor_test.cpp

@@ -4,7 +4,7 @@
 #include <set>
 #include <map>
 #include <condition_variable>
-#include <gtest/gtest.h>
+#include <catch.hpp>
 #include "cppkafka/producer.h"
 #include "cppkafka/consumer.h"
 #include "cppkafka/utils/compacted_topic_processor.h"
@@ -29,28 +29,23 @@ using std::chrono::milliseconds;
 
 using namespace cppkafka;
 
-class CompactedTopicProcessorTest : public testing::Test {
-public:
-    static const string KAFKA_TOPIC;
+static const string KAFKA_TOPIC = "cppkafka_test1";
 
-    Configuration make_producer_config() {
-        Configuration config;
-        config.set("metadata.broker.list", KAFKA_TEST_INSTANCE);
-        return config;
-    }
-
-    Configuration make_consumer_config() {
-        Configuration config;
-        config.set("metadata.broker.list", KAFKA_TEST_INSTANCE);
-        config.set("enable.auto.commit", false);
-        config.set("group.id", "compacted_topic_test");
-        return config;
-    }
-};
+static Configuration make_producer_config() {
+    Configuration config;
+    config.set("metadata.broker.list", KAFKA_TEST_INSTANCE);
+    return config;
+}
 
-const string CompactedTopicProcessorTest::KAFKA_TOPIC = "cppkafka_test1";
+static Configuration make_consumer_config() {
+    Configuration config;
+    config.set("metadata.broker.list", KAFKA_TEST_INSTANCE);
+    config.set("enable.auto.commit", false);
+    config.set("group.id", "compacted_topic_test");
+    return config;
+}
 
-TEST_F(CompactedTopicProcessorTest, Consume) {
+TEST_CASE("consumption", "[consumer][compacted]") {
     Consumer consumer(make_consumer_config());
     // We'll use ints as the key, strings as the value
     using CompactedConsumer = CompactedTopicProcessor<int, string>;
@@ -101,27 +96,27 @@ TEST_F(CompactedTopicProcessorTest, Consume) {
 
     size_t set_count = 0;
     size_t delete_count = 0;
-    ASSERT_FALSE(events.empty());
+    CHECK(events.empty() == false);
     for (const Event& event : events) {
         switch (event.get_type()) {
             case Event::SET_ELEMENT:
                 {
                     auto iter = elements.find(to_string(event.get_key()));
-                    ASSERT_NE(iter, elements.end());
-                    EXPECT_EQ(iter->second.value, event.get_value());
-                    EXPECT_EQ(iter->second.partition, event.get_partition());
+                    REQUIRE(iter != elements.end());
+                    CHECK(iter->second.value == event.get_value());
+                    CHECK(iter->second.partition == event.get_partition());
                     set_count++;
                 }
                 break;
             case Event::DELETE_ELEMENT:
-                EXPECT_EQ(0, event.get_partition());
-                EXPECT_EQ(42, event.get_key());
+                CHECK(event.get_partition() == 0);
+                CHECK(event.get_key() == 42);
                 delete_count++;
                 break;
             default:
             break;
         } 
     }
-    EXPECT_EQ(2, set_count);
-    EXPECT_EQ(1, delete_count);
+    CHECK(set_count == 2);
+    CHECK(delete_count == 1);
 }