gtest和gmock的关系_gtest教程

Google C++ Testing Framework（简称gtest，http://code.google.com/p/googletest/）是Google公司发布的一个开源C/C++单元测试框架，已被应用于多个开源项目及Google内部项目中，知名的例子包括Chrome Web浏览器、LLVM编译器架构、Protocol Buffers数据交换格式及工具等。

优秀的C/C++单元测试框架并不算少，相比之下gtest仍具有明显优势。与CppUnit比，gtest需要使用的头文件和函数宏更集中，并支持测试用例的自动注册。与CxxUnit比，gtest不要求Python等外部工具的存在。与Boost.Test比，gtest更简洁容易上手，实用性也并不逊色。Wikipedia给出了各种编程语言的单元测试框架列表（http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks）。

一、基本用法

gtest当前的版本是1.5.0，如果使用Visual C++编译，要求编译器版本不低于7.1（Visual C++ 2003）。如下图所示，它的msvc文件夹包含Visual C++工程和项目文件，samples文件夹包含10个使用范例。

一般情况下，我们的单元测试代码只需要包含头文件gtest.h。gtest中常用的所有结构体、类、函数、常量等，都通过命名空间testing访问，不过gtest已经把最简单常用的单元测试功能包装成了一些带参数宏，因此在简单的测试中常常可以忽略命名空间的存在。

      
      
      

       
       
// add.h  
       
       
#pragma once  
       
       
inline int Add(int i, int j) { return i+j; } 
      
      

      
      
      

       
       
// add_unittest.cpp  
       
       
#include "add.h"  
       
       
#include <gtest/gtest.h>  
       
       
   
       
       
TEST(Add, 负数) {  
       
       
 EXPECT_EQ(Add(-1,-2), -3);  
       
       
 EXPECT_GT(Add(-4,-5), -6); // 故意的  
       
       
}  
       
       
   
       
       
TEST(Add, 正数) {  
       
       
 EXPECT_EQ(Add(1,2), 3);  
       
       
 EXPECT_GT(Add(4,5), 6);  
       
       
} 
      
      

      
      
      

       
       
ASSERT_EQ(M[i], N[j]) << "i = " << i << ", j = " << j; 
      
      

      
      
      

       
       
// gtest-main.cc  
       
       
int main(int argc, char **argv) {  
       
       
 std::cout << "Running main() from gtest_main.cc\n";  
       
       
 testing::InitGoogleTest(&argc, argv);  
       
       
 return RUN_ALL_TESTS();  
       
       
} 
      
      

      
      
      

       
       
// add_unittest2.cpp  
       
       
#include "add.h"  
       
       
#include <stdio.h>  
       
       
#include <gtest/gtest.h>  
       
       
   
       
       
class AddTest: public testing::Test  
       
       
{  
       
       
public:  
       
       
 virtual void SetUp()    { puts("SetUp()"); }  
       
       
 virtual void TearDown() { puts("TearDown()"); }  
       
       
};  
       
       
   
       
       
TEST_F(AddTest, 正数) {  
       
       
 ASSERT_GT(Add(1,2), 3); // 故意的  
       
       
 ASSERT_EQ(Add(4,5), 6); // 也是故意的  
       
       
} 
      
      

      
      
      

       
       
class Environment {  
       
       
 public:  
       
       
 virtual ~Environment() {}  
       
       
 virtual void SetUp() {}  
       
       
 virtual void TearDown() {}  
       
       
}; 
      
      

      
      
      

       
       
Environment* AddGlobalTestEnvironment(Environment* env); 
      
      

      
      
      

       
       
// divide.h  
       
       
#pragma once  
       
       
#include <stdexcept>  
       
       
   
       
       
int divide(int dividend, int divisor) {  
       
       
 if(!divisor) {  
       
       
    throw std::length_error("can't be divided by 0"); // 故意的  
       
       
 }  
       
       
 return dividend / divisor;  
       
       
} 
      
      

      
      
      

       
       
// divide-unittest.cpp  
       
       
#include <gtest/gtest.h>  
       
       
#include "./divide.h"  
       
       
   
       
       
TEST(Divide, ByZero) {  
       
       
 EXPECT_NO_THROW(divide(-1, 2));  
       
       
   
       
       
 EXPECT_ANY_THROW({  
       
       
    int k = 0;  
       
       
    divide(k, k);  
       
       
 });  
       
       
   
       
       
 EXPECT_THROW(divide(100000, 0), std::invalid_argument);  
       
       
} 
      
      

      
      
      

       
       
try {  
       
       
 statement;  
       
       
}  
       
       
catch(type const&) {  
       
       
 // throw  
       
       
}  
       
       
catch(...) {  
       
       
 // any throw  
       
       
}  
       
       
// no throw 
      
      

      
      
      

       
       
// addupto.h  
       
       
   
       
       
#pragma once  
       
       
   
       
       
inline unsigned NaiveAddUpTo(unsigned n) {  
       
       
    unsigned sum = 0;  
       
       
    for(unsigned i = 1; i <= n; ++i) sum += i;  
       
       
    return sum;  
       
       
}  
       
       
   
       
       
inline unsigned FastAddUpTo(unsigned n) {  
       
       
    return n*(n+1)/2;  
       
       
} 
      
      

      
      
      

       
       
// addupto_test.cpp  
       
       
   
       
       
#include <gtest/gtest.h>  
       
       
#include "addupto.h"  
       
       
   
       
       
class AddUpToTest : public testing::TestWithParam<unsigned>  
       
       
{  
       
       
public:  
       
       
    AddUpToTest() { n_ = GetParam(); }  
       
       
protected:  
       
       
    unsigned n_;  
       
       
};  
       
       
   
       
       
TEST_P(AddUpToTest, Calibration) {  
       
       
    EXPECT_EQ(NaiveAddUpTo(n_), FastAddUpTo(n_));  
       
       
}  
       
       
   
       
       
INSTANTIATE_TEST_CASE_P(  
       
       
    NaiveAndFast, // prefix  
       
       
    AddUpToTest,   // test case name  
       
       
    testing::Range(1u, 1000u) // parameters  
       
       
);