Home | History | Annotate | Download | only in test
      1 // Copyright 2008, Google Inc.
      2 // All rights reserved.
      3 //
      4 // Redistribution and use in source and binary forms, with or without
      5 // modification, are permitted provided that the following conditions are
      6 // met:
      7 //
      8 //     * Redistributions of source code must retain the above copyright
      9 // notice, this list of conditions and the following disclaimer.
     10 //     * Redistributions in binary form must reproduce the above
     11 // copyright notice, this list of conditions and the following disclaimer
     12 // in the documentation and/or other materials provided with the
     13 // distribution.
     14 //     * Neither the name of Google Inc. nor the names of its
     15 // contributors may be used to endorse or promote products derived from
     16 // this software without specific prior written permission.
     17 //
     18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     29 //
     30 // Author: wan (at) google.com (Zhanyong Wan)
     31 
     32 // Tests the --gtest_repeat=number flag.
     33 
     34 #include <stdlib.h>
     35 #include <iostream>
     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"
     45 #undef GTEST_IMPLEMENTATION_
     46 
     47 namespace testing {
     48 
     49 GTEST_DECLARE_string_(death_test_style);
     50 GTEST_DECLARE_string_(filter);
     51 GTEST_DECLARE_int32_(repeat);
     52 
     53 }  // namespace testing
     54 
     55 using testing::GTEST_FLAG(death_test_style);
     56 using testing::GTEST_FLAG(filter);
     57 using testing::GTEST_FLAG(repeat);
     58 
     59 namespace {
     60 
     61 // We need this when we are testing Google Test itself and therefore
     62 // cannot use Google Test assertions.
     63 #define GTEST_CHECK_INT_EQ_(expected, actual) \
     64   do {\
     65     const int expected_val = (expected);\
     66     const int actual_val = (actual);\
     67     if (::testing::internal::IsTrue(expected_val != actual_val)) {\
     68       ::std::cout << "Value of: " #actual "\n"\
     69                   << "  Actual: " << actual_val << "\n"\
     70                   << "Expected: " #expected "\n"\
     71                   << "Which is: " << expected_val << "\n";\
     72       abort();\
     73     }\
     74   } while(::testing::internal::AlwaysFalse())
     75 
     76 
     77 // Used for verifying that global environment set-up and tear-down are
     78 // inside the gtest_repeat loop.
     79 
     80 int g_environment_set_up_count = 0;
     81 int g_environment_tear_down_count = 0;
     82 
     83 class MyEnvironment : public testing::Environment {
     84  public:
     85   MyEnvironment() {}
     86   virtual void SetUp() { g_environment_set_up_count++; }
     87   virtual void TearDown() { g_environment_tear_down_count++; }
     88 };
     89 
     90 // A test that should fail.
     91 
     92 int g_should_fail_count = 0;
     93 
     94 TEST(FooTest, ShouldFail) {
     95   g_should_fail_count++;
     96   EXPECT_EQ(0, 1) << "Expected failure.";
     97 }
     98 
     99 // A test that should pass.
    100 
    101 int g_should_pass_count = 0;
    102 
    103 TEST(FooTest, ShouldPass) {
    104   g_should_pass_count++;
    105 }
    106 
    107 // A test that contains a thread-safe death test and a fast death
    108 // test.  It should pass.
    109 
    110 int g_death_test_count = 0;
    111 
    112 TEST(BarDeathTest, ThreadSafeAndFast) {
    113   g_death_test_count++;
    114 
    115   GTEST_FLAG(death_test_style) = "threadsafe";
    116   EXPECT_DEATH_IF_SUPPORTED(abort(), "");
    117 
    118   GTEST_FLAG(death_test_style) = "fast";
    119   EXPECT_DEATH_IF_SUPPORTED(abort(), "");
    120 }
    121 
    122 #if GTEST_HAS_PARAM_TEST
    123 int g_param_test_count = 0;
    124 
    125 const int kNumberOfParamTests = 10;
    126 
    127 class MyParamTest : public testing::TestWithParam<int> {};
    128 
    129 TEST_P(MyParamTest, ShouldPass) {
    130   // TODO(vladl (at) google.com): Make parameter value checking robust
    131   //                         WRT order of tests.
    132   GTEST_CHECK_INT_EQ_(g_param_test_count % kNumberOfParamTests, GetParam());
    133   g_param_test_count++;
    134 }
    135 INSTANTIATE_TEST_CASE_P(MyParamSequence,
    136                         MyParamTest,
    137                         testing::Range(0, kNumberOfParamTests));
    138 #endif  // GTEST_HAS_PARAM_TEST
    139 
    140 // Resets the count for each test.
    141 void ResetCounts() {
    142   g_environment_set_up_count = 0;
    143   g_environment_tear_down_count = 0;
    144   g_should_fail_count = 0;
    145   g_should_pass_count = 0;
    146   g_death_test_count = 0;
    147 #if GTEST_HAS_PARAM_TEST
    148   g_param_test_count = 0;
    149 #endif  // GTEST_HAS_PARAM_TEST
    150 }
    151 
    152 // Checks that the count for each test is expected.
    153 void CheckCounts(int expected) {
    154   GTEST_CHECK_INT_EQ_(expected, g_environment_set_up_count);
    155   GTEST_CHECK_INT_EQ_(expected, g_environment_tear_down_count);
    156   GTEST_CHECK_INT_EQ_(expected, g_should_fail_count);
    157   GTEST_CHECK_INT_EQ_(expected, g_should_pass_count);
    158   GTEST_CHECK_INT_EQ_(expected, g_death_test_count);
    159 #if GTEST_HAS_PARAM_TEST
    160   GTEST_CHECK_INT_EQ_(expected * kNumberOfParamTests, g_param_test_count);
    161 #endif  // GTEST_HAS_PARAM_TEST
    162 }
    163 
    164 // Tests the behavior of Google Test when --gtest_repeat is not specified.
    165 void TestRepeatUnspecified() {
    166   ResetCounts();
    167   GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS());
    168   CheckCounts(1);
    169 }
    170 
    171 // Tests the behavior of Google Test when --gtest_repeat has the given value.
    172 void TestRepeat(int repeat) {
    173   GTEST_FLAG(repeat) = repeat;
    174 
    175   ResetCounts();
    176   GTEST_CHECK_INT_EQ_(repeat > 0 ? 1 : 0, RUN_ALL_TESTS());
    177   CheckCounts(repeat);
    178 }
    179 
    180 // Tests using --gtest_repeat when --gtest_filter specifies an empty
    181 // set of tests.
    182 void TestRepeatWithEmptyFilter(int repeat) {
    183   GTEST_FLAG(repeat) = repeat;
    184   GTEST_FLAG(filter) = "None";
    185 
    186   ResetCounts();
    187   GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS());
    188   CheckCounts(0);
    189 }
    190 
    191 // Tests using --gtest_repeat when --gtest_filter specifies a set of
    192 // successful tests.
    193 void TestRepeatWithFilterForSuccessfulTests(int repeat) {
    194   GTEST_FLAG(repeat) = repeat;
    195   GTEST_FLAG(filter) = "*-*ShouldFail";
    196 
    197   ResetCounts();
    198   GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS());
    199   GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count);
    200   GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count);
    201   GTEST_CHECK_INT_EQ_(0, g_should_fail_count);
    202   GTEST_CHECK_INT_EQ_(repeat, g_should_pass_count);
    203   GTEST_CHECK_INT_EQ_(repeat, g_death_test_count);
    204 #if GTEST_HAS_PARAM_TEST
    205   GTEST_CHECK_INT_EQ_(repeat * kNumberOfParamTests, g_param_test_count);
    206 #endif  // GTEST_HAS_PARAM_TEST
    207 }
    208 
    209 // Tests using --gtest_repeat when --gtest_filter specifies a set of
    210 // failed tests.
    211 void TestRepeatWithFilterForFailedTests(int repeat) {
    212   GTEST_FLAG(repeat) = repeat;
    213   GTEST_FLAG(filter) = "*ShouldFail";
    214 
    215   ResetCounts();
    216   GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS());
    217   GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count);
    218   GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count);
    219   GTEST_CHECK_INT_EQ_(repeat, g_should_fail_count);
    220   GTEST_CHECK_INT_EQ_(0, g_should_pass_count);
    221   GTEST_CHECK_INT_EQ_(0, g_death_test_count);
    222 #if GTEST_HAS_PARAM_TEST
    223   GTEST_CHECK_INT_EQ_(0, g_param_test_count);
    224 #endif  // GTEST_HAS_PARAM_TEST
    225 }
    226 
    227 }  // namespace
    228 
    229 int main(int argc, char **argv) {
    230   testing::InitGoogleTest(&argc, argv);
    231   testing::AddGlobalTestEnvironment(new MyEnvironment);
    232 
    233   TestRepeatUnspecified();
    234   TestRepeat(0);
    235   TestRepeat(1);
    236   TestRepeat(5);
    237 
    238   TestRepeatWithEmptyFilter(2);
    239   TestRepeatWithEmptyFilter(3);
    240 
    241   TestRepeatWithFilterForSuccessfulTests(3);
    242 
    243   TestRepeatWithFilterForFailedTests(4);
    244 
    245   // It would be nice to verify that the tests indeed loop forever
    246   // when GTEST_FLAG(repeat) is negative, but this test will be quite
    247   // complicated to write.  Since this flag is for interactive
    248   // debugging only and doesn't affect the normal test result, such a
    249   // test would be an overkill.
    250 
    251   printf("PASS\n");
    252   return 0;
    253 }
    254