Google Test测试框架自带Sample案例注释翻译

      有一段时间没写博客了，前些时间闲下来看了下google test（gtest）测试框架自带的sample测试样例，感觉还不错，就对里面的注释进行了相关翻译，在此做个标录，对测试流程、方法和设计的理解会有些帮助，方便日后重新查阅，有兴趣的同志不妨看一下

相关说明：

     1、项目工程可到附件中下载

     2、项目工程在visual studio2005环境下编译运行的

     3、对于想对gtest有进一步了解的通知，可参考金山公司一个前辈的gtest技术博客http://www.cnblogs.com/coderzh/archive/2009/03/31/1426758.html（玩转Google开源C++单元测试框架Google Test系列(gtest)）

     4、转载请保留该博客地址：http://mzhx-com.iteye.com/

正所谓，外行看热闹，内行看门道，在此就不多做解释了，注释和源码相信应该是最好的老师吧

工程结构图表：

sample1.h

//一个用来展示如何应用Google C++测试框架的简单程序示例


 


#ifndef GTEST_SAMPLES_SAMPLE1_H_


#define GTEST_SAMPLES_SAMPLE1_H_


 


// Returns n! (the factorial of n).  For negative n, n! is defined to be 1.


//返回n！(n的阶乘)，对于负数n，n！约定等于1


int Factorial(int n);


 


// Returns true iff n is a prime number.


//如果n是素数返回true


bool IsPrime(int n);


 


#endif  // GTEST_SAMPLES_SAMPLE1_H_

sample1.cc

//一个用来展示如何应用Google C++测试框架的简单程序示例


#include "stdafx.h"


#include "sample1.h"


// Returns n! (the factorial of n).  For negative n, n! is defined to be 1.


//返回n！(n的阶乘)，对于负数n，n！约定等于1


int Factorial(int n) {


	int result = 1;


	for (int i = 1; i <= n; i++) {


		result *= i;


	}


	return result;


}


// Returns true iff n is a prime number.


//如果n是素数返回true


bool IsPrime(int n) {


	// Trivial case 1: small numbers


	//情况1:小于等于1的数字


	if (n <= 1) return false;


	// Trivial case 2: even numbers


	//情况2：整数


	if (n % 2 == 0) return n == 2;


	// Now, we have that n is odd and n >= 3.


	//现在，对于那些大于3的奇数


	// Try to divide n by every odd number i, starting from 3


	//从3开始，用每个奇数i去除n


	for (int i = 3; ; i += 2) {


		// We only have to try i up to the squre root of n


		if (i > n/i) break;


		// Now, we have i <= n/i < n.


		// If n is divisible by i, n is not prime.


		if (n % i == 0) return false;


	}


	// n has no integer factor in the range (1, n), and thus is prime.


	return true;


}

sample1_unittest.cc

// This sample shows how to write a simple unit test for a function,


// using Google C++ testing framework.


//这个示例用来展示如何应用Google C++测试框架来写一个简单的函数测试单元


// Writing a unit test using Google C++ testing framework is easy as 1-2-3:


//应用Google C++写一个单元测试很简单，只需要1-2-3共三个步骤


 


 


// Step 1. Include necessary header files such that the stuff your


// test logic needs is declared.


//第一步:引入一些必须的头文件


// Don't forget gtest.h, which declares the testing framework.


//不要忘了引入声明测试框架的gtest.h头文件


#include "stdafx.h"


#include <limits.h>


#include "sample1.h"


#include <gtest/gtest.h>


 


 


// Step 2. Use the TEST macro to define your tests.


//第二步：应用TEST宏来定义你的测试


 


//TEST has two parameters: the test case name and the test name.


//TEST宏包含两个参数：一个案例【TestCaseName】名，一个测试【TestName】名


 


// After using the macro, you should define your test logic between a  pair of braces.  


//在应用了宏之后，你应该定义这两者之间的测试逻辑


 


//You can use a bunch of macros to indicate the success or failure of a test.


