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 (at) 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: 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 131 class 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 142 class 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 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 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 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 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