学习笔记：解读CppUnit源码5

cppUnit是支持多线程模式下测试的一种方法，在阅读TestListener之前我们不妨看看SynchronizedObject里面到底有什么东西。

SynchronizedObject用来管理一个被同步对象,它定义了一个public属性的abstract inner class——SynchronizationObject，代表具备同步属性的对象

//此类定义了互斥锁功能，但具体行为需在其派生类中实现 //MfcSynchronizationObject就继承这个后使用mfc的CCriticalSection来实现保护 class MySynchronizationObject { public: MySynchronizationObject() {}; virtual ~MySynchronizationObject() {}; virtual void lock() {}; virtual void unlock() {}; };

MfcSynchronizationObject中，用CCriticalSection临界区来实现同步的。

class MfcSynchronizationObject : public CPPUNIT_NS::SynchronizedObject::SynchronizationObject { CCriticalSection m_syncObject; public: void lock() { m_syncObject.Lock(); } void unlock() { m_syncObject.Unlock(); } };

SynchronizedObject还定义了一个protected属性的inner class——ExclusiveZone

//它用于在当前作用域内锁定一个SynchronizationObject的实例。 //其实现类似于std::auto_ptr,这样MyExclusiveZone的类周期就与临界区相同 class MyExclusiveZone { public: MyExclusiveZone( MySynchronizationObject *syncObject ) : m_syncObject( syncObject ) { m_syncObject->lock(); }; ~MyExclusiveZone() { m_syncObject->unlock (); }; private: MySynchronizationObject *m_syncObject; };

说白了ExclusiveZone类就是对SynchronizationObject对象的控制辅助。

接下来再看SynchronizedObject就简单了，SynchronizedObject就是对SynchronizationObject的指针对象m_syncObject的控制。其实SynchronizedObject类就是一个管理同步的类，有了两个inner类后，才感觉阅读起来有点复杂。不过这样设计其实也是为了扩展需要，同步的方法不止一种，可以继承SynchronizationObject后重载lock()和unlock()方法来实现具体如何同步。

终于可以讲TestListener了。

