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@google.com (Vlad Losev)
30 //
31 // The Google C++ Testing Framework (Google Test)
32 //
33 // This file contains tests verifying correctness of data provided via
34 // UnitTest's public methods.
35
36 #include "gtest/gtest.h"
37
38 #include <string.h> // For strcmp.
39 #include <algorithm>
40
41 using ::testing::InitGoogleTest;
42
43 namespace testing {
44 namespace internal {
45
46 template <typename T>
47 struct LessByName {
operator ()testing::internal::LessByName48 bool operator()(const T* a, const T* b) {
49 return strcmp(a->name(), b->name()) < 0;
50 }
51 };
52
53 class UnitTestHelper {
54 public:
55 // Returns the array of pointers to all test cases sorted by the test case
56 // name. The caller is responsible for deleting the array.
GetSortedTestCases()57 static TestCase const** const GetSortedTestCases() {
58 UnitTest& unit_test = *UnitTest::GetInstance();
59 TestCase const** const test_cases =
60 new const TestCase*[unit_test.total_test_case_count()];
61
62 for (int i = 0; i < unit_test.total_test_case_count(); ++i)
63 test_cases[i] = unit_test.GetTestCase(i);
64
65 std::sort(test_cases,
66 test_cases + unit_test.total_test_case_count(),
67 LessByName<TestCase>());
68 return test_cases;
69 }
70
71 // Returns the test case by its name. The caller doesn't own the returned
72 // pointer.
FindTestCase(const char * name)73 static const TestCase* FindTestCase(const char* name) {
74 UnitTest& unit_test = *UnitTest::GetInstance();
75 for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
76 const TestCase* test_case = unit_test.GetTestCase(i);
77 if (0 == strcmp(test_case->name(), name))
78 return test_case;
79 }
80 return NULL;
81 }
82
83 // Returns the array of pointers to all tests in a particular test case
84 // sorted by the test name. The caller is responsible for deleting the
85 // array.
GetSortedTests(const TestCase * test_case)86 static TestInfo const** const GetSortedTests(const TestCase* test_case) {
87 TestInfo const** const tests =
88 new const TestInfo*[test_case->total_test_count()];
89
90 for (int i = 0; i < test_case->total_test_count(); ++i)
91 tests[i] = test_case->GetTestInfo(i);
92
93 std::sort(tests, tests + test_case->total_test_count(),
94 LessByName<TestInfo>());
95 return tests;
96 }
97 };
98
99 #if GTEST_HAS_TYPED_TEST
100 template <typename T> class TestCaseWithCommentTest : public Test {};
101 TYPED_TEST_CASE(TestCaseWithCommentTest, Types<int>);
TYPED_TEST(TestCaseWithCommentTest,Dummy)102 TYPED_TEST(TestCaseWithCommentTest, Dummy) {}
103
104 const int kTypedTestCases = 1;
105 const int kTypedTests = 1;
106 #else
107 const int kTypedTestCases = 0;
108 const int kTypedTests = 0;
109 #endif // GTEST_HAS_TYPED_TEST
110
111 // We can only test the accessors that do not change value while tests run.
112 // Since tests can be run in any order, the values the accessors that track
113 // test execution (such as failed_test_count) can not be predicted.
TEST(ApiTest,UnitTestImmutableAccessorsWork)114 TEST(ApiTest, UnitTestImmutableAccessorsWork) {
115 UnitTest* unit_test = UnitTest::GetInstance();
116
117 ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());
118 EXPECT_EQ(1 + kTypedTestCases, unit_test->test_case_to_run_count());
119 EXPECT_EQ(2, unit_test->disabled_test_count());
120 EXPECT_EQ(5 + kTypedTests, unit_test->total_test_count());
121 EXPECT_EQ(3 + kTypedTests, unit_test->test_to_run_count());
122
123 const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();
124
125 EXPECT_STREQ("ApiTest", test_cases[0]->name());
126 EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
127 #if GTEST_HAS_TYPED_TEST
128 EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
129 #endif // GTEST_HAS_TYPED_TEST
130
131 delete[] test_cases;
132
133 // The following lines initiate actions to verify certain methods in
134 // FinalSuccessChecker::TearDown.
135
136 // Records a test property to verify TestResult::GetTestProperty().
137 RecordProperty("key", "value");
138 }
139
IsNull(const char * str)140 AssertionResult IsNull(const char* str) {
141 if (str != NULL) {
142 return testing::AssertionFailure() << "argument is " << str;
143 }
144 return AssertionSuccess();
145 }
146
TEST(ApiTest,TestCaseImmutableAccessorsWork)147 TEST(ApiTest, TestCaseImmutableAccessorsWork) {
148 const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
149 ASSERT_TRUE(test_case != NULL);
150
151 EXPECT_STREQ("ApiTest", test_case->name());
152 EXPECT_TRUE(IsNull(test_case->type_param()));
153 EXPECT_TRUE(test_case->should_run());
154 EXPECT_EQ(1, test_case->disabled_test_count());
155 EXPECT_EQ(3, test_case->test_to_run_count());
156 ASSERT_EQ(4, test_case->total_test_count());
157
158 const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);
159
160 EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
161 EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
162 EXPECT_TRUE(IsNull(tests[0]->value_param()));
163 EXPECT_TRUE(IsNull(tests[0]->type_param()));
164 EXPECT_FALSE(tests[0]->should_run());
165
166 EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
167 EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
168 EXPECT_TRUE(IsNull(tests[1]->value_param()));
169 EXPECT_TRUE(IsNull(tests[1]->type_param()));
170 EXPECT_TRUE(tests[1]->should_run());
171
172 EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
173 EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
174 EXPECT_TRUE(IsNull(tests[2]->value_param()));
175 EXPECT_TRUE(IsNull(tests[2]->type_param()));
176 EXPECT_TRUE(tests[2]->should_run());
177
178 EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
179 EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
180 EXPECT_TRUE(IsNull(tests[3]->value_param()));
181 EXPECT_TRUE(IsNull(tests[3]->type_param()));
182 EXPECT_TRUE(tests[3]->should_run());
183
184 delete[] tests;
185 tests = NULL;
186
187 #if GTEST_HAS_TYPED_TEST
188 test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
189 ASSERT_TRUE(test_case != NULL);
190
191 EXPECT_STREQ("TestCaseWithCommentTest/0", test_case->name());
192 EXPECT_STREQ(GetTypeName<int>().c_str(), test_case->type_param());
193 EXPECT_TRUE(test_case->should_run());
194 EXPECT_EQ(0, test_case->disabled_test_count());
195 EXPECT_EQ(1, test_case->test_to_run_count());
196 ASSERT_EQ(1, test_case->total_test_count());
197
198 tests = UnitTestHelper::GetSortedTests(test_case);
199
200 EXPECT_STREQ("Dummy", tests[0]->name());
201 EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
202 EXPECT_TRUE(IsNull(tests[0]->value_param()));
203 EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param());
204 EXPECT_TRUE(tests[0]->should_run());
205
206 delete[] tests;
207 #endif // GTEST_HAS_TYPED_TEST
208 }
209
TEST(ApiTest,TestCaseDisabledAccessorsWork)210 TEST(ApiTest, TestCaseDisabledAccessorsWork) {
211 const TestCase* test_case = UnitTestHelper::FindTestCase("DISABLED_Test");
212 ASSERT_TRUE(test_case != NULL);
213
214 EXPECT_STREQ("DISABLED_Test", test_case->name());
215 EXPECT_TRUE(IsNull(test_case->type_param()));
216 EXPECT_FALSE(test_case->should_run());
217 EXPECT_EQ(1, test_case->disabled_test_count());
218 EXPECT_EQ(0, test_case->test_to_run_count());
219 ASSERT_EQ(1, test_case->total_test_count());
220
221 const TestInfo* const test_info = test_case->GetTestInfo(0);
222 EXPECT_STREQ("Dummy2", test_info->name());
223 EXPECT_STREQ("DISABLED_Test", test_info->test_case_name());
224 EXPECT_TRUE(IsNull(test_info->value_param()));
225 EXPECT_TRUE(IsNull(test_info->type_param()));
226 EXPECT_FALSE(test_info->should_run());
227 }
228
229 // These two tests are here to provide support for testing
230 // test_case_to_run_count, disabled_test_count, and test_to_run_count.
TEST(ApiTest,DISABLED_Dummy1)231 TEST(ApiTest, DISABLED_Dummy1) {}
TEST(DISABLED_Test,Dummy2)232 TEST(DISABLED_Test, Dummy2) {}
233
234 class FinalSuccessChecker : public Environment {
235 protected:
TearDown()236 virtual void TearDown() {
237 UnitTest* unit_test = UnitTest::GetInstance();
238
239 EXPECT_EQ(1 + kTypedTestCases, unit_test->successful_test_case_count());
240 EXPECT_EQ(3 + kTypedTests, unit_test->successful_test_count());
241 EXPECT_EQ(0, unit_test->failed_test_case_count());
242 EXPECT_EQ(0, unit_test->failed_test_count());
243 EXPECT_TRUE(unit_test->Passed());
244 EXPECT_FALSE(unit_test->Failed());
245 ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());
246
247 const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();
248
249 EXPECT_STREQ("ApiTest", test_cases[0]->name());
250 EXPECT_TRUE(IsNull(test_cases[0]->type_param()));
251 EXPECT_TRUE(test_cases[0]->should_run());
252 EXPECT_EQ(1, test_cases[0]->disabled_test_count());
253 ASSERT_EQ(4, test_cases[0]->total_test_count());
254 EXPECT_EQ(3, test_cases[0]->successful_test_count());
255 EXPECT_EQ(0, test_cases[0]->failed_test_count());
256 EXPECT_TRUE(test_cases[0]->Passed());
257 EXPECT_FALSE(test_cases[0]->Failed());
258
259 EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
260 EXPECT_TRUE(IsNull(test_cases[1]->type_param()));
261 EXPECT_FALSE(test_cases[1]->should_run());
262 EXPECT_EQ(1, test_cases[1]->disabled_test_count());
263 ASSERT_EQ(1, test_cases[1]->total_test_count());
264 EXPECT_EQ(0, test_cases[1]->successful_test_count());
265 EXPECT_EQ(0, test_cases[1]->failed_test_count());
266
267 #if GTEST_HAS_TYPED_TEST
268 EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
269 EXPECT_STREQ(GetTypeName<int>().c_str(), test_cases[2]->type_param());
270 EXPECT_TRUE(test_cases[2]->should_run());
271 EXPECT_EQ(0, test_cases[2]->disabled_test_count());
272 ASSERT_EQ(1, test_cases[2]->total_test_count());
273 EXPECT_EQ(1, test_cases[2]->successful_test_count());
274 EXPECT_EQ(0, test_cases[2]->failed_test_count());
275 EXPECT_TRUE(test_cases[2]->Passed());
276 EXPECT_FALSE(test_cases[2]->Failed());
277 #endif // GTEST_HAS_TYPED_TEST
278
279 const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
280 const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);
281 EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
282 EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
283 EXPECT_FALSE(tests[0]->should_run());
284
285 EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
286 EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
287 EXPECT_TRUE(IsNull(tests[1]->value_param()));
288 EXPECT_TRUE(IsNull(tests[1]->type_param()));
289 EXPECT_TRUE(tests[1]->should_run());
290 EXPECT_TRUE(tests[1]->result()->Passed());
291 EXPECT_EQ(0, tests[1]->result()->test_property_count());
292
293 EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
294 EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
295 EXPECT_TRUE(IsNull(tests[2]->value_param()));
296 EXPECT_TRUE(IsNull(tests[2]->type_param()));
297 EXPECT_TRUE(tests[2]->should_run());
298 EXPECT_TRUE(tests[2]->result()->Passed());
299 EXPECT_EQ(0, tests[2]->result()->test_property_count());
300
301 EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
302 EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
303 EXPECT_TRUE(IsNull(tests[3]->value_param()));
304 EXPECT_TRUE(IsNull(tests[3]->type_param()));
305 EXPECT_TRUE(tests[3]->should_run());
306 EXPECT_TRUE(tests[3]->result()->Passed());
307 EXPECT_EQ(1, tests[3]->result()->test_property_count());
308 const TestProperty& property = tests[3]->result()->GetTestProperty(0);
309 EXPECT_STREQ("key", property.key());
310 EXPECT_STREQ("value", property.value());
311
312 delete[] tests;
313
314 #if GTEST_HAS_TYPED_TEST
315 test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
316 tests = UnitTestHelper::GetSortedTests(test_case);
317
318 EXPECT_STREQ("Dummy", tests[0]->name());
319 EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
320 EXPECT_TRUE(IsNull(tests[0]->value_param()));
321 EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param());
322 EXPECT_TRUE(tests[0]->should_run());
323 EXPECT_TRUE(tests[0]->result()->Passed());
324 EXPECT_EQ(0, tests[0]->result()->test_property_count());
325
326 delete[] tests;
327 #endif // GTEST_HAS_TYPED_TEST
328 delete[] test_cases;
329 }
330 };
331
332 } // namespace internal
333 } // namespace testing
334
main(int argc,char ** argv)335 int main(int argc, char **argv) {
336 InitGoogleTest(&argc, argv);
337
338 AddGlobalTestEnvironment(new testing::internal::FinalSuccessChecker());
339
340 return RUN_ALL_TESTS();
341 }
342