"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "googletest/test/googletest-param-test-test.cc" between
googletest-release-1.11.0.tar.gz and googletest-release-1.12.0.tar.gz

About: GoogleTest is Google's (unit) testing and mocking framework for C++ tests.

googletest-param-test-test.cc  (googletest-release-1.11.0)	:	googletest-param-test-test.cc  (googletest-release-1.12.0)
skipping to change at line 35		skipping to change at line 35
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY		// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT		// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE		// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.		// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//		//
// Tests for Google Test itself. This file verifies that the parameter		// Tests for Google Test itself. This file verifies that the parameter
// generators objects produce correct parameter sequences and that		// generators objects produce correct parameter sequences and that
// Google Test runtime instantiates correct tests from those sequences.		// Google Test runtime instantiates correct tests from those sequences.
#include "gtest/gtest.h"		#include "test/googletest-param-test-test.h"
# include <algorithm>		#include <algorithm>
# include <iostream>		#include <iostream>
# include <list>		#include <list>
# include <set>		#include <set>
# include <sstream>		#include <sstream>
# include <string>		#include <string>
# include <vector>		#include <vector>
# include "src/gtest-internal-inl.h" // for UnitTestOptions		#include "gtest/gtest.h"
# include "test/googletest-param-test-test.h"		#include "src/gtest-internal-inl.h" // for UnitTestOptions
using ::std::vector;
using ::std::sort;		using ::std::sort;
		using ::std::vector;