class CPPUNIT_API MyTestListener { public: virtual ~MyTestListener(){}; // 在一个测试运行前被调用 virtual void startTest( MyTest * /*test*/ ) {}; //运行测试失败时被调用 virtual void addFailure( const MyTestFailure &failure ) {}; // 在一个测试运行后被调用 virtual void endTest( MyTest * /*test*/ ){}; // 在一组测试运行前被调用 virtual void startSuite( MyTest * /*suite*/ ){}; // 在一组测试运行后被调用 virtual void endSuite( MyTest * /*suite*/ ) {}; virtual void startTestRun( MyTest * /*test*/, MyTestResult * /*eventManager*/ ) {}; virtual void endTestRun( MyTest * /*test*/, MyTestResult * /*eventManager*/ ) {}; };

BriefTestProgressListener.h加入了是否要输入错误信息的标志

class CPPUNIT_API MyBriefTestProgressListener : public MyTestListener { public: MyBriefTestProgressListener() :m_lastTestFailed(false){}; virtual ~MyBriefTestProgressListener(){}; void startTest( MyTest *test ) { std::cerr << "."; std::cerr.flush(); m_lastTestFailed = false; }; void addFailure( const MyTestFailure &failure ) { std::cout << " : " << (failure.isError() ? "error" : "assertion"); m_lastTestFailed = true; }; void endTest( MyTest *test ) { if ( !m_lastTestFailed ) std::cout << " : OK"; std::cout << "/n"; }; private: MyBriefTestProgressListener( const MyBriefTestProgressListener © ); MyBriefTestProgressListener &operator =( const MyBriefTestProgressListener © ); private: bool m_lastTestFailed; };

TextTestProgressListener.h

//监听测试用例的运行状态，并将结果定向到屏幕 class CPPUNIT_API MyTextTestProgressListener : public MyTestListener { public: MyTextTestProgressListener(){}; virtual ~MyTextTestProgressListener(){}; //在测试运行前被调用 void startTest( MyTest *test ) { std::cerr << "."; std::cerr.flush(); }; //运行测试失败时被调用 void addFailure( const MyTestFailure &failure ) { std::cerr << ( failure.isError() ? "E" : "F" ); std::cerr.flush(); }; // 在测试运行后被调用 void endTestRun( MyTest *test, MyTestResult *eventManager ) { std::cerr << std::endl; std::cerr.flush(); }; private: MyTextTestProgressListener( const MyTextTestProgressListener © ); MyTextTestProgressListener &operator =( const MyTextTestProgressListener © ); };

TestSuccessListener.h

//一个实际的观察者 class CPPUNIT_API MyTestSuccessListener : public MyTestListener, public MySynchronizedObject { public: MyTestSuccessListener( MySynchronizationObject *syncObject = NULL ) : MySynchronizedObject( syncObject ) , m_success( true ) { }; virtual ~MyTestSuccessListener(){}; virtual void reset() { MyExclusiveZone zone( m_syncObject ); m_success = true; }; void addFailure( const MyTestFailure &failure ) { MyExclusiveZone zone( m_syncObject ); //TestSucessListener只关心测试成功与否， //至于有关测试结果的详细情况则由TestResultCollector负责 m_success = false; }; virtual bool wasSuccessful() const { MyExclusiveZone zone( m_syncObject ); return m_success; }; private: bool m_success; };

TestSuccessListener只关心测试用例是否运行成功，如果失败的话会调用addFailure()这个方法，调用后就知道该测试用例失败了。reset()是在开始或者重新开始的时候使用。把测试成否的标志置为真。多重继承自SynchronizedObject顾名思义是为了实现多线程。

TestResultCollector.h

class CPPUNIT_API MyTestResultCollector : public MyTestSuccessListener { public: typedef CppUnitDeque<MyTestFailure *> TestFailures;//运行失败的测试个数 typedef CppUnitDeque<MyTest *> Tests;//运行的测试个数 MyTestResultCollector( MySynchronizationObject *syncObject = 0 ) :MyTestSuccessListener(syncObject) { reset(); }; virtual ~MyTestResultCollector() { freeFailures(); }; //加入测试用例 void startTest( MyTest *test ) { MyExclusiveZone zone( m_syncObject ); m_tests.push_back(test); }; //加入错误 void addFailure( const MyTestFailure &failure ) { MyTestSuccessListener::addFailure( failure ); MyExclusiveZone zone( m_syncObject ); // 若failure为error，则m_testErrors加1 if ( failure.isError() ) ++m_testErrors; //用一个TestFailure队列装起来 m_failures.push_back( failure.clone() ); }; virtual void reset() { MyTestSuccessListener::reset(); MyExclusiveZone zone( m_syncObject ); m_testErrors = 0; m_tests.clear(); m_failures.clear(); }; //得到测试用例的数目 virtual int runTests() const { MyExclusiveZone zone( m_syncObject ); return m_tests.size(); }; //得到错误的数目 virtual int testErrors() const { MyExclusiveZone zone( m_syncObject ); return m_testErrors; }; //得到失败的数目 virtual int testFailures() const { MyExclusiveZone zone( m_syncObject ); return m_failures.size() - m_testErrors; }; //得到失败+错误的数目 virtual int testFailuresTotal() const { MyExclusiveZone zone( m_syncObject ); return m_failures.size(); }; //指针队列用以记录测试失败信息 virtual const TestFailures& failures() const { return m_failures; }; //返回指针队列用以记录测试对象 virtual const Tests &tests() const { return m_tests; }; protected: void freeFailures() { TestFailures::iterator itFailure = m_failures.begin(); while ( itFailure != m_failures.end() ) delete *itFailure++; m_failures.clear(); }; protected: Tests m_tests;// 指针队列用以记录测试对象 TestFailures m_failures;// 指针队列用以记录测试失败信息 int m_testErrors;// 用以记录测试错误个数 private: MyTestResultCollector( const MyTestResultCollector © ); MyTestResultCollector& operator =( const MyTestResultCollector © ); };

在这个类里面，聚集了Test的对象链表和TestFailure的对象链表。既然有了这2样东西，想如何输出或想怎样输出测试用例的错误就比较方便了，只要在输出类里面包含一下这个类就可以了。其实这个才是真正的Listener。

最后说明一下TestResult.h这个类

//为了支持多线程，所以继承了MySynchronizedObject class CPPUNIT_API MyTestResult : protected MySynchronizedObject { public: //TestListener需要注册并保存到Deque队列中 typedef CppUnitDeque<MyTestListener*> TestListeners; public: MyTestResult( MySynchronizationObject *syncObject = 0 ) : MySynchronizedObject( syncObject ) , m_protectorChain( new ProtectorChain() ) , m_stop( false ) { m_protectorChain->push( new MyDefaultProtector() ); }; virtual ~MyTestResult() { delete m_protectorChain; }; //增加监听者 virtual void addListener( MyTestListener *listener ) { MyExclusiveZone zone( m_syncObject ); m_listeners.push_back( listener ); }; //删除监听者 virtual void removeListener( MyTestListener *listener ) { MyExclusiveZone zone( m_syncObject ); m_listeners.erase( std::remove( m_listeners.begin(), m_listeners.end(), listener ), m_listeners.end()); }; //重新测试 virtual void reset() { MyExclusiveZone zone( m_syncObject ); m_stop = false; }; //停止测试 virtual void stop() { MyExclusiveZone zone( m_syncObject ); m_stop = true; }; //返回测试是否进行的标志 virtual bool shouldStop() const { MyExclusiveZone zone( m_syncObject ); return m_stop; } // 调用所有TestListener的startTest virtual void startTest(MyTest* test) { MyExclusiveZone zone( m_syncObject ); for ( TestListeners::iterator it = m_listeners.begin(); it != m_listeners.end(); ++it ) (*it)->startTest(test); }; // 调用所有TestListener的endTest virtual void endTest(MyTest *test) { MyExclusiveZone zone( m_syncObject ); for ( TestListeners::iterator it = m_listeners.begin(); it != m_listeners.end(); ++it ) (*it)->endTest(test); }; //调用所有TestListener的一组startSuite virtual void startSuite( MyTest *test ) { MyExclusiveZone zone( m_syncObject ); for ( TestListeners::iterator it = m_listeners.begin(); it != m_listeners.end(); ++it ) (*it)->startSuite( test ); }; //调用所有TestListener的一组endSuite virtual void endSuite( MyTest *test ) { MyExclusiveZone zone( m_syncObject ); for ( TestListeners::iterator it = m_listeners.begin(); it != m_listeners.end(); ++it ) (*it)->endSuite( test ); }; virtual void runTest( MyTest *test ) { startTestRun( test ); test->run( this ); endTestRun( test ); }; //virtual void addError( Test *test, Exception *e ); virtual void addFailure( MyTest *test, MyException *e ) { MyTestFailure failure( test, e, false ); addFailure( failure ); }; //这个是用户编写的测试函数执行入口 //由ProtectorChain去调用里面各个Protector //其作用是对执行函数（实际上是函数对象）的错误信息（包括断言和异常等）进行捕获， //从而实现对测试结果的统计。 //protect的设计非常巧妙，运用了设计模式中命令模式、装饰者和责任链三个设计模式。 virtual bool protect( const MyFunctor &functor, MyTest *test, const std::string &shortDescription = std::string("") ) { MyProtectorContext context( test, this, shortDescription ); return m_protectorChain->protect( functor, context ); }; //添加保护者到保护者链中 virtual void pushProtector( MyProtector *protector ) { m_protectorChain->push( protector ); }; //从保护者链中删除保护者 virtual void popProtector() { m_protectorChain->pop(); }; protected: virtual void addFailure( const MyTestFailure &failure ) { MyExclusiveZone zone( m_syncObject ); //通知所有Observer对象 for ( TestListeners::iterator it = m_listeners.begin(); it != m_listeners.end(); ++it ) (*it)->addFailure( failure ); }; virtual void startTestRun( MyTest *test ) { MyExclusiveZone zone( m_syncObject ); for ( TestListeners::iterator it = m_listeners.begin(); it != m_listeners.end(); ++it ) (*it)->startTestRun( test, this ); }; virtual void endTestRun( MyTest *test ) { MyExclusiveZone zone( m_syncObject ); for ( TestListeners::iterator it = m_listeners.begin(); it != m_listeners.end(); ++it ) (*it)->endTestRun( test, this ); }; protected: TestListeners m_listeners; //在TestResult里面实质上是包含了一个ProtectorChain（protector组成的链表），也就 //是说每个用户编写的测试函数将会经过这个链表的所有protector ProtectorChain *m_protectorChain; bool m_stop;//测试是否停止的标志 private: //不用拷贝构造和赋值函数 MyTestResult( const MyTestResult &other ); MyTestResult &operator =( const MyTestResult &other ); };

在TestResult里面m_listeners是一个链表。当调用TestResult::startTest(),TestResult::endTest()

TestResult::startSuite(),TestResul::endSuite()当其中一个方法被调用的时候，m_listeners链表里所有的成员里都会遍历访问一遍。这个就是访问者模式。这里的listener机制个人觉得就是命令模式和访问者模式的结合。

这里还有一个之前讲过的ProtectorChain的控制，保护者也作成了一个链表，添加删除的操作是pushProtector()和popProtector()。TestResult::protect()就是保护机构的核心接口。

 

讲到这里大家应该对TestResult的结构和方法已经很了解了，再在这里总结一下。TestResult里面有两个链表是关键，当外部对保护者链表和监听者链表访问时就是一个观察者模式。个子类会分别相应TestResult接口的变化。真正的监听者是TestSuccessListener的子类：TestResultCollector，而真正的保护者是Protector的子类：DefaultProtector。TestResult继承SynchronizedObject以实现多线程。TestResult与Test的关系是使用与被使用的关系。