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 (at) 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 { 48 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. 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. 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. 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>); 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. 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 140 AssertionResult IsNull(const char* str) { 141 if (str != NULL) { 142 return testing::AssertionFailure() << "argument is " << str; 143 } 144 return AssertionSuccess(); 145 } 146 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 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. 231 TEST(ApiTest, DISABLED_Dummy1) {} 232 TEST(DISABLED_Test, Dummy2) {} 233 234 class FinalSuccessChecker : public Environment { 235 protected: 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 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
