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 
     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 
     47 using ::testing::AddGlobalTestEnvironment;
     48 using ::testing::Environment;
     49 using ::testing::InitGoogleTest;
     50 using ::testing::Test;
     51 using ::testing::TestCase;
     52 using ::testing::TestEventListener;
     53 using ::testing::TestInfo;
     54 using ::testing::TestPartResult;
     55 using ::testing::UnitTest;
     56 using ::testing::internal::String;
     57 using ::testing::internal::Vector;
     58 
     59 // Used by tests to register their events.
     60 Vector<String>* g_events = NULL;
     61 
     62 namespace testing {
     63 namespace internal {
     64 
     65 class 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 
    140 class 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 
    151 class 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 
    170 TEST_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 
    177 TEST_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 
    186 using ::testing::internal::EnvironmentInvocationCatcher;
    187 using ::testing::internal::EventRecordingListener;
    188 
    189 void 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 
    212 int 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