轻松编写c++单元测试

TEST(GlobalConfigurationTest,configurationDataTest)
TEST(GlobalConfigurationTest,noConfigureFileTest)

//Configure.h
#pragmaonce

#include<string>
#include<vector>

classConfigure
{
private:
std::vector<std::string>vItems;

public:
intaddItem(std::stringstr);

std::stringgetItem(intindex);

intgetSize();
};

//Configure.cpp
#include"Configure.h"

#include<algorithm>

/**
*@briefAddanitemtoconfigurationstore.Duplicateitemwillbeignored
*@paramstritemtobestored
*@returntheindexofaddedconfigurationitem
*/
intConfigure::addItem(std::stringstr)
{
std::vector<std::string>::const_iteratorvi=std::find(vItems.begin(),vItems.end(),str);
if(vi!=vItems.end())
returnvi-vItems.begin();

vItems.push_back(str);
returnvItems.size()-1;
}

/**
*@briefReturntheconfigureitematspecifiedindex.
*Iftheindexisoutofrange,""willbereturned
*@paramindextheindexofitem
*@returntheitematspecifiedindex
*/
std::stringConfigure::getItem(intindex)
{
if(index>=vItems.size())
return"";
else
returnvItems.at(index);
}

///Retrievetheinformationabouthowmanyconfigurationitemswehavehad
intConfigure::getSize()
{
returnvItems.size();
}

//ConfigureTest.cpp
#include<gtest/gtest.h>

#include"Configure.h"

TEST(ConfigureTest,addItem)
{
//dosomeinitialization
Configure*pc=newConfigure();

//validatethepointerisnotnull
ASSERT_TRUE(pc!=NULL);

//callthemethodwewanttotest
pc->addItem("A");
pc->addItem("B");
pc->addItem("A");

//validatetheresultafteroperation
EXPECT_EQ(pc->getSize(),2);
EXPECT_STREQ(pc->getItem(0).c_str(),"A");
EXPECT_STREQ(pc->getItem(1).c_str(),"B");
EXPECT_STREQ(pc->getItem(10).c_str(),"");

deletepc;
}

#include<gtest/gtest.h>

intmain(intargc,char**argv){
testing::InitGoogleTest(&argc,argv);

//RunsalltestsusingGoogleTest.
returnRUN_ALL_TESTS();
}

<UserMacro
Name="BoostDir"
Value="$(BOOST_DIR)"
/>

#include<gmock/gmock.h>//BringsinGoogleMock.

classMockTurtle:publicTurtle{
MOCK_METHOD0(PenUp,void());
MOCK_METHOD0(PenDown,void());
MOCK_METHOD1(Forward,void(intdistance));
MOCK_METHOD1(Turn,void(intdegrees));
MOCK_METHOD2(GoTo,void(intx,inty));
MOCK_CONST_METHOD0(GetX,int());
MOCK_CONST_METHOD0(GetY,int());
};

usingtesting::Return;//#1，必要的声明

TEST(BarTest,DoesThis){
MockFoofoo;//#2，创建Mock对象

ON_CALL(foo,GetSize())//#3，设定Mock对象默认的行为（可选）
.WillByDefault(Return(1));
//...otherdefaultactions...

EXPECT_CALL(foo,Describe(5))//#4，设定期望对象被访问的方式及其响应
.Times(3)
.WillRepeatedly(Return("Category5"));
//...otherexpectations...

EXPECT_EQ("good",MyProductionFunction(&foo));
//#5，操作Mock对象并使用googletest提供的断言验证处理结果
}
//#6，当Mock对象被析构时，googlemock会对结果进行验证以判断其行为是否与所有设定的预期一致

testing::NiceMock<MockFoo>nice_foo;

#include<gtest/gtest.h>
#include<gmock/gmock.h>

intmain(intargc,char**argv){
testing::InitGoogleMock(&argc,argv);

//RunsalltestsusingGoogleTest.
returnRUN_ALL_TESTS();
}

//Account.h
//basicapplicationdataclass
#pragmaonce

#include<string>

classAccount
{
private:
std::stringaccountId;

longbalance;

public:
Account();

Account(conststd::string&accountId,longinitialBalance);

voiddebit(longamount);

voidcredit(longamount);

longgetBalance()const;

std::stringgetAccountId()const;
};

//Account.cpp
#include"Account.h"

Account::Account()
{
}

Account::Account(conststd::string&accountId,longinitialBalance)
{
this->accountId=accountId;
this->balance=initialBalance;
}

voidAccount::debit(longamount)
{
this->balance-=amount;
}

