Google Test(GTest)使用方法和源码解析——自定义输出技术的分析和应用

在介绍自定义输出机制之前，我们先了解下AssertResult类型函数。（转载请指明出于breaksoftware的csdn博客）

在函数中使用AssertionResult

AssertionResult只有两种类型：

1. AssertionSuccess()
2. AssertionFailure()

要么成功，要么失败，我们就可以使用基础断言来判断

::testing::AssertionResult IsEven(int n) {if ((n % 2) == 0)return ::testing::AssertionSuccess() << n << " is even";elsereturn ::testing::AssertionFailure() << n << " is odd";
}TEST(TestAssertResult, Check) {EXPECT_FALSE(IsEven(0));EXPECT_TRUE(IsEven(1));
}

我们在IsEven函数中输出了额外的内容（Actual中），便于我们之后查看结果

Value of: IsEven(0)Actual: true (0 is even)
Expected: false
error: Value of: IsEven(1)Actual: false (1 is odd)
Expected: true

自定义输出断言

如果默认的输出结果不能满足我们的需要，或者我们的类型不支持字符流输出，我们就需要自定义输出。我们可以使用

这一系列GTest也是有5对函数，最高是ASSERT/EXPECT_PRED_FORMAT5。我们看下使用的例子

::testing::AssertionResult IsEven2(const char* expr, int n) {if ((n % 2) == 0)return ::testing::AssertionSuccess() << expr << " = " << n << " is even";elsereturn ::testing::AssertionFailure() << expr << " = " << n << " is odd";
}TEST(TestAssertResult, Check2) {int a = 0;int b = 1;EXPECT_PRED_FORMAT1(IsEven2, a);EXPECT_PRED_FORMAT1(IsEven2, b);
}

我们发现，用于判断的表达式要求返回类型是AssertionResult。因为源码底层是

#define GTEST_ASSERT_(expression, on_failure) \GTEST_AMBIGUOUS_ELSE_BLOCKER_ \if (const ::testing::AssertionResult gtest_ar = (expression)) \; \else \on_failure(gtest_ar.failure_message())

其次要求用于判断的表达式第一个参数要是一个const char*类型数据，它用于传递参数的名字。于是上面的测试输出是

error: b = 1 is odd

自定义类型输出

一些情况下，我们自定义类型可能是个复杂的符合结构。C++编译器并不知道怎么输出它，这个时候我们就需要告诉GTest如何去输出了。目前有两种方式

定义输出运算符函数

比如待测类是class Bar。我们只要定义一个方法

::std::ostream& operator<<(::std::ostream& os, const Bar& bar) {return os << bar.DebugString();  // whatever needed to print bar to os
}

通过Bar暴露出来的方法将该对象输出。我们看一个例子

#include <vector>
#include <string>
using namespace std;
class Bar {class Data {public:Data() {strData = "17";intData = 11;}public:std::string strData;int intData;};
public :std::string DebugString() const {std::string output = "Bar.Data.strData = ";output += data.strData;output += "\t";output += "Bar.Data.intData = ";char intBuffer[16] = {0};itoa(data.intData, intBuffer, 10);output += string(intBuffer);return output;}Data data;
};::std::ostream& operator<<(::std::ostream& os, const Bar& bar) {return os << bar.DebugString();  // whatever needed to print bar to os
}bool IsCorrectBarIntVector(vector<pair<Bar, int> > bar_ints) {return false;
}TEST(TestSelfDefineOutput, Test1) {vector<pair<Bar, int> > bar_ints;Bar bar;bar_ints.push_back(pair<Bar, int>(bar, 1));EXPECT_TRUE(IsCorrectBarIntVector(bar_ints))<< "bar_ints = " << ::testing::PrintToString(bar_ints);
}

我们将Bar设计为一个较为复杂的结构，然后定义了一个函数DebugString用于输出其包含的变量。我们让断言进入出错状态，查看其输出

  Actual: false
Expected: true
bar_ints = { (Bar.Data.strData = 17     Bar.Data.intData = 11, 1) }

可以看出来，GTest将Vector类型的数据格式化输出（使用了PrintToString方法），并使用我们自定义DebugString输出了自定义结构。

这儿有个有趣的地方，PrintToString的实现，比如它是如何判断它是个容器的

template <typename T>
void PrintTo(const T& value, ::std::ostream* os) {DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
}

typedef int IsContainer;
template <class C>
IsContainer IsContainerTest(int /* dummy */,typename C::iterator* /* it */ = NULL,typename C::const_iterator* /* const_it */ = NULL) {return 0;
}typedef char IsNotContainer;
template <class C>
IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; }

编译器遇到这种情况时，会试着用返回IsContainer的方法去匹配方法，但是如何发现class C没有迭代器，则用返回IsNotContaner的函数取匹配。这样就可以区分模板类是否是容器了。
        还有个一is_pointer模板方法，用于判断是否是指针。

template <typename T>
struct is_pointer : public false_type {};template <typename T>
struct is_pointer<T*> : public true_type {};

在我们的测试例子中，由于数据是个容器，且不是指针。那么将会匹配到

template <typename C>
void DefaultPrintTo(IsContainer /* dummy */,false_type /* is not a pointer */,const C& container, ::std::ostream* os) {

其实DefaultPrintTo方法还有其他两个，只是本次没有匹配到

template <typename T>
void DefaultPrintTo(IsNotContainer /* dummy */,true_type /* is a pointer */,T* p, ::std::ostream* os) {

template <typename T>
void DefaultPrintTo(IsNotContainer /* dummy */,false_type /* is not a pointer */,const T& value, ::std::ostream* os) {

定义PrintTo方法

有些时候，输出运算符可能被其他业务逻辑占用了。GTest就提供了一个针对性的方法，定义PrintTo方法，我们可以这么去做

void PrintTo(const Bar& bar, ::std::ostream* os) {*os << bar.DebugString();  // whatever needed to print bar to os
}

那么它在什么时候被调用的呢？PrintToString最终会调到如下的函数中，

template <typename C>
void DefaultPrintTo(IsContainer /* dummy */,false_type /* is not a pointer */,const C& container, ::std::ostream* os) {
......for (typename C::const_iterator it = container.begin();it != container.end(); ++it, ++count) {
......internal::UniversalPrint(*it, os);}
......
}

template <typename T1, typename T2>
void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {*os << '(';// We cannot use UniversalPrint(value.first, os) here, as T1 may be// a reference type.  The same for printing value.second.UniversalPrinter<T1>::Print(value.first, os);*os << ", ";UniversalPrinter<T2>::Print(value.second, os);*os << ')';
}

template <typename T>
class UniversalPrinter {public:GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)static void Print(const T& value, ::std::ostream* os) {PrintTo(value, os);}GTEST_DISABLE_MSC_WARNINGS_POP_()
};

其中UniversalPrinter<T1>::Print(value.first, os)会被我们定义的PrintTo匹配到，从而被调用。