Home | History | Annotate | Download | only in test
      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