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
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;
48using ::testing::internal::String;
49
50// Used by tests to register their events.
51std::vector<String>* g_events = NULL;
52
53namespace testing {
54namespace internal {
55
56class EventRecordingListener : public TestEventListener {
57 public:
58  EventRecordingListener(const char* name) : name_(name) {}
59
60 protected:
61  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {
62    g_events->push_back(GetFullMethodName("OnTestProgramStart"));
63  }
64
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
73  virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {
74    g_events->push_back(GetFullMethodName("OnEnvironmentsSetUpStart"));
75  }
76
77  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {
78    g_events->push_back(GetFullMethodName("OnEnvironmentsSetUpEnd"));
79  }
80
81  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {
82    g_events->push_back(GetFullMethodName("OnTestCaseStart"));
83  }
84
85  virtual void OnTestStart(const TestInfo& /*test_info*/) {
86    g_events->push_back(GetFullMethodName("OnTestStart"));
87  }
88
89  virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {
90    g_events->push_back(GetFullMethodName("OnTestPartResult"));
91  }
92
93  virtual void OnTestEnd(const TestInfo& /*test_info*/) {
94    g_events->push_back(GetFullMethodName("OnTestEnd"));
95  }
96
97  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {
98    g_events->push_back(GetFullMethodName("OnTestCaseEnd"));
99  }
100
101  virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {
102    g_events->push_back(GetFullMethodName("OnEnvironmentsTearDownStart"));
103  }
104
105  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {
106    g_events->push_back(GetFullMethodName("OnEnvironmentsTearDownEnd"));
107  }
108
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
117  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {
118    g_events->push_back(GetFullMethodName("OnTestProgramEnd"));
119  }
120
121 private:
122  String GetFullMethodName(const char* name) {
123    Message message;
124    message << name_ << "." << name;
125    return message.GetString();
126  }
127
128  String name_;
129};
130
131class EnvironmentInvocationCatcher : public Environment {
132 protected:
133  virtual void SetUp() {
134    g_events->push_back(String("Environment::SetUp"));
135  }
136
137  virtual void TearDown() {
138    g_events->push_back(String("Environment::TearDown"));
139  }
140};
141
142class ListenerTest : public Test {
143 protected:
144  static void SetUpTestCase() {
145    g_events->push_back(String("ListenerTest::SetUpTestCase"));
146  }
147
148  static void TearDownTestCase() {
149    g_events->push_back(String("ListenerTest::TearDownTestCase"));
150  }
151
152  virtual void SetUp() {
153    g_events->push_back(String("ListenerTest::SetUp"));
154  }
155
156  virtual void TearDown() {
157    g_events->push_back(String("ListenerTest::TearDown"));
158  }
159};
160
161TEST_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
168TEST_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
177using ::testing::internal::EnvironmentInvocationCatcher;
178using ::testing::internal::EventRecordingListener;
179
180void 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
203int 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