使用google模拟对象编写（google）测试用例的最佳方法是什么，并期望从测试中的类控制的另一个线程调用EXPECT_CALL（）定义？ 在触发调用序列之后简单地调用sleep（）或类似函数感觉不合适，因为它可能会减慢不必要的测试速度，并且可能无法真正达到时序条件。但完成测试用例不得不等到模拟方法被调用。 任何想法？
这里有一些代码来说明这种情况：
Bar.hpp（被测试的课程）
class Bar
{
public:
Bar(IFooInterface* argFooInterface);
virtual ~Bar();
void triggerDoSomething();
void start();
void stop();
private:
void* barThreadMethod(void* userArgs);
void endThread();
void doSomething();
ClassMethodThread<Bar> thread; // A simple class method thread implementation using boost::thread
IFooInterface* fooInterface;
boost::interprocess::interprocess_semaphore semActionTrigger;
boost::interprocess::interprocess_semaphore semEndThread;
bool stopped;
bool endThreadRequested;
};
Bar.cpp（摘录）：
void Bar::triggerDoSomething()
{
semActionTrigger.post();
}
void* Bar::barThreadMethod(void* userArgs)
{
(void)userArgs;
stopped = false;
do
{
semActionTrigger.wait();
if(!endThreadRequested && !semActionTrigger.try_wait())
{
doSomething();
}
} while(!endThreadRequested && !semEndThread.try_wait());
stopped = true;
return NULL;
}
void Bar::doSomething()
{
if(fooInterface)
{
fooInterface->func1();
if(fooInterface->func2() > 0)
{
return;
}
fooInterface->func3(5);
}
}
测试代码（摘录，到目前为止FooInterfaceMock定义没有什么特别之处）：
class BarTest : public ::testing::Test
{
public:
BarTest()
: fooInterfaceMock()
, bar(&fooInterfaceMock)
{
}
protected:
FooInterfaceMock fooInterfaceMock;
Bar bar;
};
TEST_F(BarTest, DoSomethingWhenFunc2Gt0)
{
EXPECT_CALL(fooInterfaceMock,func1())
.Times(1);
EXPECT_CALL(fooInterfaceMock,func2())
.Times(1)
.WillOnce(Return(1));
bar.start();
bar.triggerDoSomething();
//sleep(1);
bar.stop();
}
没有睡觉的测试结果（）：
[==========] Running 1 test from 1 test case.
[----------] Global test environment set-up.
[----------] 1 test from BarTest
[ RUN ] BarTest.DoSomethingWhenFunc2Gt0
../test/BarTest.cpp:39: Failure
Actual function call count doesn't match EXPECT_CALL(fooInterfaceMock, func2())...
Expected: to be called once
Actual: never called - unsatisfied and active
../test/BarTest.cpp:37: Failure
Actual function call count doesn't match EXPECT_CALL(fooInterfaceMock, func1())...
Expected: to be called once
Actual: never called - unsatisfied and active
[ FAILED ] BarTest.DoSomethingWhenFunc2Gt0 (1 ms)
[----------] 1 test from BarTest (1 ms total)
[----------] Global test environment tear-down
[==========] 1 test from 1 test case ran. (1 ms total)
[ PASSED ] 0 tests.
[ FAILED ] 1 test, listed below:
[ FAILED ] BarTest.DoSomethingWhenFunc2Gt0
1 FAILED TEST
terminate called after throwing an instance of 'boost::exception_detail::clone_impl<boost::exception_detail::error_info_injector<boost::lock_error> >'
Aborted
启用sleep（）的测试结果：
[==========] Running 1 test from 1 test case.
[----------] Global test environment set-up.
[----------] 1 test from BarTest
[ RUN ] BarTest.DoSomethingWhenFunc2Gt0
[ OK ] BarTest.DoSomethingWhenFunc2Gt0 (1000 ms)
[----------] 1 test from BarTest (1000 ms total)
[----------] Global test environment tear-down
[==========] 1 test from 1 test case ran. (1000 ms total)
[ PASSED ] 1 test.
我想避免sleep（），最好不需要更改Bar类。
答案 0 :(得分：14)
弗雷泽的回答激发了我使用GMock专业动作的简单解决方案。 GMock使得快速编写此类动作非常容易。
这是代码（摘自BarTest.cpp）：
// Specialize an action that synchronizes with the calling thread
ACTION_P2(ReturnFromAsyncCall,RetVal,SemDone)
{
SemDone->post();
return RetVal;
}
TEST_F(BarTest, DoSomethingWhenFunc2Gt0)
{
boost::interprocess::interprocess_semaphore semDone(0);
EXPECT_CALL(fooInterfaceMock,func1())
.Times(1);
EXPECT_CALL(fooInterfaceMock,func2())
.Times(1)
// Note that the return type doesn't need to be explicitly specialized
.WillOnce(ReturnFromAsyncCall(1,&semDone));
bar.start();
bar.triggerDoSomething();
boost::posix_time::ptime until = boost::posix_time::second_clock::universal_time() +
boost::posix_time::seconds(1);
EXPECT_TRUE(semDone.timed_wait(until));
bar.stop();
}
TEST_F(BarTest, DoSomethingWhenFunc2Eq0)
{
boost::interprocess::interprocess_semaphore semDone(0);
EXPECT_CALL(fooInterfaceMock,func1())
.Times(1);
EXPECT_CALL(fooInterfaceMock,func2())
.Times(1)
.WillOnce(Return(0));
EXPECT_CALL(fooInterfaceMock,func3(Eq(5)))
.Times(1)
// Note that the return type doesn't need to be explicitly specialized
.WillOnce(ReturnFromAsyncCall(true,&semDone));
bar.start();
bar.triggerDoSomething();
boost::posix_time::ptime until = boost::posix_time::second_clock::universal_time() +
boost::posix_time::seconds(1);
EXPECT_TRUE(semDone.timed_wait(until));
bar.stop();
}
请注意，相同的原则适用于boost::interprocess::interprocess_semaphore的任何其他类型的信号量实现。我正在使用它来使用我们的生产代码进行测试，该代码使用它自己的操作系统抽象层和信号量实现。
答案 1 :(得分：7)
使用lambdas，你可以做类似的事情（我已经在评论中添加了等价物）：
TEST_F(BarTest, DoSomethingWhenFunc2Gt0)
{
std::mutex mutex; // boost::mutex mutex;
std::condition_variable cond_var; // boost::condition_variable cond_var;
bool done(false);
EXPECT_CALL(fooInterfaceMock, func1())
.Times(1);
EXPECT_CALL(fooInterfaceMock, func2())
.Times(1)
.WillOnce(testing::Invoke([&]()->int {
std::lock_guard<std::mutex> lock(mutex); // boost::mutex::scoped_lock lock(mutex);
done = true;
cond_var.notify_one();
return 1; }));
bar.start();
bar.triggerDoSomething();
{
std::unique_lock<std::mutex> lock(mutex); // boost::mutex::scoped_lock lock(mutex);
EXPECT_TRUE(cond_var.wait_for(lock, // cond_var.timed_wait
std::chrono::seconds(1), // boost::posix_time::seconds(1),
[&done] { return done; }));
}
bar.stop();
}
如果你不能使用lambdas，我想你可以改用boost::bind。
答案 2 :(得分：0)
TEST_F(BarTest, DoSomethingWhenFunc2Gt0)
{
EXPECT_CALL(fooInterfaceMock,func1()).Times(1);
EXPECT_CALL(fooInterfaceMock,func2()).Times(1).WillOnce(Return(1));
bar.start();
bar.triggerDoSomething();
// How long of a wait is too long?
auto now = chrono::system_clock::now();
auto tooLong = now + std::chrono::milliseconds(50);
/* Expect your thread to update this condition, so execution will continue
* as soon as the condition is updated and you won't have to sleep
* for the remainder of the time
*/
while (!bar.condition() && (now = chrono::system_clock::now()) < tooLong)
{
/* Not necessary in all cases, but some compilers may optimize out
* the while loop if there's no loop body.
*/
this_thread::sleep_for(chrono::milliseconds(1));
}
// If the assertion fails, then time ran out.
ASSERT_LT(now, tooLong);
bar.stop();
}
答案 3 :(得分：0)
因此，我喜欢这些解决方案，但以为可能会更容易实现，所以我不得不等待测试启动：
Tomcat答案 4 :(得分：0)
在πάνταῥεῖ解决方案提出后，我设法解决了这个问题，但是使用了std :: condition_variable。该解决方案与Fraser提出的解决方案有所不同，并且可能会通过lambda加以改进。
ACTION_P(ReturnFromAsyncCall, cv)
{
cv->notify_all();
}
...
TEST_F(..,..)
{
std::condition_variable cv;
...
EXPECT_CALL(...).WillRepeatedly(ReturnFromAsyncCall(&cv));
std::mutex mx;
std::unique_lock<std::mutex> lock(mx);
cv.wait_for(lock, std::chrono::seconds(1));
}
这里似乎互斥锁只是为了满足条件变量。