cpp-testing / GUnit

               Google.Test                        |                     GUnit.GTest
--------------------------------------------------+------------------------------------------------------
#include <gtest/gtest.h>                          | #include <GUnit.h>
                                                  |
struct CalcTest : testing::Test {                 | GTEST("Calc Test") {
 void SetUp() override {                          |   Calc calc{};
   calc = std::make_unique<Calc>();               |
 }                                                |   // SetUp
                                                  |
 void TearDown() override { }                     |   SHOULD("return sum of 2 numbers") {
                                                  |     EXPECT_EQ(5, calc->add(4, 1));
 std::unique_ptr<Calc> calc;                      |   }
};                                                |
                                                  |   SHOULD("throw if division by 0") {
TEST_F(CalcTest, ShouldReturnSumOf2Numbers) {  |     EXPECT_ANY_THROW(calc->div(42, 0));
  EXPECT_EQ(5, calc->add(4, 1));                  |   }
}                                                 |
                                                  |   // TearDown
TEST_F(CalcTest, ShouldThrowIfDivisionBy0) {   | }
  EXPECT_ANY_THROW(calc->div(42, 0));             |
}                                                 |

struct interface {
  virtual ~interface() = default;
  virtual int get() const = 0;
  virtual void foo(int) = 0;
  virtual void bar(int, const std::string&) = 0;
};

               Google.Test                        |                     GUnit.GMock
--------------------------------------------------+------------------------------------------------------
#include <gmock/gmock.h>                          | #include <GUnit.h>
                                                  |
struct mock_interface : interface {               |
  MOCK_CONST_METHOD0(get, int(int));              |
  MOCK_METHOD1(foo, void(int));                   |
  MOCK_METHOD2(bar, void(int, const string&));    |
};                                                |
                                                  |
int main() {                                      | int main() {
  StrictMock<mock_interface> mock{};              |   StrictGMock<interface> mock{};
  EXPECT_CALL(mock, foo(42));                     |   EXPECT_CALL(mock, (foo)(42));
                                                  |
  interface& i = mock;                            |   interface& i = mock.object();
  i.foo(42);                                      |   i.foo(42);
}                                                 | }

class coffee_maker {
 public:
   coffee_maker(iheater&, ipump&, igrinder&);
   ...
};

               Google.Test                        |                     GUnit.GMake
--------------------------------------------------+------------------------------------------------------
 #include <gtest/gtest.h>                         | #include <GUnit.h>
 #include <gmock/gmock.h>                         |
                                                  |
 TEST(CalcTest, ShouldMakeCoffee) {               | GTEST("Calc Test") {
   StrictMock<mock_heater> heater{};              |   std::tie(sut, mocks) = // auto [sut, mocks] in C++17
   StrictMock<mock_pump> pump{};                  |     make<coffee_maker, StrictGMock>();
   StrictMock<mock_grinder> grinder{};            |
   coffee_maker sut{heater, pump, grinder};       |   EXPECT_CALL(mocks.mock<iheater>(), (on)());
                                                  |   EXPECT_CALL(mocks.mock<ipump>(), (pump)());
   EXPECT_CALL(heater, on());                     |   EXPECT_CALL(mocks.mock<igrinder>(), (grind)());
   EXPECT_CALL(pump, pump());                     |   EXPECT_CALL(mocks.mock<iheater>(), (off)());
   EXPECT_CALL(grinder, grind());                 |
   EXPECT_CALL(heater, off());                    |   sut->brew();
                                                  | }
   sut->brew();                                   |
 }

#include <GUnit.h>

GSTEPS("Calc*") { // "Calc Addition.Add two numbers"
  auto result = 0;

  Given("I created a calculator with value {n}") = [&](int n) {
    Calculator calc{n};

    Given("I have entered {n} into the calculator") = [&](int n) {
      calc.push(n);
    };

    When("I press add") = [&] {
      result = calc.add();
    };

    Then("The result should be {expected}") = [&](int expected) {
       EXPECT_EQ(expected, result);
    };
  };
}