//你应该使用一些宏命令去指出测试是否成功


 


//EXPECT_TRUE and EXPECT_EQ are  examples of such macros. 


//其中EXPECT_TRUE和EXPECT_EQ就是这样的宏的例子


 


// For a complete list, see gtest.h.


//要查看完整的列表，可以去看看gtest.h头文件


 


// <TechnicalDetails>


//


// In Google Test, tests are grouped into test cases.  


//在gtest中，测试都被分组到测试案例中


 


// This is how we keep test code organized. 


//这就是我们有效组织测试代码的方式


 


//  You should put logically related tests into the same test case.


//你应该将这些逻辑上相关的测试应用到相似的测试案例中去


 


// The test case name and the test name should both be valid C++ identifiers.  


//测试案例名和测试名应该都是有效的C++标识符


 


// And you should not use underscore (_) in the names.


//并且你不应该应用强调符号(_)到命名中


 


// Google Test guarantees that each test you define is run exactly


// once, but it makes no guarantee on the order the tests are


// executed.  


//gtest能够保证你定义的每个测试都能准确的运行一次，但是它并不能保证这些测试执行的顺序


 


//Therefore, you should write your tests in such a way


// that their results don't depend on their order.


//所以你应该依输出结果不依赖自身顺序的方式来写这些测试案例


 


// </TechnicalDetails>


 


 


// Tests Factorial().


//测试阶乘函数Factorial().


 


// Tests factorial of negative numbers.


//测试传入负数的情况下函数的运行情况


 


TEST(FactorialTest, Negative) {


  // This test is named "Negative", and belongs to the "FactorialTest"


  // test case.


  //这个测试本身被命名为“Negative”且从属于"FactorialTest"测试案例


 


  EXPECT_EQ(1, Factorial(-5));


  EXPECT_EQ(1, Factorial(-1));


  EXPECT_TRUE(Factorial(-10) > 0);


 


  // <TechnicalDetails>


  //<技术细节>


 


  // EXPECT_EQ(expected, actual) is the same as


  //


  //   EXPECT_TRUE((expected) == (actual))


  //


  // except that it will print both the expected value and the actual


  // value when the assertion fails.  


  //EXPECT_EQ(expected, actual)除了在断言失败时会打印出期望值和相应的真实值外，其他的情况都和EXPECT_TRUE((expected) == (actual))相同


 


  //This is very helpful for debugging.


  //这对调试来说很有帮助


 


  //   Therefore in this case EXPECT_EQ is preferred.


  //因此这样说来EXPECT_EQ是很有用的


 


  // On the other hand, EXPECT_TRUE accepts any Boolean expression,and is thus more general.


  // 在另一方面，EXPECT_TRUE会接受任何的Boolean表达式，所以他的用法更普通一些


 


  //


  // </TechnicalDetails>


}


 


// Tests factorial of 0.


//使用数字0测试阶乘


 


TEST(FactorialTest, Zero) {


  EXPECT_EQ(1, Factorial(0));


}


 


// Tests factorial of positive numbers.


//使用正数测试阶乘


 


TEST(FactorialTest, Positive) {


  EXPECT_EQ(1, Factorial(1));


  EXPECT_EQ(2, Factorial(2));


  EXPECT_EQ(6, Factorial(3));


  EXPECT_EQ(40320, Factorial(8));


}


 


 


// Tests IsPrime()


//测试素数检测函数


 


// Tests negative input.


//测试负数输入


 


TEST(IsPrimeTest, Negative) {


  // This test belongs to the IsPrimeTest test case.


  //这个测试依赖于IsPrimeTest测试案例


 


  EXPECT_FALSE(IsPrime(-1));


  EXPECT_FALSE(IsPrime(-2));


  EXPECT_FALSE(IsPrime(INT_MIN));


}


 


// Tests some trivial cases.


//测试一些平常的案例


 


