Google Test: Assert, Throw and C++

If you're a C++ programmer, you're probably familiar with Google Test. Google Test is a unit testing framework for C++ that helps developers write better tests. It provides a set of macros and functions to help write tests, and it integrates with a variety of build systems and IDEs.

One feature that sets Google Test apart from other unit testing frameworks is its support for assertions and exceptions. In this article, we'll explore how to use Google Test's assert and throw functions in your tests.

Assert

Assertions are statements that check for a specific condition and trigger an error if that condition is false. In Google Test, assertions are implemented using the ASSERT_* macros. There are a variety of assertion macros available, depending on the type of condition you want to check.

Basic Assertions

The basic assertion macros are ASSERT_TRUE, ASSERT_FALSE, ASSERT_EQ, ASSERT_NE, ASSERT_LT, ASSERT_LE, ASSERT_GT, and ASSERT_GE. These macros correspond to the following conditions:

• ASSERT_TRUE: The given expression evaluates to true.
• ASSERT_FALSE: The given expression evaluates to false.
• ASSERT_EQ: The two given values are equal.
• ASSERT_NE: The two given values are not equal.
• ASSERT_LT: The first given value is less than the second.
• ASSERT_LE: The first given value is less than or equal to the second.
• ASSERT_GT: The first given value is greater than the second.
• ASSERT_GE: The first given value is greater than or equal to the second.

Here's an example of using ASSERT_TRUE to check if a value is true:

TEST(MyTestSuite, MyTestCase) {
  bool value = true;
  ASSERT_TRUE(value);
}

If the value variable is false, the test will fail and the error message will indicate that the ASSERT_TRUE statement failed.

Binary Comparison Assertions

In addition to the basic assertions, Google Test also provides binary comparison assertions for comparing two values. These macros are ASSERT_EQ, ASSERT_NE, ASSERT_LT, ASSERT_LE, ASSERT_GT, and ASSERT_GE.

Here's an example of using ASSERT_EQ to check if two values are equal:

TEST(MyTestSuite, MyTestCase) {
  int expected = 42;
  int actual = SomeFunctionThatReturnsAnInteger();
  ASSERT_EQ(expected, actual);
}

If the SomeFunctionThatReturnsAnInteger function returns a value that is not equal to 42, the test will fail and the error message will indicate that the ASSERT_EQ statement failed.

String Comparison Assertions

Google Test provides two macros specifically for comparing strings: ASSERT_STREQ and ASSERT_STRNE. These macros compare two strings for equality or inequality.

Here's an example of using ASSERT_STREQ to check if two strings are equal:

TEST(MyTestSuite, MyTestCase) {
  std::string expected = "Hello, world!";
  std::string actual = SomeFunctionThatReturnsAString();
  ASSERT_STREQ(expected.c_str(), actual.c_str());
}

If the SomeFunctionThatReturnsAString function returns a string that is not equal to "Hello, world!", the test will fail and the error message will indicate that the ASSERT_STREQ statement failed.

Throw

In addition to assertions, Google Test also provides a way to test for exceptions. The ASSERT_THROW macro is used to check if a function throws the specified exception.

Here's an example of using ASSERT_THROW to check if a function throws an exception:

TEST(MyTestSuite, MyTestCase) {
  ASSERT_THROW(SomeFunctionThatThrowsAnException(), std::runtime_error);
}

If the SomeFunctionThatThrowsAnException function does not throw a std::runtime_error, the test will fail and the error message will indicate that the ASSERT_THROW statement failed.

Conclusion

Google Test provides a powerful set of macros and functions for testing your C++ code. The assertion macros can be used to check for specific conditions, and the ASSERT_THROW macro can be used to test for exceptions. By using Google Test in your projects, you can ensure that your code is well-tested and robust.