]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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. | |
9f95a23c | 29 | |
7c673cae FG |
30 | |
31 | // Tests the --gtest_repeat=number flag. | |
32 | ||
33 | #include <stdlib.h> | |
34 | #include <iostream> | |
35 | #include "gtest/gtest.h" | |
7c673cae | 36 | #include "src/gtest-internal-inl.h" |
7c673cae FG |
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 | |
9f95a23c | 69 | // inside the --gtest_repeat loop. |
7c673cae FG |
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() {} | |
9f95a23c TL |
77 | void SetUp() override { g_environment_set_up_count++; } |
78 | void TearDown() override { g_environment_tear_down_count++; } | |
7c673cae FG |
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 | ||
7c673cae FG |
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) { | |
7c673cae FG |
120 | GTEST_CHECK_INT_EQ_(g_param_test_count % kNumberOfParamTests, GetParam()); |
121 | g_param_test_count++; | |
122 | } | |
9f95a23c TL |
123 | INSTANTIATE_TEST_SUITE_P(MyParamSequence, |
124 | MyParamTest, | |
125 | testing::Range(0, kNumberOfParamTests)); | |
7c673cae FG |
126 | |
127 | // Resets the count for each test. | |
128 | void ResetCounts() { | |
129 | g_environment_set_up_count = 0; | |
130 | g_environment_tear_down_count = 0; | |
131 | g_should_fail_count = 0; | |
132 | g_should_pass_count = 0; | |
133 | g_death_test_count = 0; | |
7c673cae | 134 | g_param_test_count = 0; |
7c673cae FG |
135 | } |
136 | ||
137 | // Checks that the count for each test is expected. | |
138 | void CheckCounts(int expected) { | |
139 | GTEST_CHECK_INT_EQ_(expected, g_environment_set_up_count); | |
140 | GTEST_CHECK_INT_EQ_(expected, g_environment_tear_down_count); | |
141 | GTEST_CHECK_INT_EQ_(expected, g_should_fail_count); | |
142 | GTEST_CHECK_INT_EQ_(expected, g_should_pass_count); | |
143 | GTEST_CHECK_INT_EQ_(expected, g_death_test_count); | |
7c673cae | 144 | GTEST_CHECK_INT_EQ_(expected * kNumberOfParamTests, g_param_test_count); |
7c673cae FG |
145 | } |
146 | ||
147 | // Tests the behavior of Google Test when --gtest_repeat is not specified. | |
148 | void TestRepeatUnspecified() { | |
149 | ResetCounts(); | |
150 | GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS()); | |
151 | CheckCounts(1); | |
152 | } | |
153 | ||
154 | // Tests the behavior of Google Test when --gtest_repeat has the given value. | |
155 | void TestRepeat(int repeat) { | |
156 | GTEST_FLAG(repeat) = repeat; | |
157 | ||
158 | ResetCounts(); | |
159 | GTEST_CHECK_INT_EQ_(repeat > 0 ? 1 : 0, RUN_ALL_TESTS()); | |
160 | CheckCounts(repeat); | |
161 | } | |
162 | ||
163 | // Tests using --gtest_repeat when --gtest_filter specifies an empty | |
164 | // set of tests. | |
165 | void TestRepeatWithEmptyFilter(int repeat) { | |
166 | GTEST_FLAG(repeat) = repeat; | |
167 | GTEST_FLAG(filter) = "None"; | |
168 | ||
169 | ResetCounts(); | |
170 | GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS()); | |
171 | CheckCounts(0); | |
172 | } | |
173 | ||
174 | // Tests using --gtest_repeat when --gtest_filter specifies a set of | |
175 | // successful tests. | |
176 | void TestRepeatWithFilterForSuccessfulTests(int repeat) { | |
177 | GTEST_FLAG(repeat) = repeat; | |
178 | GTEST_FLAG(filter) = "*-*ShouldFail"; | |
179 | ||
180 | ResetCounts(); | |
181 | GTEST_CHECK_INT_EQ_(0, RUN_ALL_TESTS()); | |
182 | GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count); | |
183 | GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count); | |
184 | GTEST_CHECK_INT_EQ_(0, g_should_fail_count); | |
185 | GTEST_CHECK_INT_EQ_(repeat, g_should_pass_count); | |
186 | GTEST_CHECK_INT_EQ_(repeat, g_death_test_count); | |
7c673cae | 187 | GTEST_CHECK_INT_EQ_(repeat * kNumberOfParamTests, g_param_test_count); |
7c673cae FG |
188 | } |
189 | ||
190 | // Tests using --gtest_repeat when --gtest_filter specifies a set of | |
191 | // failed tests. | |
192 | void TestRepeatWithFilterForFailedTests(int repeat) { | |
193 | GTEST_FLAG(repeat) = repeat; | |
194 | GTEST_FLAG(filter) = "*ShouldFail"; | |
195 | ||
196 | ResetCounts(); | |
197 | GTEST_CHECK_INT_EQ_(1, RUN_ALL_TESTS()); | |
198 | GTEST_CHECK_INT_EQ_(repeat, g_environment_set_up_count); | |
199 | GTEST_CHECK_INT_EQ_(repeat, g_environment_tear_down_count); | |
200 | GTEST_CHECK_INT_EQ_(repeat, g_should_fail_count); | |
201 | GTEST_CHECK_INT_EQ_(0, g_should_pass_count); | |
202 | GTEST_CHECK_INT_EQ_(0, g_death_test_count); | |
7c673cae | 203 | GTEST_CHECK_INT_EQ_(0, g_param_test_count); |
7c673cae FG |
204 | } |
205 | ||
206 | } // namespace | |
207 | ||
208 | int main(int argc, char **argv) { | |
209 | testing::InitGoogleTest(&argc, argv); | |
9f95a23c | 210 | |
7c673cae FG |
211 | testing::AddGlobalTestEnvironment(new MyEnvironment); |
212 | ||
213 | TestRepeatUnspecified(); | |
214 | TestRepeat(0); | |
215 | TestRepeat(1); | |
216 | TestRepeat(5); | |
217 | ||
218 | TestRepeatWithEmptyFilter(2); | |
219 | TestRepeatWithEmptyFilter(3); | |
220 | ||
221 | TestRepeatWithFilterForSuccessfulTests(3); | |
222 | ||
223 | TestRepeatWithFilterForFailedTests(4); | |
224 | ||
225 | // It would be nice to verify that the tests indeed loop forever | |
226 | // when GTEST_FLAG(repeat) is negative, but this test will be quite | |
227 | // complicated to write. Since this flag is for interactive | |
228 | // debugging only and doesn't affect the normal test result, such a | |
229 | // test would be an overkill. | |
230 | ||
231 | printf("PASS\n"); | |
232 | return 0; | |
233 | } |