cocos2d-xプロジェクトにGoogleTestを導入してみた

cocos new gtest-sample -l cpp

#import <XCTest/XCTest.h>

@interface Tests : XCTestCase

@end

@implementation Tests

- (void)setUp {
    // Put setup code here. This method is called before the invocation of each test method in the class.
}

- (void)tearDown {
    // Put teardown code here. This method is called after the invocation of each test method in the class.
}

- (void)testExample {
    // This is an example of a functional test case.
    // Use XCTAssert and related functions to verify your tests produce the correct results.
}

- (void)testPerformanceExample {
    // This is an example of a performance test case.
    [self measureBlock:^{
        // Put the code you want to measure the time of here.
    }];
}

@end

#import <gtest/gtest.h>

TEST(SampleTest, sample) {
    EXPECT_EQ(123, 123);
}

template <typename T>
class TestWithParam : public Test, public WithParamInterface<T> {
};

#import <gtest/gtest.h>
#include "TestValue.h"

class ParamTest : public testing::TestWithParam<TestValue> {
protected:
    TestValue testData;

    TestValue params;
    TestValue expected;
    std::string message;

    virtual void SetUp();
    virtual void TearDown();
};

void ParamTest::SetUp() {
    testData = GetParam();

    params = testData["params"];
    expected = testData["expected"];
    message = testData["message"].asString();
}

void ParamTest::TearDown() {
}

/** Destructor. */
virtual ~Value();

class TestValue : public cocos2d::Value {
public:
    static const TestValue Null;

    TestValue();

    TestValue(unsigned char v);
    TestValue(int v);
    TestValue(float v);
    TestValue(double v);
    TestValue(long v);
    TestValue(int64_t v);
    TestValue(bool v);
    TestValue(const char* v);
    TestValue(const std::string& v);

    TestValue(const TestValueVector& v);
    TestValue(TestValueVector&& v);
    TestValue(const TestValueMap& v);
    TestValue(TestValueMap&& v);
    TestValue(const TestValueMapIntKey& v);
    TestValue(TestValueMapIntKey&& v);

    TestValue(const cocos2d::Value* other);
    TestValue(const cocos2d::Value& other);
    TestValue(cocos2d::Value&& other);

    TestValue(const TestValue& other);
    TestValue(TestValue&& other);
  
  // 略
  
    template <typename E,
    typename std::enable_if<std::is_enum<E>::value>::type* = nullptr,
    typename std::enable_if<std::is_same<typename std::underlying_type<E>::type, int>::value>::type* = nullptr>
    TestValue(E v) {
        *this = static_cast<int>(v);
    }

    template <typename Container,
    typename std::iterator_traits<typename Container::iterator>::value_type* = nullptr>
    TestValue(Container container) : TestValue(TestValueVector(container.begin(), container.end())) {}

    template <typename T>
    TestValue(std::initializer_list<T> list) : TestValue(TestValueVector(list.begin(), list.end())) {}

    TestValue(std::initializer_list<TestValuePair> list);
    TestValue(std::initializer_list<TestValuePairIntKey> list);

    TestValue(std::initializer_list<std::initializer_list<TestValuePair>> list);
    TestValue(std::initializer_list<std::initializer_list<TestValuePairIntKey>> list);
  
  // 略
  
  	template <typename Container, typename Predicate,
		typename ValueType = typename Container::iterator::value_type,
		typename ArgumentType = typename function_argument<Predicate>::type,
		typename std::enable_if<std::is_convertible<ValueType, ArgumentType>::value>::type* = nullptr>
	static TestValue create(const Container& container, Predicate predicate) {
		TestValueVector vector;
		std::transform(container.begin(), container.end(), std::back_inserter(vector), predicate);
		return TestValue(vector);
	}

	template <typename Container, typename Predicate,
		typename ValueType = typename Container::iterator::value_type,
		typename ArgumentType = typename function_argument<Predicate>::type,
		typename std::enable_if<std::is_convertible<typename ValueType::first_type, std::string>::value>::type* = nullptr,
		typename std::enable_if<std::is_convertible<typename ValueType::second_type, ArgumentType>::value>::type* = nullptr>
	static TestValue create(const Container& container, Predicate predicate) {
		TestValueMap map;
		for (const auto& v : container) {
			map[v.first] = predicate(v.second);
		}
		return TestValue(map);
	}
  
  // 略

class Calculator
{
public:
    Calculator() = default;
    virtual ~Calculator() = default;

    int plus(int a, int b) const { return a + b; }

private:

};

using CalculatorTest = ParamTest;

// テストコード
TEST_P(CalculatorTest, plus) {
    Calculator c;

    TestValue result = {
        {"result", c.plus(params["a"].asInt(), params["b"].asInt())},
    };

    EXPECT_EQ(expected, result) << message;
}

// テストケース
INSTANTIATE_TEST_CASE_P(Test, CalculatorTest, ([] {
    std::vector<TestValue> testDataList = {
        { // ケース1
            {"params", {
                {"a", 1},
                {"b", 2},
            }},
            {"expected", {
                {"result", 3}, // 1 + 2 = 3が期待結果
            }},
            {"message", "正の数 + 正の数"},
        },
        { // ケース2
            {"params", {
                {"a", 0},
                {"b", 6},
            }},
            {"expected", {
                {"result", 6}, // 0 + 6 = 6が期待結果
            }},
            {"message", "0 + 正の数"},
        },
    };
    return testing::ValuesIn(testDataList);
}()));

#include "dtl.hpp" // 変更点

// 中略

AssertionResult EqFailure(const char* lhs_expression,
                          const char* rhs_expression,
                          const std::string& lhs_value,
                          const std::string& rhs_value,
                          bool ignoring_case) {


  // ---- 変更点ここから ----
  msg << "\n";
  msg << "\n";
  msg << "--- Expected\n";
  msg << "+++ Actual\n";
  std::string line;
  std::vector<std::string> expected_line_list;
  std::stringstream expected_value_stream(lhs_value);
  while (std::getline(expected_value_stream, line)) {
    expected_line_list.push_back(line);
  }
  std::vector<std::string> actual_line_list;
  std::stringstream actual_value_stream(rhs_value);
  while (std::getline(actual_value_stream, line)) {
    actual_line_list.push_back(line);
  }
  dtl::Diff<std::string> diff(expected_line_list, actual_line_list);
  diff.compose();
  diff.composeUnifiedHunks();
  diff.printUnifiedFormat(msg);
  // ---- 変更点ここまで ----

  return AssertionFailure() << msg;