1 // Copyright 2009 Google Inc. All rights reserved.
2 //
3 // Redistribution and use in source and binary forms, with or without
4 // modification, are permitted provided that the following conditions are
5 // met:
6 //
7 // * Redistributions of source code must retain the above copyright
8 // notice, this list of conditions and the following disclaimer.
9 // * Redistributions in binary form must reproduce the above
10 // copyright notice, this list of conditions and the following disclaimer
11 // in the documentation and/or other materials provided with the
12 // distribution.
13 // * Neither the name of Google Inc. nor the names of its
14 // contributors may be used to endorse or promote products derived from
15 // this software without specific prior written permission.
16 //
17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 //
29 // Author: vladl@google.com (Vlad Losev)
30 //
31 // The Google C++ Testing Framework (Google Test)
32 //
33 // This file verifies Google Test event listeners receive events at the
34 // right times.
35
36 #include "gtest/gtest.h"
37 #include <vector>
38
39 using ::testing::AddGlobalTestEnvironment;
40 using ::testing::Environment;
41 using ::testing::InitGoogleTest;
42 using ::testing::Test;
43 using ::testing::TestCase;
44 using ::testing::TestEventListener;
45 using ::testing::TestInfo;
46 using ::testing::TestPartResult;
47 using ::testing::UnitTest;
48 using ::testing::internal::String;
49
50 // Used by tests to register their events.
51 std::vector<String>* g_events = NULL;
52
53 namespace testing {
54 namespace internal {
55
56 class EventRecordingListener : public TestEventListener {
57 public:
EventRecordingListener(const char * name)58 EventRecordingListener(const char* name) : name_(name) {}
59
60 protected:
OnTestProgramStart(const UnitTest &)61 virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
62 g_events->push_back(GetFullMethodName("OnTestProgramStart"));
63 }
64
OnTestIterationStart(const UnitTest &,int iteration)65 virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
66 int iteration) {
67 Message message;
68 message << GetFullMethodName("OnTestIterationStart")
69 << "(" << iteration << ")";
70 g_events->push_back(message.GetString());
71 }
72
OnEnvironmentsSetUpStart(const UnitTest &)73 virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {
74 g_events->push_back(GetFullMethodName("OnEnvironmentsSetUpStart"));
75 }
76
OnEnvironmentsSetUpEnd(const UnitTest &)77 virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {
78 g_events->push_back(GetFullMethodName("OnEnvironmentsSetUpEnd"));
79 }
80
OnTestCaseStart(const TestCase &)81 virtual void OnTestCaseStart(const TestCase& /*test_case*/) {
82 g_events->push_back(GetFullMethodName("OnTestCaseStart"));
83 }
84
OnTestStart(const TestInfo &)85 virtual void OnTestStart(const TestInfo& /*test_info*/) {
86 g_events->push_back(GetFullMethodName("OnTestStart"));
87 }
88
OnTestPartResult(const TestPartResult &)89 virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {
90 g_events->push_back(GetFullMethodName("OnTestPartResult"));
91 }
92
OnTestEnd(const TestInfo &)93 virtual void OnTestEnd(const TestInfo& /*test_info*/) {
94 g_events->push_back(GetFullMethodName("OnTestEnd"));
95 }
96
OnTestCaseEnd(const TestCase &)97 virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {
98 g_events->push_back(GetFullMethodName("OnTestCaseEnd"));
99 }
100
OnEnvironmentsTearDownStart(const UnitTest &)101 virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {
102 g_events->push_back(GetFullMethodName("OnEnvironmentsTearDownStart"));
103 }
104
OnEnvironmentsTearDownEnd(const UnitTest &)105 virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {
106 g_events->push_back(GetFullMethodName("OnEnvironmentsTearDownEnd"));
107 }
108
OnTestIterationEnd(const UnitTest &,int iteration)109 virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
110 int iteration) {
111 Message message;
112 message << GetFullMethodName("OnTestIterationEnd")
113 << "(" << iteration << ")";
114 g_events->push_back(message.GetString());
115 }
116
OnTestProgramEnd(const UnitTest &)117 virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {
118 g_events->push_back(GetFullMethodName("OnTestProgramEnd"));
119 }
120
121 private:
GetFullMethodName(const char * name)122 String GetFullMethodName(const char* name) {
123 Message message;
124 message << name_ << "." << name;
125 return message.GetString();
126 }
127
128 String name_;
129 };
130
131 class EnvironmentInvocationCatcher : public Environment {
132 protected:
SetUp()133 virtual void SetUp() {
134 g_events->push_back(String("Environment::SetUp"));
135 }
136
TearDown()137 virtual void TearDown() {
138 g_events->push_back(String("Environment::TearDown"));
139 }
140 };
141
142 class ListenerTest : public Test {
143 protected:
SetUpTestCase()144 static void SetUpTestCase() {
145 g_events->push_back(String("ListenerTest::SetUpTestCase"));
146 }
147
TearDownTestCase()148 static void TearDownTestCase() {
149 g_events->push_back(String("ListenerTest::TearDownTestCase"));
150 }
151
SetUp()152 virtual void SetUp() {
153 g_events->push_back(String("ListenerTest::SetUp"));
154 }
155
TearDown()156 virtual void TearDown() {
157 g_events->push_back(String("ListenerTest::TearDown"));
158 }
159 };
160
TEST_F(ListenerTest,DoesFoo)161 TEST_F(ListenerTest, DoesFoo) {
162 // Test execution order within a test case is not guaranteed so we are not
163 // recording the test name.
164 g_events->push_back(String("ListenerTest::* Test Body"));
165 SUCCEED(); // Triggers OnTestPartResult.
166 }
167
TEST_F(ListenerTest,DoesBar)168 TEST_F(ListenerTest, DoesBar) {
169 g_events->push_back(String("ListenerTest::* Test Body"));
170 SUCCEED(); // Triggers OnTestPartResult.
171 }
172
173 } // namespace internal
174
175 } // namespace testing
176
177 using ::testing::internal::EnvironmentInvocationCatcher;
178 using ::testing::internal::EventRecordingListener;
179
VerifyResults(const std::vector<String> & data,const char * const * expected_data,int expected_data_size)180 void VerifyResults(const std::vector<String>& data,
181 const char* const* expected_data,
182 int expected_data_size) {
183 const int actual_size = data.size();
184 // If the following assertion fails, a new entry will be appended to
185 // data. Hence we save data.size() first.
186 EXPECT_EQ(expected_data_size, actual_size);
187
188 // Compares the common prefix.
189 const int shorter_size = expected_data_size <= actual_size ?
190 expected_data_size : actual_size;
191 int i = 0;
192 for (; i < shorter_size; ++i) {
193 ASSERT_STREQ(expected_data[i], data[i].c_str())
194 << "at position " << i;
195 }
196
197 // Prints extra elements in the actual data.
198 for (; i < actual_size; ++i) {
199 printf(" Actual event #%d: %s\n", i, data[i].c_str());
200 }
201 }
202
main(int argc,char ** argv)203 int main(int argc, char **argv) {
204 std::vector<String> events;
205 g_events = &events;
206 InitGoogleTest(&argc, argv);
207
208 UnitTest::GetInstance()->listeners().Append(
209 new EventRecordingListener("1st"));
210 UnitTest::GetInstance()->listeners().Append(
211 new EventRecordingListener("2nd"));
212
213 AddGlobalTestEnvironment(new EnvironmentInvocationCatcher);
214
215 GTEST_CHECK_(events.size() == 0)
216 << "AddGlobalTestEnvironment should not generate any events itself.";
217
218 ::testing::GTEST_FLAG(repeat) = 2;
219 int ret_val = RUN_ALL_TESTS();
220
221 const char* const expected_events[] = {
222 "1st.OnTestProgramStart",
223 "2nd.OnTestProgramStart",
224 "1st.OnTestIterationStart(0)",
225 "2nd.OnTestIterationStart(0)",
226 "1st.OnEnvironmentsSetUpStart",
227 "2nd.OnEnvironmentsSetUpStart",
228 "Environment::SetUp",
229 "2nd.OnEnvironmentsSetUpEnd",
230 "1st.OnEnvironmentsSetUpEnd",
231 "1st.OnTestCaseStart",
232 "2nd.OnTestCaseStart",
233 "ListenerTest::SetUpTestCase",
234 "1st.OnTestStart",
235 "2nd.OnTestStart",
236 "ListenerTest::SetUp",
237 "ListenerTest::* Test Body",
238 "1st.OnTestPartResult",
239 "2nd.OnTestPartResult",
240 "ListenerTest::TearDown",
241 "2nd.OnTestEnd",
242 "1st.OnTestEnd",
243 "1st.OnTestStart",
244 "2nd.OnTestStart",
245 "ListenerTest::SetUp",
246 "ListenerTest::* Test Body",
247 "1st.OnTestPartResult",
248 "2nd.OnTestPartResult",
249 "ListenerTest::TearDown",
250 "2nd.OnTestEnd",
251 "1st.OnTestEnd",
252 "ListenerTest::TearDownTestCase",
253 "2nd.OnTestCaseEnd",
254 "1st.OnTestCaseEnd",
255 "1st.OnEnvironmentsTearDownStart",
256 "2nd.OnEnvironmentsTearDownStart",
257 "Environment::TearDown",
258 "2nd.OnEnvironmentsTearDownEnd",
259 "1st.OnEnvironmentsTearDownEnd",
260 "2nd.OnTestIterationEnd(0)",
261 "1st.OnTestIterationEnd(0)",
262 "1st.OnTestIterationStart(1)",
263 "2nd.OnTestIterationStart(1)",
264 "1st.OnEnvironmentsSetUpStart",
265 "2nd.OnEnvironmentsSetUpStart",
266 "Environment::SetUp",
267 "2nd.OnEnvironmentsSetUpEnd",
268 "1st.OnEnvironmentsSetUpEnd",
269 "1st.OnTestCaseStart",
270 "2nd.OnTestCaseStart",
271 "ListenerTest::SetUpTestCase",
272 "1st.OnTestStart",
273 "2nd.OnTestStart",
274 "ListenerTest::SetUp",
275 "ListenerTest::* Test Body",
276 "1st.OnTestPartResult",
277 "2nd.OnTestPartResult",
278 "ListenerTest::TearDown",
279 "2nd.OnTestEnd",
280 "1st.OnTestEnd",
281 "1st.OnTestStart",
282 "2nd.OnTestStart",
283 "ListenerTest::SetUp",
284 "ListenerTest::* Test Body",
285 "1st.OnTestPartResult",
286 "2nd.OnTestPartResult",
287 "ListenerTest::TearDown",
288 "2nd.OnTestEnd",
289 "1st.OnTestEnd",
290 "ListenerTest::TearDownTestCase",
291 "2nd.OnTestCaseEnd",
292 "1st.OnTestCaseEnd",
293 "1st.OnEnvironmentsTearDownStart",
294 "2nd.OnEnvironmentsTearDownStart",
295 "Environment::TearDown",
296 "2nd.OnEnvironmentsTearDownEnd",
297 "1st.OnEnvironmentsTearDownEnd",
298 "2nd.OnTestIterationEnd(1)",
299 "1st.OnTestIterationEnd(1)",
300 "2nd.OnTestProgramEnd",
301 "1st.OnTestProgramEnd"
302 };
303 VerifyResults(events,
304 expected_events,
305 sizeof(expected_events)/sizeof(expected_events[0]));
306
307 // We need to check manually for ad hoc test failures that happen after
308 // RUN_ALL_TESTS finishes.
309 if (UnitTest::GetInstance()->Failed())
310 ret_val = 1;
311
312 return ret_val;
313 }
314