inc/CppUnitTest/TestResult.h


#ifndef CPPUNIT_TESTRESULT_H
#define CPPUNIT_TESTRESULT_H

#include <vector>

#include "CppUnitTest/Guards.h"
#include "CppUnitTest/TestFailure.h"

#include "CppUnitTest/CppUnitTestNamespace.h"
BEGIN_NAMESPACE_CPPUNITTEST

class CppUnitException;
class Test;


/*
 * A TestResult collects the results of executing a test case. It is an 
 * instance of the Collecting Parameter pattern.
 *
 * The test framework distinguishes between failures and errors.
 * A failure is anticipated and checked for with assertions. Errors are
 * unanticipated problems signified by exceptions that are not generated
 * by the framework.
 *
 * TestResult supplies a template method 'setSynchronizationObject ()'
 * so that subclasses can provide mutual exclusion in the face of multiple
 * threads.  This can be useful when tests execute in one thread and
 * they fill a subclass of TestResult which effects change in another 
 * thread.  To have mutual exclusion, override setSynchronizationObject ()
 * and make sure that you create an instance of ExclusiveZone at the 
 * beginning of each method.
 *
 * see Test
 */

class TestResult
{
    REFERENCEOBJECT (TestResult)

public:
                                        TestResult  ();
    virtual                             ~TestResult ();

    virtual void                        addError       (Test *test, CppUnitException *e);
    virtual void                        addFailure     (Test *test, CppUnitException *e);
    virtual void                        startTest      (Test *test);
    virtual void                        endTest        (Test *test);
    virtual int                         runTests       ();
    virtual int                         testErrors     ();
    virtual int                         testFailures   ();
    virtual bool                        wasSuccessful  ();
    virtual bool                        shouldStop     ();
    virtual void                        stop           ();

    virtual std::vector<TestFailure *>& errors         ();
    virtual std::vector<TestFailure *>& failures       ();


    class SynchronizationObject
    {
    public:
                                SynchronizationObject  () {}
        virtual                 ~SynchronizationObject () {}

        virtual void            lock                   () {}
        virtual void            unlock                 () {}
    };

    class ExclusiveZone
    {
        SynchronizationObject   *m_syncObject;

    public:
                                ExclusiveZone (SynchronizationObject *syncObject) 
                                : m_syncObject (syncObject) 
                                { m_syncObject->lock (); }

                                ~ExclusiveZone () 
                                { m_syncObject->unlock (); }
    };

protected:
    virtual void                setSynchronizationObject (SynchronizationObject *syncObject);

    std::vector<TestFailure *>  m_errors;
    std::vector<TestFailure *>  m_failures;
    int                         m_runTests;
    bool                        m_stop;
    SynchronizationObject       *m_syncObject;

};


// Construct a TestResult
inline TestResult::TestResult ()
: m_syncObject (new SynchronizationObject ())
{ m_runTests = 0; m_stop = false; }


// Adds an error to the list of errors. The passed in exception
// caused the error
inline void TestResult::addError (Test *test, CppUnitException *e)
{ ExclusiveZone zone (m_syncObject); m_errors.push_back (new TestFailure (test, e)); }


// Adds a failure to the list of failures. The passed in exception
// caused the failure.
inline void TestResult::addFailure (Test *test, CppUnitException *e)
{ ExclusiveZone zone (m_syncObject); m_failures.push_back (new TestFailure (test, e)); }


// Informs the result that a test will be started.
inline void TestResult::startTest (Test *test)
{ ExclusiveZone zone (m_syncObject); m_runTests++; }

  
// Informs the result that a test was completed.
inline void TestResult::endTest (Test *test)
{ ExclusiveZone zone (m_syncObject); }


// Gets the number of run tests.
inline int TestResult::runTests ()
{ ExclusiveZone zone (m_syncObject); return m_runTests; }


// Gets the number of detected errors.
inline int TestResult::testErrors ()
{ ExclusiveZone zone (m_syncObject); return m_errors.size (); }


// Gets the number of detected failures.
inline int TestResult::testFailures ()
{ ExclusiveZone zone (m_syncObject); return m_failures.size (); }


// Returns whether the entire test was successful or not.
inline bool TestResult::wasSuccessful ()
{ ExclusiveZone zone (m_syncObject); return m_failures.size () == 0 && m_errors.size () == 0; }


// Returns a vector of the errors.
inline std::vector<TestFailure *>& TestResult::errors ()
{ ExclusiveZone zone (m_syncObject); return m_errors; }


// Returns a vector of the failures.
inline std::vector<TestFailure *>& TestResult::failures ()
{ ExclusiveZone zone (m_syncObject); return m_failures; }


// Returns whether testing should be stopped
inline bool TestResult::shouldStop ()
{ ExclusiveZone zone (m_syncObject); return m_stop; }


// Stop testing
inline void TestResult::stop ()
{ ExclusiveZone zone (m_syncObject); m_stop = true; }


// Accept a new synchronization object for protection of this instance
// TestResult assumes ownership of the object
inline void TestResult::setSynchronizationObject (SynchronizationObject *syncObject)
{ delete m_syncObject; m_syncObject = syncObject; }

END_NAMESPACE_CPPUNITTEST

#endif


