ext/googletest/test/gtest-unittest-api_test.cc - amd/gem5 - Git at Google

 // Copyright 2009 Google Inc.  All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 // Author: vladl@google.com (Vlad Losev)
 //
 // The Google C++ Testing Framework (Google Test)
 //
 // This file contains tests verifying correctness of data provided via
 // UnitTest's public methods.

 #include "gtest/gtest.h"

 #include <string.h>  // For strcmp.
 #include <algorithm>

 using ::testing::InitGoogleTest;

 namespace testing {
 namespace internal {

 template <typename T>
 struct LessByName {
   bool operator()(const T* a, const T* b) {
     return strcmp(a->name(), b->name()) < 0;
   }
 };

 class UnitTestHelper {
  public:
   // Returns the array of pointers to all test cases sorted by the test case
   // name.  The caller is responsible for deleting the array.
   static TestCase const** GetSortedTestCases() {
     UnitTest& unit_test = *UnitTest::GetInstance();
     TestCase const** const test_cases =
         new const TestCase*[unit_test.total_test_case_count()];

     for (int i = 0; i < unit_test.total_test_case_count(); ++i)
       test_cases[i] = unit_test.GetTestCase(i);

     std::sort(test_cases,
               test_cases + unit_test.total_test_case_count(),
               LessByName<TestCase>());
     return test_cases;
   }

   // Returns the test case by its name.  The caller doesn't own the returned
   // pointer.
   static const TestCase* FindTestCase(const char* name) {
     UnitTest& unit_test = *UnitTest::GetInstance();
     for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
       const TestCase* test_case = unit_test.GetTestCase(i);
       if (0 == strcmp(test_case->name(), name))
         return test_case;
     }
     return NULL;
   }

   // Returns the array of pointers to all tests in a particular test case
   // sorted by the test name.  The caller is responsible for deleting the
   // array.
   static TestInfo const** GetSortedTests(const TestCase* test_case) {
     TestInfo const** const tests =
         new const TestInfo*[test_case->total_test_count()];

     for (int i = 0; i < test_case->total_test_count(); ++i)
       tests[i] = test_case->GetTestInfo(i);

     std::sort(tests, tests + test_case->total_test_count(),
               LessByName<TestInfo>());
     return tests;
   }
 };

 #if GTEST_HAS_TYPED_TEST
 template <typename T> class TestCaseWithCommentTest : public Test {};
 TYPED_TEST_CASE(TestCaseWithCommentTest, Types<int>);
 TYPED_TEST(TestCaseWithCommentTest, Dummy) {}

 const int kTypedTestCases = 1;
 const int kTypedTests = 1;
 #else
 const int kTypedTestCases = 0;
 const int kTypedTests = 0;
 #endif  // GTEST_HAS_TYPED_TEST

 // We can only test the accessors that do not change value while tests run.
 // Since tests can be run in any order, the values the accessors that track
 // test execution (such as failed_test_count) can not be predicted.
 TEST(ApiTest, UnitTestImmutableAccessorsWork) {
   UnitTest* unit_test = UnitTest::GetInstance();

   ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());
   EXPECT_EQ(1 + kTypedTestCases, unit_test->test_case_to_run_count());
   EXPECT_EQ(2, unit_test->disabled_test_count());
   EXPECT_EQ(5 + kTypedTests, unit_test->total_test_count());
   EXPECT_EQ(3 + kTypedTests, unit_test->test_to_run_count());

   const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();

   EXPECT_STREQ("ApiTest", test_cases[0]->name());
   EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
 #if GTEST_HAS_TYPED_TEST
   EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
 #endif  // GTEST_HAS_TYPED_TEST

   delete[] test_cases;

   // The following lines initiate actions to verify certain methods in
   // FinalSuccessChecker::TearDown.

   // Records a test property to verify TestResult::GetTestProperty().
   RecordProperty("key", "value");
 }

 AssertionResult IsNull(const char* str) {
   if (str != NULL) {
     return testing::AssertionFailure() << "argument is " << str;
   }
   return AssertionSuccess();
 }

 TEST(ApiTest, TestCaseImmutableAccessorsWork) {
   const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
   ASSERT_TRUE(test_case != NULL);

   EXPECT_STREQ("ApiTest", test_case->name());
   EXPECT_TRUE(IsNull(test_case->type_param()));
   EXPECT_TRUE(test_case->should_run());
   EXPECT_EQ(1, test_case->disabled_test_count());
   EXPECT_EQ(3, test_case->test_to_run_count());
   ASSERT_EQ(4, test_case->total_test_count());

   const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);

   EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
   EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
   EXPECT_TRUE(IsNull(tests[0]->value_param()));
   EXPECT_TRUE(IsNull(tests[0]->type_param()));
   EXPECT_FALSE(tests[0]->should_run());

   EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
   EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
   EXPECT_TRUE(IsNull(tests[1]->value_param()));
   EXPECT_TRUE(IsNull(tests[1]->type_param()));
   EXPECT_TRUE(tests[1]->should_run());

   EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
   EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
   EXPECT_TRUE(IsNull(tests[2]->value_param()));
   EXPECT_TRUE(IsNull(tests[2]->type_param()));
   EXPECT_TRUE(tests[2]->should_run());

   EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
   EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
   EXPECT_TRUE(IsNull(tests[3]->value_param()));
   EXPECT_TRUE(IsNull(tests[3]->type_param()));
   EXPECT_TRUE(tests[3]->should_run());

   delete[] tests;
   tests = NULL;

 #if GTEST_HAS_TYPED_TEST
   test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
   ASSERT_TRUE(test_case != NULL);

   EXPECT_STREQ("TestCaseWithCommentTest/0", test_case->name());
   EXPECT_STREQ(GetTypeName<int>().c_str(), test_case->type_param());
   EXPECT_TRUE(test_case->should_run());
   EXPECT_EQ(0, test_case->disabled_test_count());
   EXPECT_EQ(1, test_case->test_to_run_count());
   ASSERT_EQ(1, test_case->total_test_count());

   tests = UnitTestHelper::GetSortedTests(test_case);

   EXPECT_STREQ("Dummy", tests[0]->name());
   EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
   EXPECT_TRUE(IsNull(tests[0]->value_param()));
   EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param());
   EXPECT_TRUE(tests[0]->should_run());

   delete[] tests;
 #endif  // GTEST_HAS_TYPED_TEST
 }

 TEST(ApiTest, TestCaseDisabledAccessorsWork) {
   const TestCase* test_case = UnitTestHelper::FindTestCase("DISABLED_Test");
   ASSERT_TRUE(test_case != NULL);

   EXPECT_STREQ("DISABLED_Test", test_case->name());
   EXPECT_TRUE(IsNull(test_case->type_param()));
   EXPECT_FALSE(test_case->should_run());
   EXPECT_EQ(1, test_case->disabled_test_count());
   EXPECT_EQ(0, test_case->test_to_run_count());
   ASSERT_EQ(1, test_case->total_test_count());

   const TestInfo* const test_info = test_case->GetTestInfo(0);
   EXPECT_STREQ("Dummy2", test_info->name());
   EXPECT_STREQ("DISABLED_Test", test_info->test_case_name());
   EXPECT_TRUE(IsNull(test_info->value_param()));
   EXPECT_TRUE(IsNull(test_info->type_param()));
   EXPECT_FALSE(test_info->should_run());
 }

 // These two tests are here to provide support for testing
 // test_case_to_run_count, disabled_test_count, and test_to_run_count.
 TEST(ApiTest, DISABLED_Dummy1) {}
 TEST(DISABLED_Test, Dummy2) {}

 class FinalSuccessChecker : public Environment {
  protected:
   virtual void TearDown() {
     UnitTest* unit_test = UnitTest::GetInstance();

     EXPECT_EQ(1 + kTypedTestCases, unit_test->successful_test_case_count());
     EXPECT_EQ(3 + kTypedTests, unit_test->successful_test_count());
     EXPECT_EQ(0, unit_test->failed_test_case_count());
     EXPECT_EQ(0, unit_test->failed_test_count());
     EXPECT_TRUE(unit_test->Passed());
     EXPECT_FALSE(unit_test->Failed());
     ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());

     const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();

     EXPECT_STREQ("ApiTest", test_cases[0]->name());
     EXPECT_TRUE(IsNull(test_cases[0]->type_param()));
     EXPECT_TRUE(test_cases[0]->should_run());
     EXPECT_EQ(1, test_cases[0]->disabled_test_count());
     ASSERT_EQ(4, test_cases[0]->total_test_count());
     EXPECT_EQ(3, test_cases[0]->successful_test_count());
     EXPECT_EQ(0, test_cases[0]->failed_test_count());
     EXPECT_TRUE(test_cases[0]->Passed());
     EXPECT_FALSE(test_cases[0]->Failed());

     EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
     EXPECT_TRUE(IsNull(test_cases[1]->type_param()));
     EXPECT_FALSE(test_cases[1]->should_run());
     EXPECT_EQ(1, test_cases[1]->disabled_test_count());
     ASSERT_EQ(1, test_cases[1]->total_test_count());
     EXPECT_EQ(0, test_cases[1]->successful_test_count());
     EXPECT_EQ(0, test_cases[1]->failed_test_count());

 #if GTEST_HAS_TYPED_TEST
     EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
     EXPECT_STREQ(GetTypeName<int>().c_str(), test_cases[2]->type_param());
     EXPECT_TRUE(test_cases[2]->should_run());
     EXPECT_EQ(0, test_cases[2]->disabled_test_count());
     ASSERT_EQ(1, test_cases[2]->total_test_count());
     EXPECT_EQ(1, test_cases[2]->successful_test_count());
     EXPECT_EQ(0, test_cases[2]->failed_test_count());
     EXPECT_TRUE(test_cases[2]->Passed());
     EXPECT_FALSE(test_cases[2]->Failed());
 #endif  // GTEST_HAS_TYPED_TEST

     const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
     const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);
     EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
     EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
     EXPECT_FALSE(tests[0]->should_run());

     EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
     EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
     EXPECT_TRUE(IsNull(tests[1]->value_param()));
     EXPECT_TRUE(IsNull(tests[1]->type_param()));
     EXPECT_TRUE(tests[1]->should_run());
     EXPECT_TRUE(tests[1]->result()->Passed());
     EXPECT_EQ(0, tests[1]->result()->test_property_count());

     EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
     EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
     EXPECT_TRUE(IsNull(tests[2]->value_param()));
     EXPECT_TRUE(IsNull(tests[2]->type_param()));
     EXPECT_TRUE(tests[2]->should_run());
     EXPECT_TRUE(tests[2]->result()->Passed());
     EXPECT_EQ(0, tests[2]->result()->test_property_count());

     EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
     EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
     EXPECT_TRUE(IsNull(tests[3]->value_param()));
     EXPECT_TRUE(IsNull(tests[3]->type_param()));
     EXPECT_TRUE(tests[3]->should_run());
     EXPECT_TRUE(tests[3]->result()->Passed());
     EXPECT_EQ(1, tests[3]->result()->test_property_count());
     const TestProperty& property = tests[3]->result()->GetTestProperty(0);
     EXPECT_STREQ("key", property.key());
     EXPECT_STREQ("value", property.value());

     delete[] tests;

 #if GTEST_HAS_TYPED_TEST
     test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
     tests = UnitTestHelper::GetSortedTests(test_case);

     EXPECT_STREQ("Dummy", tests[0]->name());
     EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
     EXPECT_TRUE(IsNull(tests[0]->value_param()));
     EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param());
     EXPECT_TRUE(tests[0]->should_run());
     EXPECT_TRUE(tests[0]->result()->Passed());
     EXPECT_EQ(0, tests[0]->result()->test_property_count());

     delete[] tests;
 #endif  // GTEST_HAS_TYPED_TEST
     delete[] test_cases;
   }
 };

 }  // namespace internal
 }  // namespace testing

 int main(int argc, char **argv) {
   InitGoogleTest(&argc, argv);

   AddGlobalTestEnvironment(new testing::internal::FinalSuccessChecker());

   return RUN_ALL_TESTS();
 }
	// Copyright 2009 Google Inc. All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are
	// met:
	//
	// * Redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer.
	// * Redistributions in binary form must reproduce the above
	// copyright notice, this list of conditions and the following disclaimer
	// in the documentation and/or other materials provided with the
	// distribution.
	// * Neither the name of Google Inc. nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	//
	// Author: vladl@google.com (Vlad Losev)
	//
	// The Google C++ Testing Framework (Google Test)
	//
	// This file contains tests verifying correctness of data provided via
	// UnitTest's public methods.

	#include "gtest/gtest.h"

	#include <string.h> // For strcmp.
	#include <algorithm>

	using ::testing::InitGoogleTest;

	namespace testing {
	namespace internal {

	template <typename T>
	struct LessByName {
	bool operator()(const T* a, const T* b) {
	return strcmp(a->name(), b->name()) < 0;
	}
	};

	class UnitTestHelper {
	public:
	// Returns the array of pointers to all test cases sorted by the test case
	// name. The caller is responsible for deleting the array.
	static TestCase const** GetSortedTestCases() {
	UnitTest& unit_test = *UnitTest::GetInstance();
	TestCase const** const test_cases =
	new const TestCase*[unit_test.total_test_case_count()];

	for (int i = 0; i < unit_test.total_test_case_count(); ++i)
	test_cases[i] = unit_test.GetTestCase(i);

	std::sort(test_cases,
	test_cases + unit_test.total_test_case_count(),
	LessByName<TestCase>());
	return test_cases;
	}

	// Returns the test case by its name. The caller doesn't own the returned
	// pointer.
	static const TestCase* FindTestCase(const char* name) {
	UnitTest& unit_test = *UnitTest::GetInstance();
	for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
	const TestCase* test_case = unit_test.GetTestCase(i);
	if (0 == strcmp(test_case->name(), name))
	return test_case;
	}
	return NULL;
	}

	// Returns the array of pointers to all tests in a particular test case
	// sorted by the test name. The caller is responsible for deleting the
	// array.
	static TestInfo const** GetSortedTests(const TestCase* test_case) {
	TestInfo const** const tests =
	new const TestInfo*[test_case->total_test_count()];

	for (int i = 0; i < test_case->total_test_count(); ++i)
	tests[i] = test_case->GetTestInfo(i);

	std::sort(tests, tests + test_case->total_test_count(),
	LessByName<TestInfo>());
	return tests;
	}
	};

	#if GTEST_HAS_TYPED_TEST
	template <typename T> class TestCaseWithCommentTest : public Test {};
	TYPED_TEST_CASE(TestCaseWithCommentTest, Types<int>);
	TYPED_TEST(TestCaseWithCommentTest, Dummy) {}

	const int kTypedTestCases = 1;
	const int kTypedTests = 1;
	#else
	const int kTypedTestCases = 0;
	const int kTypedTests = 0;
	#endif // GTEST_HAS_TYPED_TEST

	// We can only test the accessors that do not change value while tests run.
	// Since tests can be run in any order, the values the accessors that track
	// test execution (such as failed_test_count) can not be predicted.
	TEST(ApiTest, UnitTestImmutableAccessorsWork) {
	UnitTest* unit_test = UnitTest::GetInstance();

	ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());
	EXPECT_EQ(1 + kTypedTestCases, unit_test->test_case_to_run_count());
	EXPECT_EQ(2, unit_test->disabled_test_count());
	EXPECT_EQ(5 + kTypedTests, unit_test->total_test_count());
	EXPECT_EQ(3 + kTypedTests, unit_test->test_to_run_count());

	const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();

	EXPECT_STREQ("ApiTest", test_cases[0]->name());
	EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
	#if GTEST_HAS_TYPED_TEST
	EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
	#endif // GTEST_HAS_TYPED_TEST

	delete[] test_cases;

	// The following lines initiate actions to verify certain methods in
	// FinalSuccessChecker::TearDown.

	// Records a test property to verify TestResult::GetTestProperty().
	RecordProperty("key", "value");
	}

	AssertionResult IsNull(const char* str) {
	if (str != NULL) {
	return testing::AssertionFailure() << "argument is " << str;
	}
	return AssertionSuccess();
	}

	TEST(ApiTest, TestCaseImmutableAccessorsWork) {
	const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
	ASSERT_TRUE(test_case != NULL);

	EXPECT_STREQ("ApiTest", test_case->name());
	EXPECT_TRUE(IsNull(test_case->type_param()));
	EXPECT_TRUE(test_case->should_run());
	EXPECT_EQ(1, test_case->disabled_test_count());
	EXPECT_EQ(3, test_case->test_to_run_count());
	ASSERT_EQ(4, test_case->total_test_count());

	const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);

	EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
	EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
	EXPECT_TRUE(IsNull(tests[0]->value_param()));
	EXPECT_TRUE(IsNull(tests[0]->type_param()));
	EXPECT_FALSE(tests[0]->should_run());

	EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
	EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
	EXPECT_TRUE(IsNull(tests[1]->value_param()));
	EXPECT_TRUE(IsNull(tests[1]->type_param()));
	EXPECT_TRUE(tests[1]->should_run());

	EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
	EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
	EXPECT_TRUE(IsNull(tests[2]->value_param()));
	EXPECT_TRUE(IsNull(tests[2]->type_param()));
	EXPECT_TRUE(tests[2]->should_run());

	EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
	EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
	EXPECT_TRUE(IsNull(tests[3]->value_param()));
	EXPECT_TRUE(IsNull(tests[3]->type_param()));
	EXPECT_TRUE(tests[3]->should_run());

	delete[] tests;
	tests = NULL;

	#if GTEST_HAS_TYPED_TEST
	test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
	ASSERT_TRUE(test_case != NULL);

	EXPECT_STREQ("TestCaseWithCommentTest/0", test_case->name());
	EXPECT_STREQ(GetTypeName<int>().c_str(), test_case->type_param());
	EXPECT_TRUE(test_case->should_run());
	EXPECT_EQ(0, test_case->disabled_test_count());
	EXPECT_EQ(1, test_case->test_to_run_count());
	ASSERT_EQ(1, test_case->total_test_count());

	tests = UnitTestHelper::GetSortedTests(test_case);

	EXPECT_STREQ("Dummy", tests[0]->name());
	EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
	EXPECT_TRUE(IsNull(tests[0]->value_param()));
	EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param());
	EXPECT_TRUE(tests[0]->should_run());

	delete[] tests;
	#endif // GTEST_HAS_TYPED_TEST
	}

	TEST(ApiTest, TestCaseDisabledAccessorsWork) {
	const TestCase* test_case = UnitTestHelper::FindTestCase("DISABLED_Test");
	ASSERT_TRUE(test_case != NULL);

	EXPECT_STREQ("DISABLED_Test", test_case->name());
	EXPECT_TRUE(IsNull(test_case->type_param()));
	EXPECT_FALSE(test_case->should_run());
	EXPECT_EQ(1, test_case->disabled_test_count());
	EXPECT_EQ(0, test_case->test_to_run_count());
	ASSERT_EQ(1, test_case->total_test_count());

	const TestInfo* const test_info = test_case->GetTestInfo(0);
	EXPECT_STREQ("Dummy2", test_info->name());
	EXPECT_STREQ("DISABLED_Test", test_info->test_case_name());
	EXPECT_TRUE(IsNull(test_info->value_param()));
	EXPECT_TRUE(IsNull(test_info->type_param()));
	EXPECT_FALSE(test_info->should_run());
	}

	// These two tests are here to provide support for testing
	// test_case_to_run_count, disabled_test_count, and test_to_run_count.
	TEST(ApiTest, DISABLED_Dummy1) {}
	TEST(DISABLED_Test, Dummy2) {}

	class FinalSuccessChecker : public Environment {
	protected:
	virtual void TearDown() {
	UnitTest* unit_test = UnitTest::GetInstance();

	EXPECT_EQ(1 + kTypedTestCases, unit_test->successful_test_case_count());
	EXPECT_EQ(3 + kTypedTests, unit_test->successful_test_count());
	EXPECT_EQ(0, unit_test->failed_test_case_count());
	EXPECT_EQ(0, unit_test->failed_test_count());
	EXPECT_TRUE(unit_test->Passed());
	EXPECT_FALSE(unit_test->Failed());
	ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count());

	const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases();

	EXPECT_STREQ("ApiTest", test_cases[0]->name());
	EXPECT_TRUE(IsNull(test_cases[0]->type_param()));
	EXPECT_TRUE(test_cases[0]->should_run());
	EXPECT_EQ(1, test_cases[0]->disabled_test_count());
	ASSERT_EQ(4, test_cases[0]->total_test_count());
	EXPECT_EQ(3, test_cases[0]->successful_test_count());
	EXPECT_EQ(0, test_cases[0]->failed_test_count());
	EXPECT_TRUE(test_cases[0]->Passed());
	EXPECT_FALSE(test_cases[0]->Failed());

	EXPECT_STREQ("DISABLED_Test", test_cases[1]->name());
	EXPECT_TRUE(IsNull(test_cases[1]->type_param()));
	EXPECT_FALSE(test_cases[1]->should_run());
	EXPECT_EQ(1, test_cases[1]->disabled_test_count());
	ASSERT_EQ(1, test_cases[1]->total_test_count());
	EXPECT_EQ(0, test_cases[1]->successful_test_count());
	EXPECT_EQ(0, test_cases[1]->failed_test_count());

	#if GTEST_HAS_TYPED_TEST
	EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name());
	EXPECT_STREQ(GetTypeName<int>().c_str(), test_cases[2]->type_param());
	EXPECT_TRUE(test_cases[2]->should_run());
	EXPECT_EQ(0, test_cases[2]->disabled_test_count());
	ASSERT_EQ(1, test_cases[2]->total_test_count());
	EXPECT_EQ(1, test_cases[2]->successful_test_count());
	EXPECT_EQ(0, test_cases[2]->failed_test_count());
	EXPECT_TRUE(test_cases[2]->Passed());
	EXPECT_FALSE(test_cases[2]->Failed());
	#endif // GTEST_HAS_TYPED_TEST

	const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest");
	const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case);
	EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name());
	EXPECT_STREQ("ApiTest", tests[0]->test_case_name());
	EXPECT_FALSE(tests[0]->should_run());

	EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name());
	EXPECT_STREQ("ApiTest", tests[1]->test_case_name());
	EXPECT_TRUE(IsNull(tests[1]->value_param()));
	EXPECT_TRUE(IsNull(tests[1]->type_param()));
	EXPECT_TRUE(tests[1]->should_run());
	EXPECT_TRUE(tests[1]->result()->Passed());
	EXPECT_EQ(0, tests[1]->result()->test_property_count());

	EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name());
	EXPECT_STREQ("ApiTest", tests[2]->test_case_name());
	EXPECT_TRUE(IsNull(tests[2]->value_param()));
	EXPECT_TRUE(IsNull(tests[2]->type_param()));
	EXPECT_TRUE(tests[2]->should_run());
	EXPECT_TRUE(tests[2]->result()->Passed());
	EXPECT_EQ(0, tests[2]->result()->test_property_count());

	EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name());
	EXPECT_STREQ("ApiTest", tests[3]->test_case_name());
	EXPECT_TRUE(IsNull(tests[3]->value_param()));
	EXPECT_TRUE(IsNull(tests[3]->type_param()));
	EXPECT_TRUE(tests[3]->should_run());
	EXPECT_TRUE(tests[3]->result()->Passed());
	EXPECT_EQ(1, tests[3]->result()->test_property_count());
	const TestProperty& property = tests[3]->result()->GetTestProperty(0);
	EXPECT_STREQ("key", property.key());
	EXPECT_STREQ("value", property.value());

	delete[] tests;

	#if GTEST_HAS_TYPED_TEST
	test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0");
	tests = UnitTestHelper::GetSortedTests(test_case);

	EXPECT_STREQ("Dummy", tests[0]->name());
	EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name());
	EXPECT_TRUE(IsNull(tests[0]->value_param()));
	EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param());
	EXPECT_TRUE(tests[0]->should_run());
	EXPECT_TRUE(tests[0]->result()->Passed());
	EXPECT_EQ(0, tests[0]->result()->test_property_count());

	delete[] tests;
	#endif // GTEST_HAS_TYPED_TEST
	delete[] test_cases;
	}
	};

	} // namespace internal
	} // namespace testing

	int main(int argc, char **argv) {
	InitGoogleTest(&argc, argv);

	AddGlobalTestEnvironment(new testing::internal::FinalSuccessChecker());

	return RUN_ALL_TESTS();
	}