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//
30// The Google C++ Testing and Mocking Framework (Google Test)
31//
32// This file verifies Google Test event listeners receive events at the
33// right times.
34
35#include <vector>
36
37#include "gtest/gtest.h"
38
39using ::testing::AddGlobalTestEnvironment;
40using ::testing::Environment;
41using ::testing::InitGoogleTest;
42using ::testing::Test;
43using ::testing::TestCase;
44using ::testing::TestEventListener;
45using ::testing::TestInfo;
46using ::testing::TestPartResult;
47using ::testing::UnitTest;
48
49// Used by tests to register their events.
50std::vector<std::string>* g_events = NULL;
51
52namespace testing {
53namespace internal {
54
55class EventRecordingListener : public TestEventListener {
56 public:
57  explicit EventRecordingListener(const char* name) : name_(name) {}
58
59 protected:
60  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
61    g_events->push_back(GetFullMethodName("OnTestProgramStart"));
62  }
63
64  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
65                                    int iteration) {
66    Message message;
67    message << GetFullMethodName("OnTestIterationStart")
68            << "(" << iteration << ")";
69    g_events->push_back(message.GetString());
70  }
71
72  virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {
73    g_events->push_back(GetFullMethodName("OnEnvironmentsSetUpStart"));
74  }
75
76  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {
77    g_events->push_back(GetFullMethodName("OnEnvironmentsSetUpEnd"));
78  }
79
80  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {
81    g_events->push_back(GetFullMethodName("OnTestCaseStart"));
82  }
83
84  virtual void OnTestStart(const TestInfo& /*test_info*/) {
85    g_events->push_back(GetFullMethodName("OnTestStart"));
86  }
87
88  virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {
89    g_events->push_back(GetFullMethodName("OnTestPartResult"));
90  }
91
92  virtual void OnTestEnd(const TestInfo& /*test_info*/) {
93    g_events->push_back(GetFullMethodName("OnTestEnd"));
94  }
95
96  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {
97    g_events->push_back(GetFullMethodName("OnTestCaseEnd"));
98  }
99
100  virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {
101    g_events->push_back(GetFullMethodName("OnEnvironmentsTearDownStart"));
102  }
103
104  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {
105    g_events->push_back(GetFullMethodName("OnEnvironmentsTearDownEnd"));
106  }
107
108  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
109                                  int iteration) {
110    Message message;
111    message << GetFullMethodName("OnTestIterationEnd")
112            << "("  << iteration << ")";
113    g_events->push_back(message.GetString());
114  }
115
116  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {
117    g_events->push_back(GetFullMethodName("OnTestProgramEnd"));
118  }
119
120 private:
121  std::string GetFullMethodName(const char* name) {
122    return name_ + "." + name;
123  }
124
125  std::string name_;
126};
127
128class EnvironmentInvocationCatcher : public Environment {
129 protected:
130  virtual void SetUp() {
131    g_events->push_back("Environment::SetUp");
132  }
133
134  virtual void TearDown() {
135    g_events->push_back("Environment::TearDown");
136  }
137};
138
139class ListenerTest : public Test {
140 protected:
141  static void SetUpTestCase() {
142    g_events->push_back("ListenerTest::SetUpTestCase");
143  }
144
145  static void TearDownTestCase() {
146    g_events->push_back("ListenerTest::TearDownTestCase");
147  }
148
149  virtual void SetUp() {
150    g_events->push_back("ListenerTest::SetUp");
151  }
152
153  virtual void TearDown() {
154    g_events->push_back("ListenerTest::TearDown");
155  }
156};
157
158TEST_F(ListenerTest, DoesFoo) {
159  // Test execution order within a test case is not guaranteed so we are not
160  // recording the test name.
161  g_events->push_back("ListenerTest::* Test Body");
162  SUCCEED();  // Triggers OnTestPartResult.
163}
164
165TEST_F(ListenerTest, DoesBar) {
166  g_events->push_back("ListenerTest::* Test Body");
167  SUCCEED();  // Triggers OnTestPartResult.
168}
169
170}  // namespace internal
171
172}  // namespace testing
173
174using ::testing::internal::EnvironmentInvocationCatcher;
175using ::testing::internal::EventRecordingListener;
176
177void VerifyResults(const std::vector<std::string>& data,
178                   const char* const* expected_data,
179                   size_t expected_data_size) {
180  const size_t actual_size = data.size();
181  // If the following assertion fails, a new entry will be appended to
182  // data.  Hence we save data.size() first.
183  EXPECT_EQ(expected_data_size, actual_size);
184
185  // Compares the common prefix.
186  const size_t shorter_size = expected_data_size <= actual_size ?
187      expected_data_size : actual_size;
188  size_t i = 0;
189  for (; i < shorter_size; ++i) {
190    ASSERT_STREQ(expected_data[i], data[i].c_str())
191        << "at position " << i;
192  }
193
194  // Prints extra elements in the actual data.
195  for (; i < actual_size; ++i) {
196    printf("  Actual event #%lu: %s\n",
197        static_cast<unsigned long>(i), data[i].c_str());
198  }
199}
200
201int main(int argc, char **argv) {
202  std::vector<std::string> events;
203  g_events = &events;
204  InitGoogleTest(&argc, argv);
205
206  UnitTest::GetInstance()->listeners().Append(
207      new EventRecordingListener("1st"));
208  UnitTest::GetInstance()->listeners().Append(
209      new EventRecordingListener("2nd"));
210
211  AddGlobalTestEnvironment(new EnvironmentInvocationCatcher);
212
213  GTEST_CHECK_(events.size() == 0)
214      << "AddGlobalTestEnvironment should not generate any events itself.";
215
216  ::testing::GTEST_FLAG(repeat) = 2;
217  int ret_val = RUN_ALL_TESTS();
218
219  const char* const expected_events[] = {
220    "1st.OnTestProgramStart",
221    "2nd.OnTestProgramStart",
222    "1st.OnTestIterationStart(0)",
223    "2nd.OnTestIterationStart(0)",
224    "1st.OnEnvironmentsSetUpStart",
225    "2nd.OnEnvironmentsSetUpStart",
226    "Environment::SetUp",
227    "2nd.OnEnvironmentsSetUpEnd",
228    "1st.OnEnvironmentsSetUpEnd",
229    "1st.OnTestCaseStart",
230    "2nd.OnTestCaseStart",
231    "ListenerTest::SetUpTestCase",
232    "1st.OnTestStart",
233    "2nd.OnTestStart",
234    "ListenerTest::SetUp",
235    "ListenerTest::* Test Body",
236    "1st.OnTestPartResult",
237    "2nd.OnTestPartResult",
238    "ListenerTest::TearDown",
239    "2nd.OnTestEnd",
240    "1st.OnTestEnd",
241    "1st.OnTestStart",
242    "2nd.OnTestStart",
243    "ListenerTest::SetUp",
244    "ListenerTest::* Test Body",
245    "1st.OnTestPartResult",
246    "2nd.OnTestPartResult",
247    "ListenerTest::TearDown",
248    "2nd.OnTestEnd",
249    "1st.OnTestEnd",
250    "ListenerTest::TearDownTestCase",
251    "2nd.OnTestCaseEnd",
252    "1st.OnTestCaseEnd",
253    "1st.OnEnvironmentsTearDownStart",
254    "2nd.OnEnvironmentsTearDownStart",
255    "Environment::TearDown",
256    "2nd.OnEnvironmentsTearDownEnd",
257    "1st.OnEnvironmentsTearDownEnd",
258    "2nd.OnTestIterationEnd(0)",
259    "1st.OnTestIterationEnd(0)",
260    "1st.OnTestIterationStart(1)",
261    "2nd.OnTestIterationStart(1)",
262    "1st.OnEnvironmentsSetUpStart",
263    "2nd.OnEnvironmentsSetUpStart",
264    "Environment::SetUp",
265    "2nd.OnEnvironmentsSetUpEnd",
266    "1st.OnEnvironmentsSetUpEnd",
267    "1st.OnTestCaseStart",
268    "2nd.OnTestCaseStart",
269    "ListenerTest::SetUpTestCase",
270    "1st.OnTestStart",
271    "2nd.OnTestStart",
272    "ListenerTest::SetUp",
273    "ListenerTest::* Test Body",
274    "1st.OnTestPartResult",
275    "2nd.OnTestPartResult",
276    "ListenerTest::TearDown",
277    "2nd.OnTestEnd",
278    "1st.OnTestEnd",
279    "1st.OnTestStart",
280    "2nd.OnTestStart",
281    "ListenerTest::SetUp",
282    "ListenerTest::* Test Body",
283    "1st.OnTestPartResult",
284    "2nd.OnTestPartResult",
285    "ListenerTest::TearDown",
286    "2nd.OnTestEnd",
287    "1st.OnTestEnd",
288    "ListenerTest::TearDownTestCase",
289    "2nd.OnTestCaseEnd",
290    "1st.OnTestCaseEnd",
291    "1st.OnEnvironmentsTearDownStart",
292    "2nd.OnEnvironmentsTearDownStart",
293    "Environment::TearDown",
294    "2nd.OnEnvironmentsTearDownEnd",
295    "1st.OnEnvironmentsTearDownEnd",
296    "2nd.OnTestIterationEnd(1)",
297    "1st.OnTestIterationEnd(1)",
298    "2nd.OnTestProgramEnd",
299    "1st.OnTestProgramEnd"
300  };
301  VerifyResults(events,
302                expected_events,
303                sizeof(expected_events)/sizeof(expected_events[0]));
304
305  // We need to check manually for ad hoc test failures that happen after
306  // RUN_ALL_TESTS finishes.
307  if (UnitTest::GetInstance()->Failed())
308    ret_val = 1;
309
310  return ret_val;
311}
312