1
2	#ifndef CPPUNIT_TESTRESULT_H
3	#define CPPUNIT_TESTRESULT_H
4
5	#include <vector>
6
7	#include "CppUnitTest/Guards.h"
8	#include "CppUnitTest/TestFailure.h"
9
10	#include "CppUnitTest/CppUnitTestNamespace.h"
11	BEGIN_NAMESPACE_CPPUNITTEST
12
13	class CppUnitException;
14	class Test;
15
16
17	/*
18	* A TestResult collects the results of executing a test case. It is an
19	* instance of the Collecting Parameter pattern.
20	*
21	* The test framework distinguishes between failures and errors.
22	* A failure is anticipated and checked for with assertions. Errors are
23	* unanticipated problems signified by exceptions that are not generated
24	* by the framework.
25	*
26	* TestResult supplies a template method 'setSynchronizationObject ()'
27	* so that subclasses can provide mutual exclusion in the face of multiple
28	* threads. This can be useful when tests execute in one thread and
29	* they fill a subclass of TestResult which effects change in another
30	* thread. To have mutual exclusion, override setSynchronizationObject ()
31	* and make sure that you create an instance of ExclusiveZone at the
32	* beginning of each method.
33	*
34	* see Test
35	*/
36
37	class TestResult
38	{
39	REFERENCEOBJECT (TestResult)
40
41	public:
42	TestResult ();
43	virtual ~TestResult ();
44
45	virtual void addError (Test test, CppUnitException e);
46	virtual void addFailure (Test test, CppUnitException e);
47	virtual void startTest (Test *test);
48	virtual void endTest (Test *test);
49	virtual int runTests ();
50	virtual int testErrors ();
51	virtual int testFailures ();
52	virtual bool wasSuccessful ();
53	virtual bool shouldStop ();
54	virtual void stop ();
55
56	virtual std::vector<TestFailure *>& errors ();
57	virtual std::vector<TestFailure *>& failures ();
58
59
60	class SynchronizationObject
61	{
62	public:
63	SynchronizationObject () {}
64	virtual ~SynchronizationObject () {}
65
66	virtual void lock () {}
67	virtual void unlock () {}
68	};
69
70	class ExclusiveZone
71	{
72	SynchronizationObject *m_syncObject;
73
74	public:
75	ExclusiveZone (SynchronizationObject *syncObject)
76	: m_syncObject (syncObject)
77	{ m_syncObject->lock (); }
78
79	~ExclusiveZone ()
80	{ m_syncObject->unlock (); }
81	};
82
83	protected:
84	virtual void setSynchronizationObject (SynchronizationObject *syncObject);
85
86	std::vector<TestFailure *> m_errors;
87	std::vector<TestFailure *> m_failures;
88	int m_runTests;
89	bool m_stop;
90	SynchronizationObject *m_syncObject;
91
92	};
93
94
95
96	// Construct a TestResult
97	inline TestResult::TestResult ()
98	: m_syncObject (new SynchronizationObject ())
99	{ m_runTests = 0; m_stop = false; }
100
101
102	// Adds an error to the list of errors. The passed in exception
103	// caused the error
104	inline void TestResult::addError (Test test, CppUnitException e)
105	{ ExclusiveZone zone (m_syncObject); m_errors.push_back (new TestFailure (test, e)); }
106
107
108	// Adds a failure to the list of failures. The passed in exception
109	// caused the failure.
110	inline void TestResult::addFailure (Test test, CppUnitException e)
111	{ ExclusiveZone zone (m_syncObject); m_failures.push_back (new TestFailure (test, e)); }
112
113
114	// Informs the result that a test will be started.
115	inline void TestResult::startTest (Test *test)
116	{ ExclusiveZone zone (m_syncObject); m_runTests++; }
117
118
119	// Informs the result that a test was completed.
120	inline void TestResult::endTest (Test *test)
121	{ ExclusiveZone zone (m_syncObject); }
122
123
124	// Gets the number of run tests.
125	inline int TestResult::runTests ()
126	{ ExclusiveZone zone (m_syncObject); return m_runTests; }
127
128
129	// Gets the number of detected errors.
130	inline int TestResult::testErrors ()
131	{ ExclusiveZone zone (m_syncObject); return m_errors.size (); }
132
133
134	// Gets the number of detected failures.
135	inline int TestResult::testFailures ()
136	{ ExclusiveZone zone (m_syncObject); return m_failures.size (); }
137
138
139	// Returns whether the entire test was successful or not.
140	inline bool TestResult::wasSuccessful ()
141	{ ExclusiveZone zone (m_syncObject); return m_failures.size () == 0 && m_errors.size () == 0; }
142
143
144	// Returns a vector of the errors.
145	inline std::vector<TestFailure *>& TestResult::errors ()
146	{ ExclusiveZone zone (m_syncObject); return m_errors; }
147
148
149	// Returns a vector of the failures.
150	inline std::vector<TestFailure *>& TestResult::failures ()
151	{ ExclusiveZone zone (m_syncObject); return m_failures; }
152
153
154	// Returns whether testing should be stopped
155	inline bool TestResult::shouldStop ()
156	{ ExclusiveZone zone (m_syncObject); return m_stop; }
157
158
159	// Stop testing
160	inline void TestResult::stop ()
161	{ ExclusiveZone zone (m_syncObject); m_stop = true; }
162
163
164	// Accept a new synchronization object for protection of this instance
165	// TestResult assumes ownership of the object
166	inline void TestResult::setSynchronizationObject (SynchronizationObject *syncObject)
167	{ delete m_syncObject; m_syncObject = syncObject; }
168
169	END_NAMESPACE_CPPUNITTEST
170
171	#endif
172
173
174
175
176
177
178
179
Name	Value
svn:eol-style	native
svn:executable	*
svn:keywords	Author Date Id Revision