michael@0: // Copyright 2009 Google Inc.  All rights reserved.
michael@0: //
michael@0: // Redistribution and use in source and binary forms, with or without
michael@0: // modification, are permitted provided that the following conditions are
michael@0: // met:
michael@0: //
michael@0: //     * Redistributions of source code must retain the above copyright
michael@0: // notice, this list of conditions and the following disclaimer.
michael@0: //     * Redistributions in binary form must reproduce the above
michael@0: // copyright notice, this list of conditions and the following disclaimer
michael@0: // in the documentation and/or other materials provided with the
michael@0: // distribution.
michael@0: //     * Neither the name of Google Inc. nor the names of its
michael@0: // contributors may be used to endorse or promote products derived from
michael@0: // this software without specific prior written permission.
michael@0: //
michael@0: // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
michael@0: // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
michael@0: // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
michael@0: // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
michael@0: // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
michael@0: // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
michael@0: // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
michael@0: // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
michael@0: // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
michael@0: // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
michael@0: // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
michael@0: //
michael@0: // Author: vladl@google.com (Vlad Losev)
michael@0: //
michael@0: // The Google C++ Testing Framework (Google Test)
michael@0: //
michael@0: // This file contains tests verifying correctness of data provided via
michael@0: // UnitTest's public methods.
michael@0: 
michael@0: #include "gtest/gtest.h"
michael@0: 
michael@0: #include <string.h>  // For strcmp.
michael@0: #include <algorithm>
michael@0: 
michael@0: using ::testing::InitGoogleTest;
michael@0: 
michael@0: namespace testing {
michael@0: namespace internal {
michael@0: 
michael@0: template <typename T>
michael@0: struct LessByName {
michael@0:   bool operator()(const T* a, const T* b) {
michael@0:     return strcmp(a->name(), b->name()) < 0;
michael@0:   }
michael@0: };
michael@0: 
michael@0: class UnitTestHelper {
michael@0:  public:
michael@0:   // Returns the array of pointers to all test cases sorted by the test case
michael@0:   // name.  The caller is responsible for deleting the array.
michael@0:   static TestCase const** const GetSortedTestCases() {
michael@0:     UnitTest& unit_test = *UnitTest::GetInstance();
michael@0:     TestCase const** const test_cases =
michael@0:         new const TestCase*[unit_test.total_test_case_count()];
michael@0: 
michael@0:     for (int i = 0; i < unit_test.total_test_case_count(); ++i)
michael@0:       test_cases[i] = unit_test.GetTestCase(i);
michael@0: 
michael@0:     std::sort(test_cases,
michael@0:               test_cases + unit_test.total_test_case_count(),
michael@0:               LessByName<TestCase>());
michael@0:     return test_cases;
michael@0:   }
michael@0: 
michael@0:   // Returns the test case by its name.  The caller doesn't own the returned
michael@0:   // pointer.
michael@0:   static const TestCase* FindTestCase(const char* name) {
michael@0:     UnitTest& unit_test = *UnitTest::GetInstance();
michael@0:     for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
michael@0:       const TestCase* test_case = unit_test.GetTestCase(i);
michael@0:       if (0 == strcmp(test_case->name(), name))
michael@0:         return test_case;
michael@0:     }
michael@0:     return NULL;
michael@0:   }
michael@0: 
michael@0:   // Returns the array of pointers to all tests in a particular test case
michael@0:   // sorted by the test name.  The caller is responsible for deleting the
michael@0:   // array.
michael@0:   static TestInfo const** const GetSortedTests(const TestCase* test_case) {
michael@0:     TestInfo const** const tests =
michael@0:         new const TestInfo*[test_case->total_test_count()];
michael@0: 
michael@0:     for (int i = 0; i < test_case->total_test_count(); ++i)
michael@0:       tests[i] = test_case->GetTestInfo(i);
michael@0: 
michael@0:     std::sort(tests, tests + test_case->total_test_count(),
michael@0:               LessByName<TestInfo>());
michael@0:     return tests;
michael@0:   }
michael@0: };
michael@0: 
michael@0: #if GTEST_HAS_TYPED_TEST
michael@0: template <typename T> class TestCaseWithCommentTest : public Test {};
michael@0: TYPED_TEST_CASE(TestCaseWithCommentTest, Types<int>);
michael@0: TYPED_TEST(TestCaseWithCommentTest, Dummy) {}
michael@0: 
michael@0: const int kTypedTestCases = 1;
michael@0: const int kTypedTests = 1;
michael@0: #else
michael@0: const int kTypedTestCases = 0;
michael@0: const int kTypedTests = 0;
michael@0: #endif  // GTEST_HAS_TYPED_TEST
michael@0: 
michael@0: // We can only test the accessors that do not change value while tests run.
michael@0: // Since tests can be run in any order, the values the accessors that track
michael@0: // test execution (such as failed_test_count) can not be predicted.
michael@0: TEST(ApiTest, UnitTestImmutableAccessorsWork) {
michael@0:   UnitTest* unit_test = UnitTest::GetInstance();
michael@0: 
michael@0:   ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());
michael@0:   EXPECT_EQ(1 + kTypedTestCases, unit_test->test_case_to_run_count());
michael@0:   EXPECT_EQ(2, unit_test->disabled_test_count());
michael@0:   EXPECT_EQ(5 + kTypedTests, unit_test->total_test_count());
michael@0:   EXPECT_EQ(3 + kTypedTests, unit_test->test_to_run_count());
michael@0: 
michael@0:   const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();
michael@0: 
michael@0:   EXPECT_STREQ("ApiTest", test_cases[0]->name());
michael@0:   EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
michael@0: #if GTEST_HAS_TYPED_TEST
michael@0:   EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
michael@0: #endif  // GTEST_HAS_TYPED_TEST
michael@0: 
michael@0:   delete[] test_cases;
michael@0: 
michael@0:   // The following lines initiate actions to verify certain methods in
michael@0:   // FinalSuccessChecker::TearDown.
michael@0: 
michael@0:   // Records a test property to verify TestResult::GetTestProperty().
michael@0:   RecordProperty("key", "value");
michael@0: }
michael@0: 
michael@0: AssertionResult IsNull(const char* str) {
michael@0:   if (str != NULL) {
michael@0:     return testing::AssertionFailure() << "argument is " << str;
michael@0:   }
michael@0:   return AssertionSuccess();
michael@0: }
michael@0: 
michael@0: TEST(ApiTest, TestCaseImmutableAccessorsWork) {
michael@0:   const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
michael@0:   ASSERT_TRUE(test_case != NULL);
michael@0: 
michael@0:   EXPECT_STREQ("ApiTest", test_case->name());
michael@0:   EXPECT_TRUE(IsNull(test_case->type_param()));
michael@0:   EXPECT_TRUE(test_case->should_run());
michael@0:   EXPECT_EQ(1, test_case->disabled_test_count());
michael@0:   EXPECT_EQ(3, test_case->test_to_run_count());
michael@0:   ASSERT_EQ(4, test_case->total_test_count());
michael@0: 
michael@0:   const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);
michael@0: 
michael@0:   EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
michael@0:   EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
michael@0:   EXPECT_TRUE(IsNull(tests[0]->value_param()));
michael@0:   EXPECT_TRUE(IsNull(tests[0]->type_param()));
michael@0:   EXPECT_FALSE(tests[0]->should_run());
michael@0: 
michael@0:   EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
michael@0:   EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
michael@0:   EXPECT_TRUE(IsNull(tests[1]->value_param()));
michael@0:   EXPECT_TRUE(IsNull(tests[1]->type_param()));
michael@0:   EXPECT_TRUE(tests[1]->should_run());
michael@0: 
michael@0:   EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
michael@0:   EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
michael@0:   EXPECT_TRUE(IsNull(tests[2]->value_param()));
michael@0:   EXPECT_TRUE(IsNull(tests[2]->type_param()));
michael@0:   EXPECT_TRUE(tests[2]->should_run());
michael@0: 
michael@0:   EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
michael@0:   EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
michael@0:   EXPECT_TRUE(IsNull(tests[3]->value_param()));
michael@0:   EXPECT_TRUE(IsNull(tests[3]->type_param()));
michael@0:   EXPECT_TRUE(tests[3]->should_run());
michael@0: 
michael@0:   delete[] tests;
michael@0:   tests = NULL;
michael@0: 
michael@0: #if GTEST_HAS_TYPED_TEST
michael@0:   test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
michael@0:   ASSERT_TRUE(test_case != NULL);
michael@0: 
michael@0:   EXPECT_STREQ("TestCaseWithCommentTest/0", test_case->name());
michael@0:   EXPECT_STREQ(GetTypeName<int>().c_str(), test_case->type_param());
michael@0:   EXPECT_TRUE(test_case->should_run());
michael@0:   EXPECT_EQ(0, test_case->disabled_test_count());
michael@0:   EXPECT_EQ(1, test_case->test_to_run_count());
michael@0:   ASSERT_EQ(1, test_case->total_test_count());
michael@0: 
michael@0:   tests = UnitTestHelper::GetSortedTests(test_case);
michael@0: 
michael@0:   EXPECT_STREQ("Dummy", tests[0]->name());
michael@0:   EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
michael@0:   EXPECT_TRUE(IsNull(tests[0]->value_param()));
michael@0:   EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param());
michael@0:   EXPECT_TRUE(tests[0]->should_run());
michael@0: 
michael@0:   delete[] tests;
michael@0: #endif  // GTEST_HAS_TYPED_TEST
michael@0: }
michael@0: 
michael@0: TEST(ApiTest, TestCaseDisabledAccessorsWork) {
michael@0:   const TestCase* test_case = UnitTestHelper::FindTestCase("DISABLED_Test");
michael@0:   ASSERT_TRUE(test_case != NULL);
michael@0: 
michael@0:   EXPECT_STREQ("DISABLED_Test", test_case->name());
michael@0:   EXPECT_TRUE(IsNull(test_case->type_param()));
michael@0:   EXPECT_FALSE(test_case->should_run());
michael@0:   EXPECT_EQ(1, test_case->disabled_test_count());
michael@0:   EXPECT_EQ(0, test_case->test_to_run_count());
michael@0:   ASSERT_EQ(1, test_case->total_test_count());
michael@0: 
michael@0:   const TestInfo* const test_info = test_case->GetTestInfo(0);
michael@0:   EXPECT_STREQ("Dummy2", test_info->name());
michael@0:   EXPECT_STREQ("DISABLED_Test", test_info->test_case_name());
michael@0:   EXPECT_TRUE(IsNull(test_info->value_param()));
michael@0:   EXPECT_TRUE(IsNull(test_info->type_param()));
michael@0:   EXPECT_FALSE(test_info->should_run());
michael@0: }
michael@0: 
michael@0: // These two tests are here to provide support for testing
michael@0: // test_case_to_run_count, disabled_test_count, and test_to_run_count.
michael@0: TEST(ApiTest, DISABLED_Dummy1) {}
michael@0: TEST(DISABLED_Test, Dummy2) {}
michael@0: 
michael@0: class FinalSuccessChecker : public Environment {
michael@0:  protected:
michael@0:   virtual void TearDown() {
michael@0:     UnitTest* unit_test = UnitTest::GetInstance();
michael@0: 
michael@0:     EXPECT_EQ(1 + kTypedTestCases, unit_test->successful_test_case_count());
michael@0:     EXPECT_EQ(3 + kTypedTests, unit_test->successful_test_count());
michael@0:     EXPECT_EQ(0, unit_test->failed_test_case_count());
michael@0:     EXPECT_EQ(0, unit_test->failed_test_count());
michael@0:     EXPECT_TRUE(unit_test->Passed());
michael@0:     EXPECT_FALSE(unit_test->Failed());
michael@0:     ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());
michael@0: 
michael@0:     const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();
michael@0: 
michael@0:     EXPECT_STREQ("ApiTest", test_cases[0]->name());
michael@0:     EXPECT_TRUE(IsNull(test_cases[0]->type_param()));
michael@0:     EXPECT_TRUE(test_cases[0]->should_run());
michael@0:     EXPECT_EQ(1, test_cases[0]->disabled_test_count());
michael@0:     ASSERT_EQ(4, test_cases[0]->total_test_count());
michael@0:     EXPECT_EQ(3, test_cases[0]->successful_test_count());
michael@0:     EXPECT_EQ(0, test_cases[0]->failed_test_count());
michael@0:     EXPECT_TRUE(test_cases[0]->Passed());
michael@0:     EXPECT_FALSE(test_cases[0]->Failed());
michael@0: 
michael@0:     EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
michael@0:     EXPECT_TRUE(IsNull(test_cases[1]->type_param()));
michael@0:     EXPECT_FALSE(test_cases[1]->should_run());
michael@0:     EXPECT_EQ(1, test_cases[1]->disabled_test_count());
michael@0:     ASSERT_EQ(1, test_cases[1]->total_test_count());
michael@0:     EXPECT_EQ(0, test_cases[1]->successful_test_count());
michael@0:     EXPECT_EQ(0, test_cases[1]->failed_test_count());
michael@0: 
michael@0: #if GTEST_HAS_TYPED_TEST
michael@0:     EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
michael@0:     EXPECT_STREQ(GetTypeName<int>().c_str(), test_cases[2]->type_param());
michael@0:     EXPECT_TRUE(test_cases[2]->should_run());
michael@0:     EXPECT_EQ(0, test_cases[2]->disabled_test_count());
michael@0:     ASSERT_EQ(1, test_cases[2]->total_test_count());
michael@0:     EXPECT_EQ(1, test_cases[2]->successful_test_count());
michael@0:     EXPECT_EQ(0, test_cases[2]->failed_test_count());
michael@0:     EXPECT_TRUE(test_cases[2]->Passed());
michael@0:     EXPECT_FALSE(test_cases[2]->Failed());
michael@0: #endif  // GTEST_HAS_TYPED_TEST
michael@0: 
michael@0:     const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
michael@0:     const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);
michael@0:     EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
michael@0:     EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
michael@0:     EXPECT_FALSE(tests[0]->should_run());
michael@0: 
michael@0:     EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
michael@0:     EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
michael@0:     EXPECT_TRUE(IsNull(tests[1]->value_param()));
michael@0:     EXPECT_TRUE(IsNull(tests[1]->type_param()));
michael@0:     EXPECT_TRUE(tests[1]->should_run());
michael@0:     EXPECT_TRUE(tests[1]->result()->Passed());
michael@0:     EXPECT_EQ(0, tests[1]->result()->test_property_count());
michael@0: 
michael@0:     EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
michael@0:     EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
michael@0:     EXPECT_TRUE(IsNull(tests[2]->value_param()));
michael@0:     EXPECT_TRUE(IsNull(tests[2]->type_param()));
michael@0:     EXPECT_TRUE(tests[2]->should_run());
michael@0:     EXPECT_TRUE(tests[2]->result()->Passed());
michael@0:     EXPECT_EQ(0, tests[2]->result()->test_property_count());
michael@0: 
michael@0:     EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
michael@0:     EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
michael@0:     EXPECT_TRUE(IsNull(tests[3]->value_param()));
michael@0:     EXPECT_TRUE(IsNull(tests[3]->type_param()));
michael@0:     EXPECT_TRUE(tests[3]->should_run());
michael@0:     EXPECT_TRUE(tests[3]->result()->Passed());
michael@0:     EXPECT_EQ(1, tests[3]->result()->test_property_count());
michael@0:     const TestProperty& property = tests[3]->result()->GetTestProperty(0);
michael@0:     EXPECT_STREQ("key", property.key());
michael@0:     EXPECT_STREQ("value", property.value());
michael@0: 
michael@0:     delete[] tests;
michael@0: 
michael@0: #if GTEST_HAS_TYPED_TEST
michael@0:     test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
michael@0:     tests = UnitTestHelper::GetSortedTests(test_case);
michael@0: 
michael@0:     EXPECT_STREQ("Dummy", tests[0]->name());
michael@0:     EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
michael@0:     EXPECT_TRUE(IsNull(tests[0]->value_param()));
michael@0:     EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param());
michael@0:     EXPECT_TRUE(tests[0]->should_run());
michael@0:     EXPECT_TRUE(tests[0]->result()->Passed());
michael@0:     EXPECT_EQ(0, tests[0]->result()->test_property_count());
michael@0: 
michael@0:     delete[] tests;
michael@0: #endif  // GTEST_HAS_TYPED_TEST
michael@0:     delete[] test_cases;
michael@0:   }
michael@0: };
michael@0: 
michael@0: }  // namespace internal
michael@0: }  // namespace testing
michael@0: 
michael@0: int main(int argc, char **argv) {
michael@0:   InitGoogleTest(&argc, argv);
michael@0: 
michael@0:   AddGlobalTestEnvironment(new testing::internal::FinalSuccessChecker());
michael@0: 
michael@0:   return RUN_ALL_TESTS();
michael@0: }