GTEST or CPP Test

[Ulrond]

Comparing Google Test (GTest) and CppTest in terms of their class and assertion structures, and how to translate tests between them.

Class Structures

• GTest: Uses macros (TEST, TEST_F, TEST_P) to define test cases. Test fixtures are created by defining classes that inherit from ::testing::Test.

  TEST(MyTestSuite, MyTestCase) {
      // Test logic here
  }
  
  class MyTestFixture : public ::testing::Test {
   protected:
      void SetUp() override { /* Setup code */ }
      void TearDown() override { /* Teardown code */ }
  };
  
  TEST_F(MyTestFixture, MyFixtureTestCase) {
      // Test logic using fixture members
  }

• CppTest: Uses macros (TEST_SUITE, TEST) to define test suites and cases. Test fixtures are classes with special setup() and teardown() methods.

  TEST_SUITE(MyTestSuite) { 
      class MyTestFixture {
       public:
          void setup() { /* Setup code */ }
          void teardown() { /* Teardown code */ }
      };
  
      TEST(MyTestSuite, MyTestCase) {
          // Test logic here
      }
  
      TEST_FIXTURE(MyTestFixture, MyFixtureTestCase) {
          // Test logic using fixture members
      }
  }

Assertion Structures

• GTest: Provides a rich set of ASSERT_* (fatal) and EXPECT_* (non-fatal) macros for assertions.

  ASSERT_EQ(expected, actual);
  EXPECT_TRUE(condition);
  ASSERT_NE(value1, value2);

• CppTest: Uses CHECK macros for assertions (mostly fatal, with some non-fatal variations).

  CHECK(condition);
  CHECK_EQUAL(expected, actual);
  CHECK_THROW(expression, exception_type);

Translating Between GTest and CppTest

Here's a general approach to translate tests between GTest and CppTest:

1. Test Cases: Replace GTest's TEST macro with CppTest's TEST macro within a TEST_SUITE.

2. Test Fixtures:

   • GTest: Inherit from ::testing::Test and use SetUp()/TearDown().
   • CppTest: Create a class with setup()/teardown() methods and use TEST_FIXTURE.

3. Assertions: Map GTest's ASSERT_* and EXPECT_* macros to their CppTest CHECK equivalents. Here's a basic mapping:

   GTest	CppTest
   ASSERT_EQ	CHECK_EQUAL
   EXPECT_EQ	CHECK_EQUAL (non-fatal variations exist)
   ASSERT_TRUE	CHECK
   EXPECT_TRUE	CHECK (non-fatal variations exist)
   ASSERT_NE	CHECK_NOT_EQUAL
   EXPECT_NE	CHECK_NOT_EQUAL (non-fatal variations exist)
   ASSERT_THROW	CHECK_THROW
   EXPECT_THROW	CHECK_THROW (non-fatal variations exist)

Example Translation (GTest to CppTest):

GTest:

TEST(MySuite, MyTest) {
  int x = 5;
  ASSERT_EQ(x, 5);
  EXPECT_TRUE(x > 0); 
}

CppTest:

TEST_SUITE(MySuite) {
  TEST(MySuite, MyTest) {
    int x = 5;
    CHECK_EQUAL(x, 5);
    CHECK(x > 0);
  }
}

Challenges and Considerations

• Mocking: GTest has Google Mock, while CppTest has its own mocking framework. Translating mocks might require more effort.
• Advanced Features: GTest and CppTest have unique advanced features (e.g., parameterized tests, death tests, etc.) that might not have direct equivalents.
• Test Runner: The test runners for GTest and CppTest are different, so you'll need to adjust your build system and execution commands.