在上面一篇博客中已经介绍了关于gtest的一些基本的用法，gtest的介绍和使用。今天主要是对gtest的熟练掌握做的一个实战练习。
在实战练习之前先来在学习一个gtest的用法–>gtest的参数化。
在设计测试案例的时候，经常需要考虑到多种不同的情况。我们一般的做法就是提前编写一个通用的方法，然后在编写测试用例的时候调用它。但是Google的程序员为了解决代码的复用性，在gtest中同时也提供了一个灵活的参数化的方案。
参数化的使用规则：
1、告诉gtest你要参数化的类型是什仫？
必须添加一个类，继承testing::TestWithParam<T>，其中的T就是你要告诉gtest你要参数化的类型；
2、告诉gtest有了参数之后你要进行什仫样的测试？
在这里就用到了之前提到的TEST_P这个宏了。这个”P”你可以理解为”parameterized” 或者 “pattern”。在TEST_P这个宏里面，使用GetParam()函数可以获取当前参数的具体值；
3、告诉gtest你想要测试的参数具体是什仫？
使用这个INSTANTIATE_TEST_CASE_P宏告诉gtest用户的测试范围。
1>、它的第一个参数是测试案例的前缀，可以任意取名；
2>、第二个参数是测试案例的名称，必须和之前参数化定义的名称相同；
3>、第三个参数可以理解为参数的生成方式，一般提供了下列几种方式：
1>、Range(begin,end,step); //范围在begin~end之间，步长为step，不包括end
2>、Values(v1,v2,...,vN); //v1,v2到vN的值
3>、ValuesIn(container) and ValuesIn(begin, end) //从一个C类型的数组或是STL容器，或是迭代器中取值
4>、Bool() //只能是true、false这两种值
5>、Combine(g1, g2, ..., gN) //将g1,g2,...gN进行排列组合，g1,g2,...gN本身是一个参数生成器，每次分别从g1,g2,..gN中各取出一个值，组合成一个元组(Tuple)作为一个参数。这个功能只在提供了<tr1/tuple>头的系统中有效。gtest会自动去判断是否支持tr/tuple，如果你的系统确实支持，而gtest判断错误的话，你可以重新定义宏GTEST_HAS_TR1_TUPLE=1。还是测试绝对值的那个函数，此时使用参数化进行测试：
在使用参数化的情况下，当运行案例的时候是可以查看每个案例的名称的
好了，穿插了一下gtest的参数化的知识，下面就来模拟实现一个MyVector，并用gtest来测试吧！
MyVector.h
#include<iostream>
using namespace std;
#include<cassert>
#include<gtest/gtest.h>
template<class T>
class MyVector
{
public:
MyVector()
:_pData(NULL)
,_capacity(0)
,_size(0)
{}
MyVector(size_t n,const T& data)
:_pData(new T[n])
,_capacity(n)
,_size(n)
{
for(int i=0;i<_size;i++)
{
_pData[i]=data;
}
}
//MyVector<int> V2(v1);
MyVector(const MyVector<T>& v) //拷贝构造函数
:_pData(new T[v._size])
,_capacity(v._size)
,_size(v._size)
{
for(int i=0;i<v._size;i++)
{
_pData[i]=v._pData[i];
}
//memcpy(_pData,v._pData,sizeof(T)*_size); //memcpy存在问题，当传的模板类型是string的时候就会产生浅拷贝的问题，可以使用类型萃取来解决。
}
MyVector& operator=(const MyVector<T>& v) //赋值运算符的重载
{
if(this != &v)
{
MyVector<T> tmp(v);
Swap(tmp);
}
return *this;
}
~MyVector() //析构函数
{
if(_pData != NULL)
{
delete[]_pData;
_pData=NULL;
}
_capacity=0;
_size=0;
}
public:
void Swap(MyVector<T> v)
{
std::swap(_pData,v._pData);
std::swap(_capacity,v._capacity);
std::swap(_size,v._size);
}
void PushBack(const T&data)
{
_CheckCapacity();
_pData[_size++]=data;
}
void PopBack()
{
assert(_size > 0);
_size--;
}
void Insert(const int& pos,const T& data)
{
assert(pos >=0 && pos < _size); //所给的位置下标是否正确
_CheckCapacity(); //检查容量是否已满
if(_size-1 == pos){ //尾插
PushBack(data);
}
else{ //不是尾插
for(int i=_size-1;i>=pos;i--){
_pData[i+1]=_pData[i];
}
_pData[pos]=data;
_size++;
}
}
void Erase(const int& pos)
{
assert(pos >= 0 && pos < _size);
for(int i=pos+1;i<_size;i++){
_pData[i-1]=_pData[i];
}
_size--;
}
void Clear()
{
_size=0;
}
T& operator[](int index)
{
assert(index >= 0 && index < _size);
return _pData[index];
}
const T& Front()const
{
assert(_size > 0);
return _pData[0];
}
const T& Back()const
{
assert(_size > 0);
return _pData[_size-1];
}
size_t Size()
{
return _size;
}
size_t Capacity()
{
return _capacity;
}
void Resize(size_t nums,T c=T()) //修改Vector的大小
{
if(nums > _size){ //新扩充的元素个数比当前的大
T *pData=new T[nums];
for(int i=0;i<_size;i++){
pData[i]=_pData[i];
}
for(int i=_size;i<nums;i++){
pData[i]=c;
}
delete[]_pData;
_pData=pData;
_size=nums;
}
else{ //新扩充元素的个数比当前的元素个数小
for(int i=nums;i<_size;i++){
_pData[i]=0;
}
_size -= nums;
}
}
void Reverse(size_t nums) //修改容量
{
if(nums > _capacity){
T *pData=new int[nums];
for(int i=0;i<_size;i++){
pData[i]=_pData[i];
}
delete[]_pData;
_pData=pData;
_capacity=nums;
}
}
bool Empty()
{
return _size == 0;
}
private:
void _CheckCapacity()
{
if(_size == _capacity)
{
int newCapacity=2*_capacity+3;
T *pData=new T[newCapacity];
memcpy(pData,_pData,sizeof(T)*_size); //如果T是string的话容易出问题
delete[]_pData;
_pData=pData;
_capacity=newCapacity;
_size=_size;
}
}
protected:
T *_pData;
size_t _capacity;//容量
size_t _size; //实际存储的数据个数
};
TestVector.cc
#include"MyVector.h"
class TestVector:public testing::Test
{
public:
virtual void SetUp()
{
cout<<"SetUp"<<endl;
v.PushBack(2);
v.PushBack(4);
v.PushBack(6);
v.PushBack(8);
v.PushBack(0);
v.PushBack(3);
}
virtual void TearDown()
{
cout<<"TearDown"<<endl;
v.Clear();
}
MyVector<int> v;
};
TEST_F(TestVector,Copy)
{
MyVector<int> v1(5,10);
for(int i=0;i<5;i++){
ASSERT_EQ(v1[i],10);
}
MyVector<int> v2(v);
ASSERT_FALSE(v2.Size() != v.Size()) << "v.Size() != v2.Size()";
v1=v2;
ASSERT_FALSE(v2.Size() != v1.Size()) << "v.Size() != v2.Size()";
}
class TestPushBack:public testing::TestWithParam<int>
{};
TEST_P(TestPushBack,PushBack)
{
MyVector<int> v1;
int n=GetParam();
v1.PushBack(n);
EXPECT_EQ(v1.Back(),n);
}
INSTANTIATE_TEST_CASE_P(TrueReturn,TestPushBack,testing::Values(10,12,14,16));
TEST_F(TestVector,PopBack)
{
for(int i=v.Size()-1;i>=0;--i){
v.PopBack();
ASSERT_EQ(v.Size(),i);
}
ASSERT_TRUE(v.Empty()) << "v is empty";
}
TEST_F(TestVector,Insert)
{
v.Insert(2,10);
ASSERT_NE(v[2],6) << "v[2] != 6";
ASSERT_EQ(v[2],10) << "v[2] = 10";
v.Insert(v.Size()-1,20);
ASSERT_EQ(v[v.Size()-1],20) << "v[last]=20";
}
TEST_F(TestVector,Erase)
{
int data=v[0];
v.Erase(0);
ASSERT_NE(v[0],data);
ASSERT_EQ(v.Size(),5);
data=v[v.Size()-1];
v.Erase(v.Size()-1);
ASSERT_NE(v[v.Size()-1],data);
ASSERT_EQ(v.Size(),4);
data=v[2];
v.Erase(2);
ASSERT_NE(v[2],data);
ASSERT_EQ(v.Size(),3);
}
TEST_F(TestVector,Resize)
{
v.Resize(3);
for(int i=0;i<3;i++){
ASSERT_TRUE(v[i] != 0);
}
v.Resize(6,100);
for(int i=3;i<6;i++){
ASSERT_EQ(v[i],100);
}
v.Resize(12);
for(int i=6;i<12;i++){
ASSERT_TRUE(v[i] == 0);
}
}
TEST_F(TestVector,Reverse)
{
v.Reverse(10);
ASSERT_EQ(v.Capacity(),10);
}
int main(int argc,char *argv[])
{
testing::InitGoogleTest(&argc,argv);
return RUN_ALL_TESTS();
}在这里就分享结束了~~~
作者：ONEDAY_789 发表于2017/8/6 17:55:59 原文链接
阅读：307 评论：0 查看评论