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