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