voidAccount::credit(longamount)
{
this->balance+=amount;
}

longAccount::getBalance()const
{
returnthis->balance;
}

std::stringAccount::getAccountId()const
{
returnaccountId;
}

//AccountManager.h
//theinterfaceofexternalserviceswhichshouldbemocked
#pragmaonce

#include<string>

#include"Account.h"

classAccountManager
{
public:
virtualAccountfindAccountForUser(conststd::string&userId)=0;

virtualvoidupdateAccount(constAccount&account)=0;
};

//AccountService.h
//theclasstobetested
#pragmaonce

#include<string>

#include"Account.h"
#include"AccountManager.h"

classAccountService
{
private:
AccountManager*pAccountManager;

public:
AccountService();

voidsetAccountManager(AccountManager*pManager);
voidtransfer(conststd::string&senderId,
conststd::string&beneficiaryId,longamount);
};

//AccountService.cpp
#include"AccountService.h"

AccountService::AccountService()
{
this->pAccountManager=NULL;
}

voidAccountService::setAccountManager(AccountManager*pManager)
{
this->pAccountManager=pManager;
}

voidAccountService::transfer(conststd::string&senderId,
conststd::string&beneficiaryId,longamount)
{
Accountsender=this->pAccountManager->findAccountForUser(senderId);

Accountbeneficiary=this->pAccountManager->findAccountForUser(beneficiaryId);

sender.debit(amount);

beneficiary.credit(amount);

this->pAccountManager->updateAccount(sender);

this->pAccountManager->updateAccount(beneficiary);
}

//AccountServiceTest.cpp
//codetotestAccountService
#include<map>
#include<string>

#include<gtest/gtest.h>
#include<gmock/gmock.h>

#include"../Account.h"
#include"../AccountService.h"
#include"../AccountManager.h"

//MockAccountManager,mockAccountManagerwithgooglemock
classMockAccountManager:publicAccountManager
{
public:
MOCK_METHOD1(findAccountForUser,Account(conststd::string&));

MOCK_METHOD1(updateAccount,void(constAccount&));
};

//AfacilityclassactsasanexternalDB
classAccountHelper
{
private:
std::map<std::string,Account>mAccount;
//aninternalmaptostoreallAccountsfortest

public:
AccountHelper(std::map<std::string,Account>&mAccount);

voidupdateAccount(constAccount&account);

AccountfindAccountForUser(conststd::string&userId);
};

AccountHelper::AccountHelper(std::map<std::string,Account>&mAccount)
{
this->mAccount=mAccount;
}

voidAccountHelper::updateAccount(constAccount&account)
{
this->mAccount[account.getAccountId()]=account;
}

AccountAccountHelper::findAccountForUser(conststd::string&userId)
{
if(this->mAccount.find(userId)!=this->mAccount.end())
returnthis->mAccount[userId];
else
returnAccount();
}

//TestcasetotestAccountService
TEST(AccountServiceTest,transferTest)
{
std::map<std::string,Account>mAccount;
mAccount["A"]=Account("A",3000);
mAccount["B"]=Account("B",2000);
AccountHelperhelper(mAccount);

MockAccountManager*pManager=newMockAccountManager();

//specifythebehaviorofMockAccountManager
//alwaysinvokeAccountHelper::findAccountForUser
//whenAccountManager::findAccountForUserisinvoked
EXPECT_CALL(*pManager,findAccountForUser(testing::_)).WillRepeatedly(
testing::Invoke(&helper,&AccountHelper::findAccountForUser));

//alwaysinvokeAccountHelper::updateAccount
//whenAccountManager::updateAccountisinvoked
EXPECT_CALL(*pManager,updateAccount(testing::_)).WillRepeatedly(
testing::Invoke(&helper,&AccountHelper::updateAccount));

AccountServiceas;
//injecttheMockAccountManagerobjectintoAccountService
as.setAccountManager(pManager);

//operateAccountService
as.transfer("A","B",1005);

//checkthebalanceofAccount("A")andAccount("B")to
//verifythatAccountServicehasdonetherightjob
EXPECT_EQ(1995,helper.findAccountForUser("A").getBalance());
EXPECT_EQ(3005,helper.findAccountForUser("B").getBalance());

deletepManager;
}

//Main.cpp
#include<gtest/gtest.h>
#include<gmock/gmock.h>

intmain(intargc,char**argv){
testing::InitGoogleMock(&argc,argv);

//RunsalltestsusingGoogleTest.
returnRUN_ALL_TESTS();
}