using ::testing::AddGlobalTestEnvironment;		using ::testing::AddGlobalTestEnvironment;
using ::testing::Bool;		using ::testing::Bool;
using ::testing::Combine;		using ::testing::Combine;
using ::testing::Message;		using ::testing::Message;
using ::testing::Range;		using ::testing::Range;
using ::testing::TestWithParam;		using ::testing::TestWithParam;
using ::testing::Values;		using ::testing::Values;
using ::testing::ValuesIn;		using ::testing::ValuesIn;
skipping to change at line 88		skipping to change at line 88
void VerifyGenerator(const ParamGenerator<T>& generator,		void VerifyGenerator(const ParamGenerator<T>& generator,
const T (&expected_values)[N]) {		const T (&expected_values)[N]) {
typename ParamGenerator<T>::iterator it = generator.begin();		typename ParamGenerator<T>::iterator it = generator.begin();
for (size_t i = 0; i < N; ++i) {		for (size_t i = 0; i < N; ++i) {
ASSERT_FALSE(it == generator.end())		ASSERT_FALSE(it == generator.end())
<< "At element " << i << " when accessing via an iterator "		<< "At element " << i << " when accessing via an iterator "
<< "created with the copy constructor.\n";		<< "created with the copy constructor.\n";
// We cannot use EXPECT_EQ() here as the values may be tuples,		// We cannot use EXPECT_EQ() here as the values may be tuples,
// which don't support <<.		// which don't support <<.
EXPECT_TRUE(expected_values[i] == *it)		EXPECT_TRUE(expected_values[i] == *it)
<< "where i is " << i		<< "where i is " << i << ", expected_values[i] is "
<< ", expected_values[i] is " << PrintValue(expected_values[i])		<< PrintValue(expected_values[i]) << ", *it is " << PrintValue(*it)
<< ", *it is " << PrintValue(*it)
<< ", and 'it' is an iterator created with the copy constructor.\n";		<< ", and 'it' is an iterator created with the copy constructor.\n";
++it;		++it;
}		}
EXPECT_TRUE(it == generator.end())		EXPECT_TRUE(it == generator.end())
<< "At the presumed end of sequence when accessing via an iterator "		<< "At the presumed end of sequence when accessing via an iterator "
<< "created with the copy constructor.\n";		<< "created with the copy constructor.\n";
// Test the iterator assignment. The following lines verify that		// Test the iterator assignment. The following lines verify that
// the sequence accessed via an iterator initialized via the		// the sequence accessed via an iterator initialized via the
// assignment operator (as opposed to a copy constructor) matches		// assignment operator (as opposed to a copy constructor) matches
// just the same.		// just the same.
it = generator.begin();		it = generator.begin();
for (size_t i = 0; i < N; ++i) {		for (size_t i = 0; i < N; ++i) {
ASSERT_FALSE(it == generator.end())		ASSERT_FALSE(it == generator.end())
<< "At element " << i << " when accessing via an iterator "		<< "At element " << i << " when accessing via an iterator "
<< "created with the assignment operator.\n";		<< "created with the assignment operator.\n";
EXPECT_TRUE(expected_values[i] == *it)		EXPECT_TRUE(expected_values[i] == *it)
<< "where i is " << i		<< "where i is " << i << ", expected_values[i] is "
<< ", expected_values[i] is " << PrintValue(expected_values[i])		<< PrintValue(expected_values[i]) << ", *it is " << PrintValue(*it)
<< ", *it is " << PrintValue(*it)
<< ", and 'it' is an iterator created with the copy constructor.\n";		<< ", and 'it' is an iterator created with the copy constructor.\n";
++it;		++it;
}		}
EXPECT_TRUE(it == generator.end())		EXPECT_TRUE(it == generator.end())
<< "At the presumed end of sequence when accessing via an iterator "		<< "At the presumed end of sequence when accessing via an iterator "
<< "created with the assignment operator.\n";		<< "created with the assignment operator.\n";
}		}
template <typename T>		template <typename T>
void VerifyGeneratorIsEmpty(const ParamGenerator<T>& generator) {		void VerifyGeneratorIsEmpty(const ParamGenerator<T>& generator) {
typename ParamGenerator<T>::iterator it = generator.begin();		typename ParamGenerator<T>::iterator it = generator.begin();
EXPECT_TRUE(it == generator.end());		EXPECT_TRUE(it == generator.end());
it = generator.begin();		it = generator.begin();
EXPECT_TRUE(it == generator.end());		EXPECT_TRUE(it == generator.end());
}		}
skipping to change at line 219		skipping to change at line 217
}		}
// Verifies that Range works with user-defined types that define		// Verifies that Range works with user-defined types that define
// copy constructor, operator=(), operator+(), and operator<().		// copy constructor, operator=(), operator+(), and operator<().
class DogAdder {		class DogAdder {
public:		public:
explicit DogAdder(const char* a_value) : value_(a_value) {}		explicit DogAdder(const char* a_value) : value_(a_value) {}
DogAdder(const DogAdder& other) : value_(other.value_.c_str()) {}		DogAdder(const DogAdder& other) : value_(other.value_.c_str()) {}
DogAdder operator=(const DogAdder& other) {		DogAdder operator=(const DogAdder& other) {
if (this != &other)		if (this != &other) value_ = other.value_;
value_ = other.value_;
return *this;		return *this;
}		}
DogAdder operator+(const DogAdder& other) const {		DogAdder operator+(const DogAdder& other) const {
Message msg;		Message msg;
msg << value_.c_str() << other.value_.c_str();		msg << value_.c_str() << other.value_.c_str();
return DogAdder(msg.GetString().c_str());		return DogAdder(msg.GetString().c_str());
}		}
bool operator<(const DogAdder& other) const {		bool operator<(const DogAdder& other) const { return value_ < other.value_; }
return value_ < other.value_;
}
const std::string& value() const { return value_; }		const std::string& value() const { return value_; }
private:		private:
std::string value_;		std::string value_;
};		};
TEST(RangeTest, WorksWithACustomType) {		TEST(RangeTest, WorksWithACustomType) {
const ParamGenerator<DogAdder> gen =		const ParamGenerator<DogAdder> gen =
Range(DogAdder("cat"), DogAdder("catdogdog"), DogAdder("dog"));		Range(DogAdder("cat"), DogAdder("catdogdog"), DogAdder("dog"));
ParamGenerator<DogAdder>::iterator it = gen.begin();		ParamGenerator<DogAdder>::iterator it = gen.begin();
skipping to change at line 375		skipping to change at line 370
// Tests that Values() generates the expected sequences from elements of		// Tests that Values() generates the expected sequences from elements of
// different types convertible to ParamGenerator's parameter type.		// different types convertible to ParamGenerator's parameter type.
TEST(ValuesTest, ValuesWorksForValuesOfCompatibleTypes) {		TEST(ValuesTest, ValuesWorksForValuesOfCompatibleTypes) {
const ParamGenerator<double> gen = Values(3, 5.0f, 8.0);		const ParamGenerator<double> gen = Values(3, 5.0f, 8.0);
const double expected_values[] = {3.0, 5.0, 8.0};		const double expected_values[] = {3.0, 5.0, 8.0};
VerifyGenerator(gen, expected_values);		VerifyGenerator(gen, expected_values);
}		}
TEST(ValuesTest, ValuesWorksForMaxLengthList) {		TEST(ValuesTest, ValuesWorksForMaxLengthList) {
const ParamGenerator<int> gen = Values(		const ParamGenerator<int> gen =
10, 20, 30, 40, 50, 60, 70, 80, 90, 100,		Values(10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150,
110, 120, 130, 140, 150, 160, 170, 180, 190, 200,		160, 170, 180, 190, 200, 210, 220, 230, 240, 250, 260, 270, 280,
210, 220, 230, 240, 250, 260, 270, 280, 290, 300,		290, 300, 310, 320, 330, 340, 350, 360, 370, 380, 390, 400, 410,
310, 320, 330, 340, 350, 360, 370, 380, 390, 400,		420, 430, 440, 450, 460, 470, 480, 490, 500);
410, 420, 430, 440, 450, 460, 470, 480, 490, 500);
const int expected_values[] = {		const int expected_values[] = {
10, 20, 30, 40, 50, 60, 70, 80, 90, 100,		10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130,
110, 120, 130, 140, 150, 160, 170, 180, 190, 200,		140, 150, 160, 170, 180, 190, 200, 210, 220, 230, 240, 250, 260,
210, 220, 230, 240, 250, 260, 270, 280, 290, 300,		270, 280, 290, 300, 310, 320, 330, 340, 350, 360, 370, 380, 390,
310, 320, 330, 340, 350, 360, 370, 380, 390, 400,		400, 410, 420, 430, 440, 450, 460, 470, 480, 490, 500};
410, 420, 430, 440, 450, 460, 470, 480, 490, 500};
VerifyGenerator(gen, expected_values);		VerifyGenerator(gen, expected_values);
}		}
// Edge case test. Tests that single-parameter Values() generates the sequence		// Edge case test. Tests that single-parameter Values() generates the sequence
// with the single value.		// with the single value.
TEST(ValuesTest, ValuesWithSingleParameter) {		TEST(ValuesTest, ValuesWithSingleParameter) {
const ParamGenerator<int> gen = Values(42);		const ParamGenerator<int> gen = Values(42);
const int expected_values[] = {42};		const int expected_values[] = {42};
VerifyGenerator(gen, expected_values);		VerifyGenerator(gen, expected_values);
skipping to change at line 575		skipping to change at line 568
void TearDown() override {		void TearDown() override {
// If all MultipleTestGenerationTest tests have been de-selected		// If all MultipleTestGenerationTest tests have been de-selected
// by the filter flag, the following checks make no sense.		// by the filter flag, the following checks make no sense.
bool perform_check = false;		bool perform_check = false;
for (int i = 0; i < kExpectedCalls; ++i) {		for (int i = 0; i < kExpectedCalls; ++i) {
Message msg;		Message msg;
msg << "TestsExpandedAndRun/" << i;		msg << "TestsExpandedAndRun/" << i;
if (UnitTestOptions::FilterMatchesTest(		if (UnitTestOptions::FilterMatchesTest(
"TestExpansionModule/MultipleTestGenerationTest",		"TestExpansionModule/MultipleTestGenerationTest",
msg.GetString().c_str())) {		msg.GetString().c_str())) {
perform_check = true;		perform_check = true;
}		}
}		}
if (perform_check) {		if (perform_check) {
EXPECT_EQ(kExpectedCalls, fixture_constructor_count_)		EXPECT_EQ(kExpectedCalls, fixture_constructor_count_)
<< "Fixture constructor of ParamTestGenerationTest test case "		<< "Fixture constructor of ParamTestGenerationTest test case "
<< "has not been run as expected.";		<< "has not been run as expected.";
EXPECT_EQ(kExpectedCalls, set_up_count_)		EXPECT_EQ(kExpectedCalls, set_up_count_)
<< "Fixture SetUp method of ParamTestGenerationTest test case "		<< "Fixture SetUp method of ParamTestGenerationTest test case "
skipping to change at line 597		skipping to change at line 590
EXPECT_EQ(kExpectedCalls, tear_down_count_)		EXPECT_EQ(kExpectedCalls, tear_down_count_)
<< "Fixture TearDown method of ParamTestGenerationTest test case "		<< "Fixture TearDown method of ParamTestGenerationTest test case "
<< "has not been run as expected.";		<< "has not been run as expected.";
EXPECT_EQ(kExpectedCalls, test_body_count_)		EXPECT_EQ(kExpectedCalls, test_body_count_)
<< "Test in ParamTestGenerationTest test case "		<< "Test in ParamTestGenerationTest test case "
<< "has not been run as expected.";		<< "has not been run as expected.";
}		}
}		}
private:		private:
TestGenerationEnvironment() : fixture_constructor_count_(0), set_up_count_(0),		TestGenerationEnvironment()
tear_down_count_(0), test_body_count_(0) {}		: fixture_constructor_count_(0),
		set_up_count_(0),
		tear_down_count_(0),
		test_body_count_(0) {}
int fixture_constructor_count_;		int fixture_constructor_count_;
int set_up_count_;		int set_up_count_;
int tear_down_count_;		int tear_down_count_;
int test_body_count_;		int test_body_count_;
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationEnvironment);		TestGenerationEnvironment(const TestGenerationEnvironment&) = delete;
		TestGenerationEnvironment& operator=(const TestGenerationEnvironment&) =
		delete;
};		};
const int test_generation_params[] = {36, 42, 72};		const int test_generation_params[] = {36, 42, 72};
class TestGenerationTest : public TestWithParam<int> {		class TestGenerationTest : public TestWithParam<int> {
public:		public:
enum {		enum {
PARAMETER_COUNT =		PARAMETER_COUNT =
sizeof(test_generation_params)/sizeof(test_generation_params[0])		sizeof(test_generation_params) / sizeof(test_generation_params[0])
};		};
typedef TestGenerationEnvironment<PARAMETER_COUNT> Environment;		typedef TestGenerationEnvironment<PARAMETER_COUNT> Environment;
TestGenerationTest() {		TestGenerationTest() {
Environment::Instance()->FixtureConstructorExecuted();		Environment::Instance()->FixtureConstructorExecuted();
current_parameter_ = GetParam();		current_parameter_ = GetParam();
}		}
void SetUp() override {		void SetUp() override {
Environment::Instance()->SetUpExecuted();		Environment::Instance()->SetUpExecuted();
skipping to change at line 638		skipping to change at line 636
Environment::Instance()->TearDownExecuted();		Environment::Instance()->TearDownExecuted();
EXPECT_EQ(current_parameter_, GetParam());		EXPECT_EQ(current_parameter_, GetParam());
}		}
static void SetUpTestSuite() {		static void SetUpTestSuite() {
bool all_tests_in_test_case_selected = true;		bool all_tests_in_test_case_selected = true;
for (int i = 0; i < PARAMETER_COUNT; ++i) {		for (int i = 0; i < PARAMETER_COUNT; ++i) {
Message test_name;		Message test_name;
test_name << "TestsExpandedAndRun/" << i;		test_name << "TestsExpandedAndRun/" << i;
if ( !UnitTestOptions::FilterMatchesTest(		if (!UnitTestOptions::FilterMatchesTest(
"TestExpansionModule/MultipleTestGenerationTest",		"TestExpansionModule/MultipleTestGenerationTest",
test_name.GetString())) {		test_name.GetString())) {
all_tests_in_test_case_selected = false;		all_tests_in_test_case_selected = false;
}		}
}		}
EXPECT_TRUE(all_tests_in_test_case_selected)		EXPECT_TRUE(all_tests_in_test_case_selected)
<< "When running the TestGenerationTest test case all of its tests\n"		<< "When running the TestGenerationTest test case all of its tests\n"
<< "must be selected by the filter flag for the test case to pass.\n"		<< "must be selected by the filter flag for the test case to pass.\n"
<< "If not all of them are enabled, we can't reliably conclude\n"		<< "If not all of them are enabled, we can't reliably conclude\n"
<< "that the correct number of tests have been generated.";		<< "that the correct number of tests have been generated.";
collected_parameters_.clear();		collected_parameters_.clear();
skipping to change at line 670		skipping to change at line 668
sort(collected_parameters_.begin(), collected_parameters_.end());		sort(collected_parameters_.begin(), collected_parameters_.end());
EXPECT_TRUE(collected_parameters_ == expected_values);		EXPECT_TRUE(collected_parameters_ == expected_values);
}		}
protected:		protected:
int current_parameter_;		int current_parameter_;
static vector<int> collected_parameters_;		static vector<int> collected_parameters_;
private:		private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationTest);		TestGenerationTest(const TestGenerationTest&) = delete;
		TestGenerationTest& operator=(const TestGenerationTest&) = delete;
};		};
vector<int> TestGenerationTest::collected_parameters_;		vector<int> TestGenerationTest::collected_parameters_;
TEST_P(TestGenerationTest, TestsExpandedAndRun) {		TEST_P(TestGenerationTest, TestsExpandedAndRun) {
Environment::Instance()->TestBodyExecuted();		Environment::Instance()->TestBodyExecuted();
EXPECT_EQ(current_parameter_, GetParam());		EXPECT_EQ(current_parameter_, GetParam());
collected_parameters_.push_back(GetParam());		collected_parameters_.push_back(GetParam());
}		}
INSTANTIATE_TEST_SUITE_P(TestExpansionModule, TestGenerationTest,		INSTANTIATE_TEST_SUITE_P(TestExpansionModule, TestGenerationTest,
ValuesIn(test_generation_params));		ValuesIn(test_generation_params));
skipping to change at line 731		skipping to change at line 730
// unit and instantiated in another. This test will be instantiated in		// unit and instantiated in another. This test will be instantiated in
// gtest-param-test_test2.cc. ExternalInstantiationTest fixture class is		// gtest-param-test_test2.cc. ExternalInstantiationTest fixture class is
// defined in gtest-param-test_test.h.		// defined in gtest-param-test_test.h.
TEST_P(ExternalInstantiationTest, IsMultipleOf33) {		TEST_P(ExternalInstantiationTest, IsMultipleOf33) {
EXPECT_EQ(0, GetParam() % 33);		EXPECT_EQ(0, GetParam() % 33);
}		}
// Tests that a parameterized test case can be instantiated with multiple		// Tests that a parameterized test case can be instantiated with multiple
// generators.		// generators.
class MultipleInstantiationTest : public TestWithParam<int> {};		class MultipleInstantiationTest : public TestWithParam<int> {};
TEST_P(MultipleInstantiationTest, AllowsMultipleInstances) {		TEST_P(MultipleInstantiationTest, AllowsMultipleInstances) {}
}
INSTANTIATE_TEST_SUITE_P(Sequence1, MultipleInstantiationTest, Values(1, 2));		INSTANTIATE_TEST_SUITE_P(Sequence1, MultipleInstantiationTest, Values(1, 2));
INSTANTIATE_TEST_SUITE_P(Sequence2, MultipleInstantiationTest, Range(3, 5));		INSTANTIATE_TEST_SUITE_P(Sequence2, MultipleInstantiationTest, Range(3, 5));
// Tests that a parameterized test case can be instantiated		// Tests that a parameterized test case can be instantiated
// in multiple translation units. This test will be instantiated		// in multiple translation units. This test will be instantiated
// here and in gtest-param-test_test2.cc.		// here and in gtest-param-test_test2.cc.
// InstantiationInMultipleTranslationUnitsTest fixture class		// InstantiationInMultipleTranslationUnitsTest fixture class
// is defined in gtest-param-test_test.h.		// is defined in gtest-param-test_test.h.
TEST_P(InstantiationInMultipleTranslationUnitsTest, IsMultipleOf42) {		TEST_P(InstantiationInMultipleTranslationUnitsTest, IsMultipleOf42) {
EXPECT_EQ(0, GetParam() % 42);		EXPECT_EQ(0, GetParam() % 42);
skipping to change at line 782		skipping to change at line 780
// Tests that all instantiations of a test have named appropriately. Test		// Tests that all instantiations of a test have named appropriately. Test
// defined with TEST_P(TestSuiteName, TestName) and instantiated with		// defined with TEST_P(TestSuiteName, TestName) and instantiated with
// INSTANTIATE_TEST_SUITE_P(SequenceName, TestSuiteName, generator) must be		// INSTANTIATE_TEST_SUITE_P(SequenceName, TestSuiteName, generator) must be
// named SequenceName/TestSuiteName.TestName/i, where i is the 0-based index of		// named SequenceName/TestSuiteName.TestName/i, where i is the 0-based index of
// the sequence element used to instantiate the test.		// the sequence element used to instantiate the test.
class NamingTest : public TestWithParam<int> {};		class NamingTest : public TestWithParam<int> {};
TEST_P(NamingTest, TestsReportCorrectNamesAndParameters) {		TEST_P(NamingTest, TestsReportCorrectNamesAndParameters) {
const ::testing::TestInfo* const test_info =		const ::testing::TestInfo* const test_info =
::testing::UnitTest::GetInstance()->current_test_info();		::testing::UnitTest::GetInstance()->current_test_info();
EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_suite_name());		EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_suite_name());
Message index_stream;		Message index_stream;
index_stream << "TestsReportCorrectNamesAndParameters/" << GetParam();		index_stream << "TestsReportCorrectNamesAndParameters/" << GetParam();
EXPECT_STREQ(index_stream.GetString().c_str(), test_info->name());		EXPECT_STREQ(index_stream.GetString().c_str(), test_info->name());
EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());		EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());
}		}
INSTANTIATE_TEST_SUITE_P(ZeroToFiveSequence, NamingTest, Range(0, 5));		INSTANTIATE_TEST_SUITE_P(ZeroToFiveSequence, NamingTest, Range(0, 5));
// Tests that macros in test names are expanded correctly.		// Tests that macros in test names are expanded correctly.
class MacroNamingTest : public TestWithParam<int> {};		class MacroNamingTest : public TestWithParam<int> {};
#define PREFIX_WITH_FOO(test_name) Foo##test_name		#define PREFIX_WITH_FOO(test_name) Foo##test_name
#define PREFIX_WITH_MACRO(test_name) Macro##test_name		#define PREFIX_WITH_MACRO(test_name) Macro##test_name
TEST_P(PREFIX_WITH_MACRO(NamingTest), PREFIX_WITH_FOO(SomeTestName)) {		TEST_P(PREFIX_WITH_MACRO(NamingTest), PREFIX_WITH_FOO(SomeTestName)) {
const ::testing::TestInfo* const test_info =		const ::testing::TestInfo* const test_info =
::testing::UnitTest::GetInstance()->current_test_info();		::testing::UnitTest::GetInstance()->current_test_info();
EXPECT_STREQ("FortyTwo/MacroNamingTest", test_info->test_suite_name());		EXPECT_STREQ("FortyTwo/MacroNamingTest", test_info->test_suite_name());
EXPECT_STREQ("FooSomeTestName/0", test_info->name());		EXPECT_STREQ("FooSomeTestName/0", test_info->name());
}		}
INSTANTIATE_TEST_SUITE_P(FortyTwo, MacroNamingTest, Values(42));		INSTANTIATE_TEST_SUITE_P(FortyTwo, MacroNamingTest, Values(42));
// Tests the same thing for non-parametrized tests.		// Tests the same thing for non-parametrized tests.
class MacroNamingTestNonParametrized : public ::testing::Test {};		class MacroNamingTestNonParametrized : public ::testing::Test {};
TEST_F(PREFIX_WITH_MACRO(NamingTestNonParametrized),		TEST_F(PREFIX_WITH_MACRO(NamingTestNonParametrized),
PREFIX_WITH_FOO(SomeTestName)) {		PREFIX_WITH_FOO(SomeTestName)) {
const ::testing::TestInfo* const test_info =		const ::testing::TestInfo* const test_info =
::testing::UnitTest::GetInstance()->current_test_info();		::testing::UnitTest::GetInstance()->current_test_info();
EXPECT_STREQ("MacroNamingTestNonParametrized", test_info->test_suite_name());		EXPECT_STREQ("MacroNamingTestNonParametrized", test_info->test_suite_name());
EXPECT_STREQ("FooSomeTestName", test_info->name());		EXPECT_STREQ("FooSomeTestName", test_info->name());
}		}
TEST(MacroNameing, LookupNames) {		TEST(MacroNameing, LookupNames) {
std::set<std::string> know_suite_names, know_test_names;		std::set<std::string> know_suite_names, know_test_names;
auto ins = testing::UnitTest::GetInstance();		auto ins = testing::UnitTest::GetInstance();
int ts = 0;		int ts = 0;
skipping to change at line 841		skipping to change at line 839
int ti = 0;		int ti = 0;
while (const testing::TestInfo* info = suite->GetTestInfo(ti++)) {		while (const testing::TestInfo* info = suite->GetTestInfo(ti++)) {
know_test_names.insert(std::string(suite->name()) + "." + info->name());		know_test_names.insert(std::string(suite->name()) + "." + info->name());
}		}
}		}
// Check that the expected form of the test suit name actually exists.		// Check that the expected form of the test suit name actually exists.
EXPECT_NE( //		EXPECT_NE( //
know_suite_names.find("FortyTwo/MacroNamingTest"),		know_suite_names.find("FortyTwo/MacroNamingTest"),
know_suite_names.end());		know_suite_names.end());
EXPECT_NE(		EXPECT_NE(know_suite_names.find("MacroNamingTestNonParametrized"),
know_suite_names.find("MacroNamingTestNonParametrized"),		know_suite_names.end());
know_suite_names.end());
// Check that the expected form of the test name actually exists.		// Check that the expected form of the test name actually exists.
EXPECT_NE( //		EXPECT_NE( //
know_test_names.find("FortyTwo/MacroNamingTest.FooSomeTestName/0"),		know_test_names.find("FortyTwo/MacroNamingTest.FooSomeTestName/0"),
know_test_names.end());		know_test_names.end());
EXPECT_NE(		EXPECT_NE(
know_test_names.find("MacroNamingTestNonParametrized.FooSomeTestName"),		know_test_names.find("MacroNamingTestNonParametrized.FooSomeTestName"),
know_test_names.end());		know_test_names.end());
}		}
// Tests that user supplied custom parameter names are working correctly.		// Tests that user supplied custom parameter names are working correctly.
skipping to change at line 926		skipping to change at line 923
EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctionNameP"));		EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctionNameP"));
EXPECT_EQ(1u, test_names.count("CustomTestNames/LambdaName"));		EXPECT_EQ(1u, test_names.count("CustomTestNames/LambdaName"));
}		}
// Test a numeric name to ensure PrintToStringParamName works correctly.		// Test a numeric name to ensure PrintToStringParamName works correctly.
class CustomIntegerNamingTest : public TestWithParam<int> {};		class CustomIntegerNamingTest : public TestWithParam<int> {};
TEST_P(CustomIntegerNamingTest, TestsReportCorrectNames) {		TEST_P(CustomIntegerNamingTest, TestsReportCorrectNames) {
const ::testing::TestInfo* const test_info =		const ::testing::TestInfo* const test_info =
::testing::UnitTest::GetInstance()->current_test_info();		::testing::UnitTest::GetInstance()->current_test_info();
Message test_name_stream;		Message test_name_stream;
test_name_stream << "TestsReportCorrectNames/" << GetParam();		test_name_stream << "TestsReportCorrectNames/" << GetParam();
EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());		EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
}		}
INSTANTIATE_TEST_SUITE_P(PrintToString, CustomIntegerNamingTest, Range(0, 5),		INSTANTIATE_TEST_SUITE_P(PrintToString, CustomIntegerNamingTest, Range(0, 5),
::testing::PrintToStringParamName());		::testing::PrintToStringParamName());
// Test a custom struct with PrintToString.		// Test a custom struct with PrintToString.
skipping to change at line 951		skipping to change at line 948
std::ostream& operator<<(std::ostream& stream, const CustomStruct& val) {		std::ostream& operator<<(std::ostream& stream, const CustomStruct& val) {
stream << val.x;		stream << val.x;
return stream;		return stream;
}		}
class CustomStructNamingTest : public TestWithParam<CustomStruct> {};		class CustomStructNamingTest : public TestWithParam<CustomStruct> {};
TEST_P(CustomStructNamingTest, TestsReportCorrectNames) {		TEST_P(CustomStructNamingTest, TestsReportCorrectNames) {
const ::testing::TestInfo* const test_info =		const ::testing::TestInfo* const test_info =
::testing::UnitTest::GetInstance()->current_test_info();		::testing::UnitTest::GetInstance()->current_test_info();
Message test_name_stream;		Message test_name_stream;
test_name_stream << "TestsReportCorrectNames/" << GetParam();		test_name_stream << "TestsReportCorrectNames/" << GetParam();
EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());		EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
}		}
INSTANTIATE_TEST_SUITE_P(PrintToString, CustomStructNamingTest,		INSTANTIATE_TEST_SUITE_P(PrintToString, CustomStructNamingTest,
Values(CustomStruct(0), CustomStruct(1)),		Values(CustomStruct(0), CustomStruct(1)),
::testing::PrintToStringParamName());		::testing::PrintToStringParamName());
// Test that using a stateful parameter naming function works as expected.		// Test that using a stateful parameter naming function works as expected.
skipping to change at line 981		skipping to change at line 978
};		};
class StatefulNamingTest : public ::testing::TestWithParam<int> {		class StatefulNamingTest : public ::testing::TestWithParam<int> {
protected:		protected:
StatefulNamingTest() : sum_(0) {}		StatefulNamingTest() : sum_(0) {}
int sum_;		int sum_;
};		};
TEST_P(StatefulNamingTest, TestsReportCorrectNames) {		TEST_P(StatefulNamingTest, TestsReportCorrectNames) {
const ::testing::TestInfo* const test_info =		const ::testing::TestInfo* const test_info =
::testing::UnitTest::GetInstance()->current_test_info();		::testing::UnitTest::GetInstance()->current_test_info();
sum_ += GetParam();		sum_ += GetParam();
Message test_name_stream;		Message test_name_stream;
test_name_stream << "TestsReportCorrectNames/" << sum_;		test_name_stream << "TestsReportCorrectNames/" << sum_;
EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());		EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
}		}
INSTANTIATE_TEST_SUITE_P(StatefulNamingFunctor, StatefulNamingTest, Range(0, 5),		INSTANTIATE_TEST_SUITE_P(StatefulNamingFunctor, StatefulNamingTest, Range(0, 5),
StatefulNamingFunctor());		StatefulNamingFunctor());
// Class that cannot be streamed into an ostream. It needs to be copyable		// Class that cannot be streamed into an ostream. It needs to be copyable
skipping to change at line 1009		skipping to change at line 1006
const int& dummy_value() const { return value_; }		const int& dummy_value() const { return value_; }
private:		private:
int value_;		int value_;
};		};
class CommentTest : public TestWithParam<Unstreamable> {};		class CommentTest : public TestWithParam<Unstreamable> {};
TEST_P(CommentTest, TestsCorrectlyReportUnstreamableParams) {		TEST_P(CommentTest, TestsCorrectlyReportUnstreamableParams) {
const ::testing::TestInfo* const test_info =		const ::testing::TestInfo* const test_info =
::testing::UnitTest::GetInstance()->current_test_info();		::testing::UnitTest::GetInstance()->current_test_info();
EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());		EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());
}		}
INSTANTIATE_TEST_SUITE_P(InstantiationWithComments, CommentTest,		INSTANTIATE_TEST_SUITE_P(InstantiationWithComments, CommentTest,
Values(Unstreamable(1)));		Values(Unstreamable(1)));
// Verify that we can create a hierarchy of test fixtures, where the base		// Verify that we can create a hierarchy of test fixtures, where the base
// class fixture is not parameterized and the derived class is. In this case		// class fixture is not parameterized and the derived class is. In this case
// ParameterizedDerivedTest inherits from NonParameterizedBaseTest. We		// ParameterizedDerivedTest inherits from NonParameterizedBaseTest. We
// perform simple tests on both.		// perform simple tests on both.
class NonParameterizedBaseTest : public ::testing::Test {		class NonParameterizedBaseTest : public ::testing::Test {
public:		public:
NonParameterizedBaseTest() : n_(17) { }		NonParameterizedBaseTest() : n_(17) {}
protected:		protected:
int n_;		int n_;
};		};
class ParameterizedDerivedTest : public NonParameterizedBaseTest,		class ParameterizedDerivedTest : public NonParameterizedBaseTest,
public ::testing::WithParamInterface<int> {		public ::testing::WithParamInterface<int> {
protected:		protected:
ParameterizedDerivedTest() : count_(0) { }		ParameterizedDerivedTest() : count_(0) {}
int count_;		int count_;
static int global_count_;		static int global_count_;
};		};
int ParameterizedDerivedTest::global_count_ = 0;		int ParameterizedDerivedTest::global_count_ = 0;
TEST_F(NonParameterizedBaseTest, FixtureIsInitialized) {		TEST_F(NonParameterizedBaseTest, FixtureIsInitialized) { EXPECT_EQ(17, n_); }
EXPECT_EQ(17, n_);
}
TEST_P(ParameterizedDerivedTest, SeesSequence) {		TEST_P(ParameterizedDerivedTest, SeesSequence) {
EXPECT_EQ(17, n_);		EXPECT_EQ(17, n_);
EXPECT_EQ(0, count_++);		EXPECT_EQ(0, count_++);
EXPECT_EQ(GetParam(), global_count_++);		EXPECT_EQ(GetParam(), global_count_++);
}		}
class ParameterizedDeathTest : public ::testing::TestWithParam<int> { };		class ParameterizedDeathTest : public ::testing::TestWithParam<int> {};
TEST_F(ParameterizedDeathTest, GetParamDiesFromTestF) {		TEST_F(ParameterizedDeathTest, GetParamDiesFromTestF) {
EXPECT_DEATH_IF_SUPPORTED(GetParam(),		EXPECT_DEATH_IF_SUPPORTED(GetParam(), ".* value-parameterized test .*");
".* value-parameterized test .*");
}		}
INSTANTIATE_TEST_SUITE_P(RangeZeroToFive, ParameterizedDerivedTest,		INSTANTIATE_TEST_SUITE_P(RangeZeroToFive, ParameterizedDerivedTest,
Range(0, 5));		Range(0, 5));
// Tests param generator working with Enums		// Tests param generator working with Enums
enum MyEnums {		enum MyEnums {
ENUM1 = 1,		ENUM1 = 1,
ENUM2 = 3,		ENUM2 = 3,
ENUM3 = 8,		ENUM3 = 8,
skipping to change at line 1086		skipping to change at line 1081
// Never used not instantiated, this should work.		// Never used not instantiated, this should work.
template <typename T>		template <typename T>
class NotUsedTypeTest : public testing::Test {};		class NotUsedTypeTest : public testing::Test {};
TYPED_TEST_SUITE_P(NotUsedTypeTest);		TYPED_TEST_SUITE_P(NotUsedTypeTest);
// Used but not instantiated, this would fail. but...		// Used but not instantiated, this would fail. but...
class NotInstantiatedTest : public testing::TestWithParam<int> {};		class NotInstantiatedTest : public testing::TestWithParam<int> {};
// ... we mark is as allowed.		// ... we mark is as allowed.
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(NotInstantiatedTest);		GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(NotInstantiatedTest);
TEST_P(NotInstantiatedTest, Used) { }		TEST_P(NotInstantiatedTest, Used) {}
using OtherName = NotInstantiatedTest;		using OtherName = NotInstantiatedTest;
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(OtherName);		GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(OtherName);
TEST_P(OtherName, Used) { }		TEST_P(OtherName, Used) {}
// Used but not instantiated, this would fail. but...		// Used but not instantiated, this would fail. but...
template <typename T>		template <typename T>
class NotInstantiatedTypeTest : public testing::Test {};		class NotInstantiatedTypeTest : public testing::Test {};
TYPED_TEST_SUITE_P(NotInstantiatedTypeTest);		TYPED_TEST_SUITE_P(NotInstantiatedTypeTest);
// ... we mark is as allowed.		// ... we mark is as allowed.
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(NotInstantiatedTypeTest);		GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(NotInstantiatedTypeTest);
TYPED_TEST_P(NotInstantiatedTypeTest, Used) { }		TYPED_TEST_P(NotInstantiatedTypeTest, Used) {}
REGISTER_TYPED_TEST_SUITE_P(NotInstantiatedTypeTest, Used);		REGISTER_TYPED_TEST_SUITE_P(NotInstantiatedTypeTest, Used);
} // namespace works_here		} // namespace works_here
int main(int argc, char **argv) {		int main(int argc, char** argv) {
// Used in TestGenerationTest test suite.		// Used in TestGenerationTest test suite.
AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());		AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());
// Used in GeneratorEvaluationTest test suite. Tests that the updated value		// Used in GeneratorEvaluationTest test suite. Tests that the updated value
// will be picked up for instantiating tests in GeneratorEvaluationTest.		// will be picked up for instantiating tests in GeneratorEvaluationTest.
GeneratorEvaluationTest::set_param_value(1);		GeneratorEvaluationTest::set_param_value(1);
::testing::InitGoogleTest(&argc, argv);		::testing::InitGoogleTest(&argc, argv);
// Used in GeneratorEvaluationTest test suite. Tests that value updated		// Used in GeneratorEvaluationTest test suite. Tests that value updated
// here will NOT be used for instantiating tests in		// here will NOT be used for instantiating tests in
End of changes. 37 change blocks.
70 lines changed or deleted		65 lines changed or added

---