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 // Tests the --gtest_repeat=number flag. 31 32 #include <stdlib.h> 33 34 #include <iostream> 35 36 #include "gtest/gtest.h" 37 #include "src/gtest-internal-inl.h" 38 39 namespace { 40 41 // We need this when we are testing Google Test itself and therefore 42 // cannot use Google Test assertions. 43 #define GTEST_CHECK_INT_EQ_(expected, actual) \ 44 do { \ 45 const int expected_val = (expected); \ 46 const int actual_val = (actual); \ 47 if (::testing::internal::IsTrue(expected_val != actual_val)) { \ 48 ::std::cout << "Value of: " #actual "\n" \ 49 << " Actual: " << actual_val << "\n" \ 50 << "Expected: " #expected "\n" \ 51 << "Which is: " << expected_val << "\n"; \ 52 ::testing::internal::posix::Abort(); \ 53 } \ 54 } while (::testing::internal::AlwaysFalse()) 55 56 // Used for verifying that global environment set-up and tear-down are 57 // inside the --gtest_repeat loop. 58 59 int g_environment_set_up_count = 0; 60 int g_environment_tear_down_count = 0; 61 62 class MyEnvironment : public testing::Environment { 63 public: 64 MyEnvironment() = default; 65 void SetUp() override { g_environment_set_up_count++; } 66 void TearDown() override { g_environment_tear_down_count++; } 67 }; 68 69 // A test that should fail. 70 71 int g_should_fail_count = 0; 72 73 TEST(FooTest, ShouldFail) { 74 g_should_fail_count++; 75 EXPECT_EQ(0, 1) << "Expected failure."; 76 } 77 78 // A test that should pass. 79 80 int g_should_pass_count = 0; 81 82 TEST(FooTest, ShouldPass) { g_should_pass_count++; } 83 84 // A test that contains a thread-safe death test and a fast death 85 // test. It should pass. 86 87 int g_death_test_count = 0; 88 89 TEST(BarDeathTest, ThreadSafeAndFast) { 90 g_death_test_count++; 91 92 GTEST_FLAG_SET(death_test_style, "threadsafe"); 93 EXPECT_DEATH_IF_SUPPORTED(::testing::internal::posix::Abort(), ""); 94 95 GTEST_FLAG_SET(death_test_style, "fast"); 96 EXPECT_DEATH_IF_SUPPORTED(::testing::internal::posix::Abort(), ""); 97 } 98 99 int g_param_test_count = 0; 100 101 const int kNumberOfParamTests = 10; 102 103 class MyParamTest : public testing::TestWithParam<int> {}; 104 105 TEST_P(MyParamTest, ShouldPass) { 106 GTEST_CHECK_INT_EQ_(g_param_test_count % kNumberOfParamTests, GetParam()); 107 g_param_test_count++; 108 } 109 INSTANTIATE_TEST_SUITE_P(MyParamSequence, MyParamTest, 110 testing::Range(0, kNumberOfParamTests)); 111 112 // Resets the count for each test. 113 void ResetCounts() { 114 g_environment_set_up_count = 0; 115 g_environment_tear_down_count = 0; 116 g_should_fail_count = 0; 117 g_should_pass_count = 0; 118 g_death_test_count = 0; 119 g_param_test_count = 0; 120 } 121 122 // Checks that the count for each test is expected. 123 void CheckCounts(int expected) { 124 GTEST_CHECK_INT_EQ_(expected, g_environment_set_up_count); 125 GTEST_CHECK_INT_EQ_(expected, g_environment_tear_down_count); 126 GTEST_CHECK_INT_EQ_(expected, g_should_fail_count); 127 GTEST_CHECK_INT_EQ_(expected, g_should_pass_count); 128 GTEST_CHECK_INT_EQ_(expected, g_death_test_count); 129 GTEST_CHECK_INT_EQ_(expected * kNumberOfParamTests, g_param_test_count); 130 } 131 132 // Tests the behavior of Google Test when --gtest_repeat is not specified. 133 void TestRepeatUnspecified() { 134 ResetCounts(); 135 GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS()); 136 CheckCounts(1); 137 } 138 139 // Tests the behavior of Google Test when --gtest_repeat has the given value. 140 void TestRepeat(int repeat) { 141 GTEST_FLAG_SET(repeat, repeat); 142 GTEST_FLAG_SET(recreate_environments_when_repeating, true); 143 144 ResetCounts(); 145 GTEST_CHECK_INT_EQ_(repeat > 0 ? 1 : 0, RUN_ALL_TESTS()); 146 CheckCounts(repeat); 147 } 148 149 // Tests using --gtest_repeat when --gtest_filter specifies an empty 150 // set of tests. 151 void TestRepeatWithEmptyFilter(int repeat) { 152 GTEST_FLAG_SET(repeat, repeat); 153 GTEST_FLAG_SET(recreate_environments_when_repeating, true); 154 GTEST_FLAG_SET(filter, "None"); 155 156 ResetCounts(); 157 GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS()); 158 CheckCounts(0); 159 } 160 161 // Tests using --gtest_repeat when --gtest_filter specifies a set of 162 // successful tests. 163 void TestRepeatWithFilterForSuccessfulTests(int repeat) { 164 GTEST_FLAG_SET(repeat, repeat); 165 GTEST_FLAG_SET(recreate_environments_when_repeating, true); 166 GTEST_FLAG_SET(filter, "*-*ShouldFail"); 167 168 ResetCounts(); 169 GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS()); 170 GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count); 171 GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count); 172 GTEST_CHECK_INT_EQ_(0, g_should_fail_count); 173 GTEST_CHECK_INT_EQ_(repeat, g_should_pass_count); 174 GTEST_CHECK_INT_EQ_(repeat, g_death_test_count); 175 GTEST_CHECK_INT_EQ_(repeat * kNumberOfParamTests, g_param_test_count); 176 } 177 178 // Tests using --gtest_repeat when --gtest_filter specifies a set of 179 // failed tests. 180 void TestRepeatWithFilterForFailedTests(int repeat) { 181 GTEST_FLAG_SET(repeat, repeat); 182 GTEST_FLAG_SET(recreate_environments_when_repeating, true); 183 GTEST_FLAG_SET(filter, "*ShouldFail"); 184 185 ResetCounts(); 186 GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS()); 187 GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count); 188 GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count); 189 GTEST_CHECK_INT_EQ_(repeat, g_should_fail_count); 190 GTEST_CHECK_INT_EQ_(0, g_should_pass_count); 191 GTEST_CHECK_INT_EQ_(0, g_death_test_count); 192 GTEST_CHECK_INT_EQ_(0, g_param_test_count); 193 } 194 195 } // namespace 196 197 int main(int argc, char **argv) { 198 testing::InitGoogleTest(&argc, argv); 199 200 testing::AddGlobalTestEnvironment(new MyEnvironment); 201 202 TestRepeatUnspecified(); 203 TestRepeat(0); 204 TestRepeat(1); 205 TestRepeat(5); 206 207 TestRepeatWithEmptyFilter(2); 208 TestRepeatWithEmptyFilter(3); 209 210 TestRepeatWithFilterForSuccessfulTests(3); 211 212 TestRepeatWithFilterForFailedTests(4); 213 214 // It would be nice to verify that the tests indeed loop forever 215 // when GTEST_FLAG(repeat) is negative, but this test will be quite 216 // complicated to write. Since this flag is for interactive 217 // debugging only and doesn't affect the normal test result, such a 218 // test would be an overkill. 219 220 printf("PASS\n"); 221 return 0; 222 } 223