Home | History | Annotate | Download | only in test 
      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 
     49 // Used by tests to register their events.
     50 std::vector<std::string>* g_events = NULL;
     51 
     52 namespace testing {
     53 namespace internal {
     54 
     55 class 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 
    128 class 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 
    139 class 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 
    158 TEST_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 
    165 TEST_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 
    174 using ::testing::internal::EnvironmentInvocationCatcher;
    175 using ::testing::internal::EventRecordingListener;
    176 
    177 void 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 
    201 int 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