← Back to branch summary

~s-cecilio/lenmus/v5.3

« back to all changes in this revision

Viewing changes to packages/UnitTest++/src/tests/TestTestRunner.cpp

  • Committer: cecilios
  • Date: 2007-05-19 11:39:03 UTC
  • Revision ID: svn-v4:2587a929-2f0e-0410-ae78-fe6f687d5efe:trunk:236

Show diffs side-by-side

added added

removed removed

Lines of Context:
packages/UnitTest++/src/tests/TestTestRunner.cpp
1
 
#include "../UnitTest++.h"
2
 
#include "RecordingReporter.h"
3
 
#include "../ReportAssert.h"
4
 
#include "../TestList.h"
5
 
#include "../TimeHelpers.h"
6
 
#include "../TimeConstraint.h"
7
 
 
8
 
using namespace UnitTest;
9
 
 
10
 
namespace
11
 
{
12
 
 
13
 
struct MockTest : public Test
14
 
{
15
 
    MockTest(char const* testName, bool const success_, bool const assert_, int const count_ = 1)
16
 
        : Test(testName)
17
 
        , success(success_)
18
 
        , asserted(assert_)
19
 
        , count(count_)
20
 
    {
21
 
    }
22
 
 
23
 
    virtual void RunImpl(TestResults& testResults_) const
24
 
    {
25
 
        for (int i=0; i < count; ++i)
26
 
        {
27
 
            if (asserted)
28
 
                ReportAssert("desc", "file", 0);
29
 
            else if (!success)
30
 
                testResults_.OnTestFailure(m_details, "message");
31
 
        }
32
 
    }
33
 
 
34
 
    bool const success;
35
 
    bool const asserted;
36
 
    int const count;
37
 
};
38
 
 
39
 
 
40
 
struct TestRunnerFixture
41
 
{
42
 
        TestRunnerFixture()
43
 
                : runner(reporter)
44
 
        {
45
 
        }
46
 
 
47
 
    RecordingReporter reporter;
48
 
    TestList list;
49
 
        TestRunner runner;
50
 
};
51
 
 
52
 
TEST_FIXTURE(TestRunnerFixture, TestStartIsReportedCorrectly)
53
 
{
54
 
    MockTest test("goodtest", true, false);
55
 
    list.Add(&test);
56
 
 
57
 
        runner.RunTestsIf(list, NULL, True(), 0);
58
 
    CHECK_EQUAL(1, reporter.testRunCount);
59
 
    CHECK_EQUAL("goodtest", reporter.lastStartedTest);
60
 
}
61
 
 
62
 
TEST_FIXTURE(TestRunnerFixture, TestFinishIsReportedCorrectly)
63
 
{
64
 
    MockTest test("goodtest", true, false);
65
 
    list.Add(&test);
66
 
 
67
 
        runner.RunTestsIf(list, NULL, True(), 0);
68
 
    CHECK_EQUAL(1, reporter.testFinishedCount);
69
 
    CHECK_EQUAL("goodtest", reporter.lastFinishedTest);
70
 
}
71
 
 
72
 
class SlowTest : public Test
73
 
{
74
 
public:
75
 
    SlowTest() : Test("slow", "somesuite", "filename", 123) {}
76
 
    virtual void RunImpl(TestResults&) const
77
 
    {
78
 
        TimeHelpers::SleepMs(20);
79
 
    }
80
 
};
81
 
 
82
 
TEST_FIXTURE(TestRunnerFixture, TestFinishIsCalledWithCorrectTime)
83
 
{
84
 
    SlowTest test;
85
 
    list.Add(&test);
86
 
 
87
 
        runner.RunTestsIf(list, NULL, True(), 0);
88
 
    CHECK(reporter.lastFinishedTestTime >= 0.005f && reporter.lastFinishedTestTime <= 0.050f);
89
 
}
90
 
 
91
 
TEST_FIXTURE(TestRunnerFixture, FailureCountIsZeroWhenNoTestsAreRun)
92
 
{
93
 
        CHECK_EQUAL(0, runner.RunTestsIf(list, NULL, True(), 0));
94
 
    CHECK_EQUAL(0, reporter.testRunCount);
95
 
    CHECK_EQUAL(0, reporter.testFailedCount);
96
 
}
97
 
 
98
 
TEST_FIXTURE(TestRunnerFixture, CallsReportFailureOncePerFailingTest)
99
 
{
100
 
    MockTest test1("test", false, false);
101
 
    list.Add(&test1);
102
 
    MockTest test2("test", true, false);
103
 
    list.Add(&test2);
104
 
    MockTest test3("test", false, false);
105
 
    list.Add(&test3);
106
 
 
107
 
        CHECK_EQUAL(2,  runner.RunTestsIf(list, NULL, True(), 0));
108
 
    CHECK_EQUAL(2, reporter.testFailedCount);
109
 
}
110
 
 
111
 
TEST_FIXTURE(TestRunnerFixture, TestsThatAssertAreReportedAsFailing)
112
 
{
113
 
    MockTest test("test", true, true);
114
 
    list.Add(&test);
115
 
 
116
 
        runner.RunTestsIf(list, NULL, True(), 0);
117
 
    CHECK_EQUAL(1, reporter.testFailedCount);
118
 
}
119
 
 
120
 
 
121
 
TEST_FIXTURE(TestRunnerFixture, ReporterNotifiedOfTestCount)
122
 
{
123
 
    MockTest test1("test", true, false);
124
 
    MockTest test2("test", true, false);
125
 
    MockTest test3("test", true, false);
126
 
    list.Add(&test1);
127
 
    list.Add(&test2);
128
 
    list.Add(&test3);
129
 
 
130
 
        runner.RunTestsIf(list, NULL, True(), 0);
131
 
    CHECK_EQUAL(3, reporter.summaryTotalTestCount);
132
 
}
133
 
 
134
 
TEST_FIXTURE(TestRunnerFixture, ReporterNotifiedOfFailedTests)
135
 
{
136
 
    MockTest test1("test", false, false, 2);
137
 
    MockTest test2("test", true, false);
138
 
    MockTest test3("test", false, false, 3);
139
 
    list.Add(&test1);
140
 
    list.Add(&test2);
141
 
    list.Add(&test3);
142
 
 
143
 
        runner.RunTestsIf(list, NULL, True(), 0);
144
 
    CHECK_EQUAL(2, reporter.summaryFailedTestCount);
145
 
}
146
 
 
147
 
TEST_FIXTURE(TestRunnerFixture, ReporterNotifiedOfFailures)
148
 
{
149
 
    MockTest test1("test", false, false, 2);
150
 
    MockTest test2("test", true, false);
151
 
    MockTest test3("test", false, false, 3);
152
 
    list.Add(&test1);
153
 
    list.Add(&test2);
154
 
    list.Add(&test3);
155
 
 
156
 
        runner.RunTestsIf(list, NULL, True(), 0);
157
 
        CHECK_EQUAL(5, reporter.summaryFailureCount);
158
 
}
159
 
 
160
 
TEST_FIXTURE(TestRunnerFixture, SlowTestPassesForHighTimeThreshold)
161
 
{
162
 
    SlowTest test;
163
 
    list.Add(&test);
164
 
 
165
 
        runner.RunTestsIf(list, NULL, True(), 0);
166
 
    CHECK_EQUAL(0, reporter.testFailedCount);
167
 
}
168
 
 
169
 
TEST_FIXTURE(TestRunnerFixture, SlowTestFailsForLowTimeThreshold)
170
 
{
171
 
    SlowTest test;
172
 
    list.Add(&test);
173
 
 
174
 
        runner.RunTestsIf(list, NULL, True(), 3);
175
 
    CHECK_EQUAL(1, reporter.testFailedCount);
176
 
}
177
 
 
178
 
TEST_FIXTURE(TestRunnerFixture, SlowTestHasCorrectFailureInformation)
179
 
{
180
 
    SlowTest test;
181
 
    list.Add(&test);
182
 
 
183
 
        runner.RunTestsIf(list, NULL, True(), 3);
184
 
 
185
 
        using namespace std;
186
 
 
187
 
    CHECK_EQUAL(test.m_details.testName, reporter.lastFailedTest);
188
 
    CHECK(strstr(test.m_details.filename, reporter.lastFailedFile));
189
 
    CHECK_EQUAL(test.m_details.lineNumber, reporter.lastFailedLine);
190
 
 
191
 
        CHECK(strstr(reporter.lastFailedMessage, "Global time constraint failed"));
192
 
    CHECK(strstr(reporter.lastFailedMessage, "3ms"));
193
 
}
194
 
 
195
 
TEST_FIXTURE(TestRunnerFixture, SlowTestWithTimeExemptionPasses)
196
 
{
197
 
    class SlowExemptedTest : public Test
198
 
    {
199
 
    public:
200
 
        SlowExemptedTest() : Test("slowexempted", "", 0) {}
201
 
        virtual void RunImpl(TestResults&) const
202
 
        {
203
 
            UNITTEST_TIME_CONSTRAINT_EXEMPT();
204
 
            TimeHelpers::SleepMs(20);
205
 
        }
206
 
    };
207
 
 
208
 
    SlowExemptedTest test;
209
 
    list.Add(&test);
210
 
 
211
 
        runner.RunTestsIf(list, NULL, True(), 3);
212
 
    CHECK_EQUAL(0, reporter.testFailedCount);
213
 
}
214
 
 
215
 
struct TestSuiteFixture
216
 
{
217
 
    TestSuiteFixture()
218
 
        : test1("TestInDefaultSuite")
219
 
        , test2("TestInOtherSuite", "OtherSuite")
220
 
        , test3("SecondTestInDefaultSuite")
221
 
                , runner(reporter)
222
 
    {
223
 
        list.Add(&test1);
224
 
        list.Add(&test2);
225
 
    }
226
 
 
227
 
    Test test1;
228
 
    Test test2;
229
 
    Test test3;
230
 
    RecordingReporter reporter;
231
 
    TestList list;
232
 
        TestRunner runner;
233
 
};
234
 
 
235
 
TEST_FIXTURE(TestSuiteFixture, TestRunnerRunsAllSuitesIfNullSuiteIsPassed)
236
 
{
237
 
        runner.RunTestsIf(list, NULL, True(), 0);
238
 
    CHECK_EQUAL(2, reporter.summaryTotalTestCount);
239
 
}
240
 
 
241
 
TEST_FIXTURE(TestSuiteFixture,TestRunnerRunsOnlySpecifiedSuite)
242
 
{
243
 
        runner.RunTestsIf(list, "OtherSuite", True(), 0);
244
 
    CHECK_EQUAL(1, reporter.summaryTotalTestCount);
245
 
    CHECK_EQUAL("TestInOtherSuite", reporter.lastFinishedTest);
246
 
}
247
 
 
248
 
struct RunTestIfNameIs
249
 
{
250
 
        RunTestIfNameIs(char const* name_)
251
 
        : name(name_)
252
 
        {               
253
 
        }
254
 
        
255
 
        bool operator()(const Test* const test) const
256
 
        {
257
 
                using namespace std;
258
 
                return (0 == strcmp(test->m_details.testName, name));
259
 
        }
260
 
        
261
 
        char const* name;
262
 
};
263
 
 
264
 
TEST(TestMockPredicateBehavesCorrectly)
265
 
{
266
 
        RunTestIfNameIs predicate("pass");
267
 
        
268
 
        Test pass("pass");
269
 
        Test fail("fail");
270
 
        
271
 
        CHECK(predicate(&pass));
272
 
        CHECK(!predicate(&fail));       
273
 
}
274
 
 
275
 
TEST_FIXTURE(TestRunnerFixture, TestRunnerRunsTestsThatPassPredicate)
276
 
{
277
 
    Test should_run("goodtest");
278
 
    list.Add(&should_run);
279
 
 
280
 
    Test should_not_run("badtest");
281
 
        list.Add(&should_not_run);
282
 
 
283
 
        runner.RunTestsIf(list, NULL, RunTestIfNameIs("goodtest"), 0);
284
 
        CHECK_EQUAL(1, reporter.testRunCount);
285
 
    CHECK_EQUAL("goodtest", reporter.lastStartedTest);
286
 
}
287
 
 
288
 
TEST_FIXTURE(TestRunnerFixture, TestRunnerOnlyRunsTestsInSpecifiedSuiteAndThatPassPredicate)
289
 
{
290
 
    Test runningTest1("goodtest", "suite");
291
 
    Test skippedTest2("goodtest");
292
 
    Test skippedTest3("badtest", "suite");
293
 
    Test skippedTest4("badtest");
294
 
    
295
 
    list.Add(&runningTest1);
296
 
    list.Add(&skippedTest2);
297
 
    list.Add(&skippedTest3);
298
 
    list.Add(&skippedTest4);   
299
 
 
300
 
        runner.RunTestsIf(list, "suite", RunTestIfNameIs("goodtest"), 0);
301
 
 
302
 
        CHECK_EQUAL(1, reporter.testRunCount);
303
 
    CHECK_EQUAL("goodtest", reporter.lastStartedTest); 
304
 
    CHECK_EQUAL("suite", reporter.lastStartedSuite);    
305
 
}
306
 
 
307
 
}