blob: 05929e33ad2d36281e13a4eccff84c0065e6b0f7 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
/**
* @file chained_callback.h
* @author Nat Goodspeed
* @date 2020-01-03
* @brief Subclass of tut::callback used for chaining callbacks.
*
* $LicenseInfo:firstyear=2020&license=viewerlgpl$
* Copyright (c) 2020, Linden Research, Inc.
* $/LicenseInfo$
*/
#if ! defined(LL_CHAINED_CALLBACK_H)
#define LL_CHAINED_CALLBACK_H
#include "lltut.h"
/**
* Derive your TUT callback from chained_callback instead of tut::callback to
* ensure that multiple such callbacks can coexist in a given test executable.
* The relevant callback method will be called for each callback instance in
* reverse order of the instance's link() methods being called: the most
* recently link()ed callback will be called first, then the previous, and so
* forth.
*
* Obviously, for this to work, all relevant callbacks must be derived from
* chained_callback instead of tut::callback. Given that, control should reach
* each of them regardless of their construction order. The chain is
* guaranteed to stop because the first link() call will link to test_runner's
* default_callback, which is simply an instance of the callback() base class.
*
* The rule for deriving from chained_callback is that you may override any of
* its virtual methods, but your override must at some point call the
* corresponding chained_callback method.
*/
class chained_callback: public tut::callback
{
public:
/**
* Instead of calling tut::test_runner::set_callback(&your_callback), call
* your_callback.link();
* This uses the canonical instance of tut::test_runner.
*/
void link()
{
link(tut::runner.get());
}
/**
* If for some reason you have a different instance of test_runner...
*/
void link(tut::test_runner& runner)
{
// Since test_runner's constructor sets a default callback,
// get_callback() will always return a reference to a valid callback
// instance.
mPrev = &runner.get_callback();
runner.set_callback(this);
}
/**
* Called when new test run started.
*/
virtual void run_started()
{
mPrev->run_started();
}
/**
* Called when a group started
* @param name Name of the group
*/
virtual void group_started(const std::string& name)
{
mPrev->group_started(name);
}
/**
* Called when a test finished.
* @param tr Test results.
*/
virtual void test_completed(const tut::test_result& tr)
{
mPrev->test_completed(tr);
}
/**
* Called when a group is completed
* @param name Name of the group
*/
virtual void group_completed(const std::string& name)
{
mPrev->group_completed(name);
}
/**
* Called when all tests in run completed.
*/
virtual void run_completed()
{
mPrev->run_completed();
}
private:
tut::callback* mPrev;
};
#endif /* ! defined(LL_CHAINED_CALLBACK_H) */
|