TEST(IsPrimeTest, Trivial) {


  EXPECT_FALSE(IsPrime(0));


  EXPECT_FALSE(IsPrime(1));


  EXPECT_TRUE(IsPrime(2));


  EXPECT_TRUE(IsPrime(3));


}


 


// Tests positive input.


//测试正数输入


 


TEST(IsPrimeTest, Positive) {


  EXPECT_FALSE(IsPrime(4));


  EXPECT_TRUE(IsPrime(5));


  EXPECT_FALSE(IsPrime(6));


  EXPECT_TRUE(IsPrime(23));


}


 


// Step 3. Call RUN_ALL_TESTS() in main().


//第三步：在main()函数中调用 RUN_ALL_TESTS()函数


 


// We do this by linking in src/gtest_main.cc file, which consists of


// a main() function which calls RUN_ALL_TESTS() for us.


//在src/gtest_main.cc文件中有一个调用RUN_ALL_TESTS()函数的main()函数，我们可以引入该文件来实现第三步的要求


 


// This runs all the tests you've defined, prints the result, 


//在这里可以运行所有你定义的测试，打印输出结果


 


//and returns 0 if successful, or 1 otherwise.


//并且如果成功返回0，其他情况返回1


 


// Did you notice that we didn't register the tests?  


//你有没有发现我们并没有注册这些测试


 


//The RUN_ALL_TESTS() macro magically knows about all the tests we defined.


//这个RUN_ALL_TESTS()宏函数能神奇的知道我们定义的所有测试


 


//Isn't this convenient?


//这样是不是很方便呢，嘿嘿

sample2.h

//一个用来展示如何应用Google C++测试框架的简单程序示例


 


#ifndef GTEST_SAMPLES_SAMPLE2_H_


#define GTEST_SAMPLES_SAMPLE2_H_


 


#include <string.h>


 


 


// A simple string class.


//一个简单的string字符串相关类


class MyString {


private:


	const char * c_string_;


	const MyString& operator=(const MyString& rhs);


 


public:


 


	// Clones a 0-terminated C string, allocating memory using new.


	//克隆一个0结尾的C string字符串，用new关键字分配空间


	static const char * CloneCString(const char * c_string);


 


	


	//


	// C'tors


 


	// The default c'tor constructs a NULL string.


	//为c_string_默认赋NULL值的构造函数


 


	MyString() : c_string_(NULL) {}


 


	// Constructs a MyString by cloning a 0-terminated C string.


	explicit MyString(const char * c_string) : c_string_(NULL) {


		Set(c_string);


	}


 


	// Copy c'tor


	MyString(const MyString& string) : c_string_(NULL) {


		Set(string.c_string_);


	}


 


	


	//


	// D'tor.  MyString is intended to be a final class, so the d'tor


	// doesn't need to be virtual.


	//析构函数：MyString类想定义为final类，所以析构函数没必要定义为virtual


 


	~MyString() { delete[] c_string_; }


 


	// Gets the 0-terminated C string this MyString object represents.


	//返回MyString对象的c_string_


	const char * c_string() const { return c_string_; }


 


	size_t Length() const {


		return c_string_ == NULL ? 0 : strlen(c_string_);


	}


 


	// Sets the 0-terminated C string this MyString object represents.


	//为MyString对象的c_string赋值


	void Set(const char * c_string);


};


 


 


#endif  // GTEST_SAMPLES_SAMPLE2_H_

sample2.cc

#include "stdafx.h"


#include "sample2.h"


 


#include <string.h>


 


// Clones a 0-terminated C string, allocating memory using new.


//克隆复制一个以0结尾的C字符串，用new关键字申请空间


const char * MyString::CloneCString(const char * c_string) {


	if (c_string == NULL) return NULL;


 


	const size_t len = strlen(c_string);


	char * const clone = new char[ len + 1 ];


	memcpy(clone, c_string, len + 1);


 


	return clone;


}


 


// Sets the 0-terminated C string this MyString object


// represents.


//设置以0结尾的字符串用MyString实体表示


void MyString::Set(const cha