googletest-param-test-test.cc File Reference

#include "gtest/gtest.h"
#include <algorithm>
#include <iostream>
#include <list>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#include "src/gtest-internal-inl.h"
#include "test/googletest-param-test-test.h"

Go to the source code of this file.

Classes
class	DogAdder
class	IntWrapper
class	NonDefaultConstructAssignString
class	TestGenerationEnvironment< kExpectedCalls >
class	TestGenerationTest
class	GeneratorEvaluationTest
class	ExternalGeneratorTest
class	MultipleInstantiationTest
class	SeparateInstanceTest
class	NamingTest
class	MacroNamingTest
class	MacroNamingTestNonParametrized
class	CustomFunctorNamingTest
struct	CustomParamNameFunctor
class	CustomFunctionNamingTest
class	CustomLambdaNamingTest
class	CustomIntegerNamingTest
struct	CustomStruct
class	CustomStructNamingTest
struct	StatefulNamingFunctor
class	StatefulNamingTest
class	Unstreamable
class	CommentTest
class	NonParameterizedBaseTest
class	ParameterizedDerivedTest
class	ParameterizedDeathTest
class	MyEnumTest
class	works_here::NotUsedTest
class	works_here::NotUsedTypeTest< T >
class	works_here::NotInstantiatedTest
class	works_here::NotInstantiatedTypeTest< T >

Namespaces
namespace	works_here

Macros
#define	PREFIX_WITH_FOO(test_name)   Foo##test_name
#define	PREFIX_WITH_MACRO(test_name)   Macro##test_name

Typedefs
using	works_here::OtherName = NotInstantiatedTest

Enumerations
enum	MyEnums { ENUM1 = 1 , ENUM2 = 3 , ENUM3 = 8 }

Functions
template<typename T >
::std::string	PrintValue (const T &value)
template<typename T , size_t N>
void	VerifyGenerator (const ParamGenerator< T > &generator, const T(&expected_values)[N])
template<typename T >
void	VerifyGeneratorIsEmpty (const ParamGenerator< T > &generator)
	TEST (IteratorTest, ParamIteratorConformsToForwardIteratorConcept)
	TEST (RangeTest, IntRangeWithDefaultStep)
	TEST (RangeTest, IntRangeSingleValue)
	TEST (RangeTest, IntRangeEmpty)
	TEST (RangeTest, IntRangeWithCustomStep)
	TEST (RangeTest, IntRangeWithCustomStepOverUpperBound)
	TEST (RangeTest, WorksWithACustomType)
	TEST (RangeTest, WorksWithACustomTypeWithDifferentIncrementType)
	TEST (ValuesInTest, ValuesInArray)
	TEST (ValuesInTest, ValuesInConstArray)
	TEST (ValuesInTest, ValuesInSingleElementArray)
	TEST (ValuesInTest, ValuesInVector)
	TEST (ValuesInTest, ValuesInIteratorRange)
	TEST (ValuesInTest, ValuesInSingleElementIteratorRange)
	TEST (ValuesInTest, ValuesInEmptyIteratorRange)
	TEST (ValuesTest, ValuesWorks)
	TEST (ValuesTest, ValuesWorksForValuesOfCompatibleTypes)
	TEST (ValuesTest, ValuesWorksForMaxLengthList)
	TEST (ValuesTest, ValuesWithSingleParameter)
	TEST (BoolTest, BoolWorks)
	TEST (CombineTest, CombineWithTwoParameters)
	TEST (CombineTest, CombineWithThreeParameters)
	TEST (CombineTest, CombineWithFirstParameterSingleValue)
	TEST (CombineTest, CombineWithSecondParameterSingleValue)
	TEST (CombineTest, CombineWithFirstParameterEmptyRange)
	TEST (CombineTest, CombineWithSecondParameterEmptyRange)
	TEST (CombineTest, CombineWithMaxNumberOfParameters)
	TEST (CombineTest, NonDefaultConstructAssign)
	TEST (ParamGeneratorTest, AssignmentWorks)
	TEST_P (TestGenerationTest, TestsExpandedAndRun)
	INSTANTIATE_TEST_SUITE_P (TestExpansionModule, TestGenerationTest, ValuesIn(test_generation_params))
	TEST_P (GeneratorEvaluationTest, GeneratorsEvaluatedInMain)
	INSTANTIATE_TEST_SUITE_P (GenEvalModule, GeneratorEvaluationTest, Values(GeneratorEvaluationTest::param_value()))
	TEST_P (ExternalGeneratorTest, ExternalGenerator)
	INSTANTIATE_TEST_SUITE_P (ExternalGeneratorModule, ExternalGeneratorTest, extern_gen)
	TEST_P (ExternalInstantiationTest, IsMultipleOf33)
	TEST_P (MultipleInstantiationTest, AllowsMultipleInstances)
	INSTANTIATE_TEST_SUITE_P (Sequence1, MultipleInstantiationTest, Values(1, 2))
	INSTANTIATE_TEST_SUITE_P (Sequence2, MultipleInstantiationTest, Range(3, 5))
	TEST_P (InstantiationInMultipleTranslationUnitsTest, IsMultipleOf42)
	INSTANTIATE_TEST_SUITE_P (Sequence1, InstantiationInMultipleTranslationUnitsTest, Values(42, 42 *2))
	TEST_P (SeparateInstanceTest, TestsRunInSeparateInstances)
	INSTANTIATE_TEST_SUITE_P (FourElemSequence, SeparateInstanceTest, Range(1, 4))
	TEST_P (NamingTest, TestsReportCorrectNamesAndParameters)
	INSTANTIATE_TEST_SUITE_P (ZeroToFiveSequence, NamingTest, Range(0, 5))
	TEST_P (PREFIX_WITH_MACRO(NamingTest), PREFIX_WITH_FOO(SomeTestName))
	INSTANTIATE_TEST_SUITE_P (FortyTwo, MacroNamingTest, Values(42))
	TEST_F (PREFIX_WITH_MACRO(NamingTestNonParametrized), PREFIX_WITH_FOO(SomeTestName))
	TEST (MacroNameing, LookupNames)
	TEST_P (CustomFunctorNamingTest, CustomTestNames)
	INSTANTIATE_TEST_SUITE_P (CustomParamNameFunctor, CustomFunctorNamingTest, Values(std::string("FunctorName")), CustomParamNameFunctor())
	INSTANTIATE_TEST_SUITE_P (AllAllowedCharacters, CustomFunctorNamingTest, Values("abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "01234567890_"), CustomParamNameFunctor())
std::string	CustomParamNameFunction (const ::testing::TestParamInfo< std::string > &inf)
	TEST_P (CustomFunctionNamingTest, CustomTestNames)
	INSTANTIATE_TEST_SUITE_P (CustomParamNameFunction, CustomFunctionNamingTest, Values(std::string("FunctionName")), CustomParamNameFunction)
	INSTANTIATE_TEST_SUITE_P (CustomParamNameFunctionP, CustomFunctionNamingTest, Values(std::string("FunctionNameP")), &CustomParamNameFunction)
	TEST_P (CustomLambdaNamingTest, CustomTestNames)
	INSTANTIATE_TEST_SUITE_P (CustomParamNameLambda, CustomLambdaNamingTest, Values(std::string("LambdaName")), [](const ::testing::TestParamInfo< std::string > &inf) { return inf.param;})
	TEST (CustomNamingTest, CheckNameRegistry)
	TEST_P (CustomIntegerNamingTest, TestsReportCorrectNames)
	INSTANTIATE_TEST_SUITE_P (PrintToString, CustomIntegerNamingTest, Range(0, 5), ::testing::PrintToStringParamName())
std::ostream &	operator<< (std::ostream &stream, const CustomStruct &val)
	TEST_P (CustomStructNamingTest, TestsReportCorrectNames)
	INSTANTIATE_TEST_SUITE_P (PrintToString, CustomStructNamingTest, Values(CustomStruct(0), CustomStruct(1)), ::testing::PrintToStringParamName())
	TEST_P (StatefulNamingTest, TestsReportCorrectNames)
	INSTANTIATE_TEST_SUITE_P (StatefulNamingFunctor, StatefulNamingTest, Range(0, 5), StatefulNamingFunctor())
	TEST_P (CommentTest, TestsCorrectlyReportUnstreamableParams)
	INSTANTIATE_TEST_SUITE_P (InstantiationWithComments, CommentTest, Values(Unstreamable(1)))
	TEST_F (NonParameterizedBaseTest, FixtureIsInitialized)
	TEST_P (ParameterizedDerivedTest, SeesSequence)
	TEST_F (ParameterizedDeathTest, GetParamDiesFromTestF)
	INSTANTIATE_TEST_SUITE_P (RangeZeroToFive, ParameterizedDerivedTest, Range(0, 5))
	TEST_P (MyEnumTest, ChecksParamMoreThanZero)
	INSTANTIATE_TEST_SUITE_P (MyEnumTests, MyEnumTest, ::testing::Values(ENUM1, ENUM2, 0))
	works_here::TYPED_TEST_SUITE_P (NotUsedTypeTest)
	works_here::GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST (NotInstantiatedTest)
	works_here::TEST_P (NotInstantiatedTest, Used)
	works_here::TYPED_TEST_SUITE_P (NotInstantiatedTypeTest)
	works_here::GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST (NotInstantiatedTypeTest)
	works_here::TYPED_TEST_P (NotInstantiatedTypeTest, Used)
	works_here::REGISTER_TYPED_TEST_SUITE_P (NotInstantiatedTypeTest, Used)
int	main (int argc, char **argv)

Variables
const int	test_generation_params [] = {36, 42, 72}
ParamGenerator< int >	extern_gen

Macro Definition Documentation

PREFIX_WITH_FOO

#define PREFIX_WITH_FOO

(

test_name

)

Foo##test_name

Definition at line 799 of file googletest-param-test-test.cc.

PREFIX_WITH_MACRO

#define PREFIX_WITH_MACRO

(

test_name

)

Macro##test_name

Definition at line 800 of file googletest-param-test-test.cc.

Enumeration Type Documentation

MyEnums

enum MyEnums

Enumerator
ENUM1
ENUM2
ENUM3

Definition at line 1060 of file googletest-param-test-test.cc.

             {
  ENUM1 = 1,
  ENUM2 = 3,
  ENUM3 = 8,
};

Function Documentation

CustomParamNameFunction()

std::string CustomParamNameFunction ( const ::testing::TestParamInfo< std::string > &  inf )

inline

Definition at line 876 of file googletest-param-test-test.cc.

                                                {
  return inf.param;
}

INSTANTIATE_TEST_SUITE_P() [1/20]

INSTANTIATE_TEST_SUITE_P	(	AllAllowedCharacters	,
		CustomFunctorNamingTest	,
		Values("abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "01234567890_")	,
		CustomParamNameFunctor()
	)

INSTANTIATE_TEST_SUITE_P() [2/20]

INSTANTIATE_TEST_SUITE_P	(	CustomParamNameFunction	,
		CustomFunctionNamingTest	,
		Values(std::string("FunctionName"))	,
		CustomParamNameFunction
	)

INSTANTIATE_TEST_SUITE_P() [3/20]

INSTANTIATE_TEST_SUITE_P	(	CustomParamNameFunctionP	,
		CustomFunctionNamingTest	,
		Values(std::string("FunctionNameP"))	,
		&	CustomParamNameFunction
	)

INSTANTIATE_TEST_SUITE_P() [4/20]

INSTANTIATE_TEST_SUITE_P	(	CustomParamNameFunctor	,
		CustomFunctorNamingTest	,
		Values(std::string("FunctorName"))	,
		CustomParamNameFunctor()
	)

INSTANTIATE_TEST_SUITE_P() [5/20]

INSTANTIATE_TEST_SUITE_P	(	CustomParamNameLambda	,
		CustomLambdaNamingTest	,
		Values(std::string("LambdaName"))	,
		[] (const ::testing::TestParamInfo< std::string > &inf) { return inf.param;}
	)

INSTANTIATE_TEST_SUITE_P() [6/20]

INSTANTIATE_TEST_SUITE_P	(	ExternalGeneratorModule	,
		ExternalGeneratorTest	,
		extern_gen
	)

INSTANTIATE_TEST_SUITE_P() [7/20]

INSTANTIATE_TEST_SUITE_P	(	FortyTwo	,
		MacroNamingTest	,
		Values(42)
	)

INSTANTIATE_TEST_SUITE_P() [8/20]

INSTANTIATE_TEST_SUITE_P	(	FourElemSequence	,
		SeparateInstanceTest	,
		Range(1, 4)
	)

INSTANTIATE_TEST_SUITE_P() [9/20]

INSTANTIATE_TEST_SUITE_P	(	GenEvalModule	,
		GeneratorEvaluationTest	,
		Values(GeneratorEvaluationTest::param_value())
	)

INSTANTIATE_TEST_SUITE_P() [10/20]

INSTANTIATE_TEST_SUITE_P	(	InstantiationWithComments	,
		CommentTest	,
		Values(Unstreamable(1))
	)

INSTANTIATE_TEST_SUITE_P() [11/20]

INSTANTIATE_TEST_SUITE_P	(	MyEnumTests	,
		MyEnumTest	,
		::testing::Values(ENUM1, ENUM2, 0)
	)

INSTANTIATE_TEST_SUITE_P() [12/20]

INSTANTIATE_TEST_SUITE_P	(	PrintToString	,
		CustomIntegerNamingTest	,
		Range(0, 5)	,
		::testing::PrintToStringParamName()
	)

INSTANTIATE_TEST_SUITE_P() [13/20]

INSTANTIATE_TEST_SUITE_P	(	PrintToString	,
		CustomStructNamingTest	,
		Values(CustomStruct(0), CustomStruct(1))	,
		::testing::PrintToStringParamName()
	)

INSTANTIATE_TEST_SUITE_P() [14/20]

INSTANTIATE_TEST_SUITE_P	(	RangeZeroToFive	,
		ParameterizedDerivedTest	,
		Range(0, 5)
	)

INSTANTIATE_TEST_SUITE_P() [15/20]

INSTANTIATE_TEST_SUITE_P	(	Sequence1	,
		InstantiationInMultipleTranslationUnitsTest	,
		Values(42, 42 *2)
	)

INSTANTIATE_TEST_SUITE_P() [16/20]

INSTANTIATE_TEST_SUITE_P	(	Sequence1	,
		MultipleInstantiationTest	,
		Values(1, 2)
	)

INSTANTIATE_TEST_SUITE_P() [17/20]

INSTANTIATE_TEST_SUITE_P	(	Sequence2	,
		MultipleInstantiationTest	,
		Range(3, 5)
	)

INSTANTIATE_TEST_SUITE_P() [18/20]

INSTANTIATE_TEST_SUITE_P	(	StatefulNamingFunctor	,
		StatefulNamingTest	,
		Range(0, 5)	,
		StatefulNamingFunctor()
	)

INSTANTIATE_TEST_SUITE_P() [19/20]

INSTANTIATE_TEST_SUITE_P	(	TestExpansionModule	,
		TestGenerationTest	,
		ValuesIn(test_generation_params)
	)

INSTANTIATE_TEST_SUITE_P() [20/20]

INSTANTIATE_TEST_SUITE_P	(	ZeroToFiveSequence	,
		NamingTest	,
		Range(0, 5)
	)

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 1104 of file googletest-param-test-test.cc.

                                {
  // Used in TestGenerationTest test suite.
  AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());
  // Used in GeneratorEvaluationTest test suite. Tests that the updated value
  // will be picked up for instantiating tests in GeneratorEvaluationTest.
  GeneratorEvaluationTest::set_param_value(1);
 
  ::testing::InitGoogleTest(&argc, argv);
 
  // Used in GeneratorEvaluationTest test suite. Tests that value updated
  // here will NOT be used for instantiating tests in
  // GeneratorEvaluationTest.
  GeneratorEvaluationTest::set_param_value(2);
 
  return RUN_ALL_TESTS();
}

operator<<()

std::ostream & operator<<	(	std::ostream &	stream,
		const CustomStruct &	val
	)

Definition at line 943 of file googletest-param-test-test.cc.

                                                                    {
  stream << val.x;
  return stream;
}

PrintValue()

template<typename T >

::std::string PrintValue

(

const T &

value

)

Definition at line 70 of file googletest-param-test-test.cc.

                                     {
  return testing::PrintToString(value);
}

TEST() [1/31]

TEST	(	BoolTest	,
		BoolWorks
	)

Definition at line 401 of file googletest-param-test-test.cc.

                          {
  const ParamGenerator<bool> gen = Bool();
 
  const bool expected_values[] = {false, true};
  VerifyGenerator(gen, expected_values);
}

TEST() [2/31]

TEST	(	CombineTest	,
		CombineWithFirstParameterEmptyRange
	)

Definition at line 459 of file googletest-param-test-test.cc.

                                                       {
  const ParamGenerator<std::tuple<int, int> > gen =
      Combine(Range(0, 0), Values(0, 1));
  VerifyGeneratorIsEmpty(gen);
}

TEST() [3/31]

TEST	(	CombineTest	,
		CombineWithFirstParameterSingleValue
	)

Definition at line 436 of file googletest-param-test-test.cc.

                                                        {
  const ParamGenerator<std::tuple<int, int> > gen =
      Combine(Values(42), Values(0, 1));
 
  std::tuple<int, int> expected_values[] = {std::make_tuple(42, 0),
                                            std::make_tuple(42, 1)};
  VerifyGenerator(gen, expected_values);
}

TEST() [4/31]

TEST	(	CombineTest	,
		CombineWithMaxNumberOfParameters
	)

Definition at line 475 of file googletest-param-test-test.cc.

                                                    {
  const char* foo = "foo";
  const char* bar = "bar";
  const ParamGenerator<
      std::tuple<const char*, int, int, int, int, int, int, int, int, int> >
      gen =
          Combine(Values(foo, bar), Values(1), Values(2), Values(3), Values(4),
                  Values(5), Values(6), Values(7), Values(8), Values(9));
 
  std::tuple<const char*, int, int, int, int, int, int, int, int, int>
      expected_values[] = {std::make_tuple(foo, 1, 2, 3, 4, 5, 6, 7, 8, 9),
                           std::make_tuple(bar, 1, 2, 3, 4, 5, 6, 7, 8, 9)};
  VerifyGenerator(gen, expected_values);
}

TEST() [5/31]

TEST	(	CombineTest	,
		CombineWithSecondParameterEmptyRange
	)

Definition at line 467 of file googletest-param-test-test.cc.

                                                        {
  const ParamGenerator<std::tuple<int, int> > gen =
      Combine(Values(0, 1), Range(1, 1));
  VerifyGeneratorIsEmpty(gen);
}

TEST() [6/31]

TEST	(	CombineTest	,
		CombineWithSecondParameterSingleValue
	)

Definition at line 448 of file googletest-param-test-test.cc.

                                                         {
  const ParamGenerator<std::tuple<int, int> > gen =
      Combine(Values(0, 1), Values(42));
 
  std::tuple<int, int> expected_values[] = {std::make_tuple(0, 42),
                                            std::make_tuple(1, 42)};
  VerifyGenerator(gen, expected_values);
}

TEST() [7/31]

TEST	(	CombineTest	,
		CombineWithThreeParameters
	)

Definition at line 422 of file googletest-param-test-test.cc.

                                              {
  const ParamGenerator<std::tuple<int, int, int> > gen =
      Combine(Values(0, 1), Values(3, 4), Values(5, 6));
  std::tuple<int, int, int> expected_values[] = {
      std::make_tuple(0, 3, 5), std::make_tuple(0, 3, 6),
      std::make_tuple(0, 4, 5), std::make_tuple(0, 4, 6),
      std::make_tuple(1, 3, 5), std::make_tuple(1, 3, 6),
      std::make_tuple(1, 4, 5), std::make_tuple(1, 4, 6)};
  VerifyGenerator(gen, expected_values);
}

TEST() [8/31]

TEST	(	CombineTest	,
		CombineWithTwoParameters
	)

Definition at line 409 of file googletest-param-test-test.cc.

                                            {
  const char* foo = "foo";
  const char* bar = "bar";
  const ParamGenerator<std::tuple<const char*, int> > gen =
      Combine(Values(foo, bar), Values(3, 4));
 
  std::tuple<const char*, int> expected_values[] = {
      std::make_tuple(foo, 3), std::make_tuple(foo, 4), std::make_tuple(bar, 3),
      std::make_tuple(bar, 4)};
  VerifyGenerator(gen, expected_values);
}

TEST() [9/31]

TEST	(	CombineTest	,
		NonDefaultConstructAssign
	)

Definition at line 506 of file googletest-param-test-test.cc.

                                             {
  const ParamGenerator<std::tuple<int, NonDefaultConstructAssignString> > gen =
      Combine(Values(0, 1), Values(NonDefaultConstructAssignString("A"),
                                   NonDefaultConstructAssignString("B")));
 
  ParamGenerator<std::tuple<int, NonDefaultConstructAssignString> >::iterator
      it = gen.begin();
 
  EXPECT_EQ(0, std::get<0>(*it));
  EXPECT_EQ("A", std::get<1>(*it).str());
  ++it;
 
  EXPECT_EQ(0, std::get<0>(*it));
  EXPECT_EQ("B", std::get<1>(*it).str());
  ++it;
 
  EXPECT_EQ(1, std::get<0>(*it));
  EXPECT_EQ("A", std::get<1>(*it).str());
  ++it;
 
  EXPECT_EQ(1, std::get<0>(*it));
  EXPECT_EQ("B", std::get<1>(*it).str());
  ++it;
 
  EXPECT_TRUE(it == gen.end());
}

TEST() [10/31]

TEST	(	CustomNamingTest	,
		CheckNameRegistry
	)

Definition at line 903 of file googletest-param-test-test.cc.

                                          {
  ::testing::UnitTest* unit_test = ::testing::UnitTest::GetInstance();
  std::set<std::string> test_names;
  for (int suite_num = 0; suite_num < unit_test->total_test_suite_count();
       ++suite_num) {
    const ::testing::TestSuite* test_suite = unit_test->GetTestSuite(suite_num);
    for (int test_num = 0; test_num < test_suite->total_test_count();
         ++test_num) {
      const ::testing::TestInfo* test_info = test_suite->GetTestInfo(test_num);
      test_names.insert(std::string(test_info->name()));
    }
  }
  EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctorName"));
  EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctionName"));
  EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctionNameP"));
  EXPECT_EQ(1u, test_names.count("CustomTestNames/LambdaName"));
}

TEST() [11/31]

TEST	(	IteratorTest	,
		ParamIteratorConformsToForwardIteratorConcept
	)

Definition at line 137 of file googletest-param-test-test.cc.

                                                                  {
  const ParamGenerator<int> gen = Range(0, 10);
  ParamGenerator<int>::iterator it = gen.begin();
 
  // Verifies that iterator initialization works as expected.
  ParamGenerator<int>::iterator it2 = it;
  EXPECT_TRUE(*it == *it2) << "Initialized iterators must point to the "
                           << "element same as its source points to";
 
  // Verifies that iterator assignment works as expected.
  ++it;
  EXPECT_FALSE(*it == *it2);
  it2 = it;
  EXPECT_TRUE(*it == *it2) << "Assigned iterators must point to the "
                           << "element same as its source points to";
 
  // Verifies that prefix operator++() returns *this.
  EXPECT_EQ(&it, &(++it)) << "Result of the prefix operator++ must be "
                          << "refer to the original object";
 
  // Verifies that the result of the postfix operator++ points to the value
  // pointed to by the original iterator.
  int original_value = *it;  // Have to compute it outside of macro call to be
                             // unaffected by the parameter evaluation order.
  EXPECT_EQ(original_value, *(it++));
 
  // Verifies that prefix and postfix operator++() advance an iterator
  // all the same.
  it2 = it;
  ++it;
  ++it2;
  EXPECT_TRUE(*it == *it2);
}

TEST() [12/31]

TEST	(	MacroNameing	,
		LookupNames
	)

Definition at line 824 of file googletest-param-test-test.cc.

                                {
  std::set<std::string> know_suite_names, know_test_names;
 
  auto ins = testing::UnitTest::GetInstance();
  int ts = 0;
  while (const testing::TestSuite* suite = ins->GetTestSuite(ts++)) {
    know_suite_names.insert(suite->name());
 
    int ti = 0;
    while (const testing::TestInfo* info = suite->GetTestInfo(ti++)) {
      know_test_names.insert(std::string(suite->name()) + "." + info->name());
    }
  }
 
  // Check that the expected form of the test suit name actually exists.
  EXPECT_NE(  //
      know_suite_names.find("FortyTwo/MacroNamingTest"),
      know_suite_names.end());
  EXPECT_NE(
      know_suite_names.find("MacroNamingTestNonParametrized"),
      know_suite_names.end());
  // Check that the expected form of the test name actually exists.
  EXPECT_NE(  //
      know_test_names.find("FortyTwo/MacroNamingTest.FooSomeTestName/0"),
      know_test_names.end());
  EXPECT_NE(
      know_test_names.find("MacroNamingTestNonParametrized.FooSomeTestName"),
      know_test_names.end());
}

TEST() [13/31]

TEST	(	ParamGeneratorTest	,
		AssignmentWorks
	)

Definition at line 536 of file googletest-param-test-test.cc.

                                          {
  ParamGenerator<int> gen = Values(1, 2);
  const ParamGenerator<int> gen2 = Values(3, 4);
  gen = gen2;
 
  const int expected_values[] = {3, 4};
  VerifyGenerator(gen, expected_values);
}

TEST() [14/31]

TEST	(	RangeTest	,
		IntRangeEmpty
	)

Definition at line 188 of file googletest-param-test-test.cc.

                               {
  const ParamGenerator<int> gen = Range(0, 0);
  VerifyGeneratorIsEmpty(gen);
}

TEST() [15/31]

TEST	(	RangeTest	,
		IntRangeSingleValue
	)

Definition at line 180 of file googletest-param-test-test.cc.

                                     {
  const ParamGenerator<int> gen = Range(0, 1);
  const int expected_values[] = {0};
  VerifyGenerator(gen, expected_values);
}

TEST() [16/31]

TEST	(	RangeTest	,
		IntRangeWithCustomStep
	)

Definition at line 195 of file googletest-param-test-test.cc.

                                        {
  const ParamGenerator<int> gen = Range(0, 9, 3);
  const int expected_values[] = {0, 3, 6};
  VerifyGenerator(gen, expected_values);
}

TEST() [17/31]

TEST	(	RangeTest	,
		IntRangeWithCustomStepOverUpperBound
	)

Definition at line 205 of file googletest-param-test-test.cc.

                                                      {
  const ParamGenerator<int> gen = Range(0, 4, 3);
  const int expected_values[] = {0, 3};
  VerifyGenerator(gen, expected_values);
}

TEST() [18/31]

TEST	(	RangeTest	,
		IntRangeWithDefaultStep
	)

Definition at line 172 of file googletest-param-test-test.cc.

                                         {
  const ParamGenerator<int> gen = Range(0, 3);
  const int expected_values[] = {0, 1, 2};
  VerifyGenerator(gen, expected_values);
}

TEST() [19/31]

TEST	(	RangeTest	,
		WorksWithACustomType
	)

Definition at line 237 of file googletest-param-test-test.cc.

                                      {
  const ParamGenerator<DogAdder> gen =
      Range(DogAdder("cat"), DogAdder("catdogdog"), DogAdder("dog"));
  ParamGenerator<DogAdder>::iterator it = gen.begin();
 
  ASSERT_FALSE(it == gen.end());
  EXPECT_STREQ("cat", it->value().c_str());
 
  ASSERT_FALSE(++it == gen.end());
  EXPECT_STREQ("catdog", it->value().c_str());
 
  EXPECT_TRUE(++it == gen.end());
}

TEST() [20/31]

TEST	(	RangeTest	,
		WorksWithACustomTypeWithDifferentIncrementType
	)

Definition at line 271 of file googletest-param-test-test.cc.

                                                                {
  const ParamGenerator<IntWrapper> gen = Range(IntWrapper(0), IntWrapper(2));
  ParamGenerator<IntWrapper>::iterator it = gen.begin();
 
  ASSERT_FALSE(it == gen.end());
  EXPECT_EQ(0, it->value());
 
  ASSERT_FALSE(++it == gen.end());
  EXPECT_EQ(1, it->value());
 
  EXPECT_TRUE(++it == gen.end());
}

TEST() [21/31]

TEST	(	ValuesInTest	,
		ValuesInArray
	)

Definition at line 286 of file googletest-param-test-test.cc.

                                  {
  int array[] = {3, 5, 8};
  const ParamGenerator<int> gen = ValuesIn(array);
  VerifyGenerator(gen, array);
}

TEST() [22/31]

TEST	(	ValuesInTest	,
		ValuesInConstArray
	)

Definition at line 294 of file googletest-param-test-test.cc.

                                       {
  const int array[] = {3, 5, 8};
  const ParamGenerator<int> gen = ValuesIn(array);
  VerifyGenerator(gen, array);
}

TEST() [23/31]

TEST	(	ValuesInTest	,
		ValuesInEmptyIteratorRange
	)

Definition at line 349 of file googletest-param-test-test.cc.

                                               {
  typedef ::std::vector<int> ContainerType;
  ContainerType values;
  const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
 
  VerifyGeneratorIsEmpty(gen);
}

TEST() [24/31]

TEST	(	ValuesInTest	,
		ValuesInIteratorRange
	)

Definition at line 323 of file googletest-param-test-test.cc.

                                          {
  typedef ::std::vector<int> ContainerType;
  ContainerType values;
  values.push_back(3);
  values.push_back(5);
  values.push_back(8);
  const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
 
  const int expected_values[] = {3, 5, 8};
  VerifyGenerator(gen, expected_values);
}

TEST() [25/31]

TEST	(	ValuesInTest	,
		ValuesInSingleElementArray
	)

Definition at line 302 of file googletest-param-test-test.cc.

                                               {
  int array[] = {42};
  const ParamGenerator<int> gen = ValuesIn(array);
  VerifyGenerator(gen, array);
}

TEST() [26/31]

TEST	(	ValuesInTest	,
		ValuesInSingleElementIteratorRange
	)

Definition at line 337 of file googletest-param-test-test.cc.

                                                       {
  typedef ::std::vector<int> ContainerType;
  ContainerType values;
  values.push_back(42);
  const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
 
  const int expected_values[] = {42};
  VerifyGenerator(gen, expected_values);
}

TEST() [27/31]

TEST	(	ValuesInTest	,
		ValuesInVector
	)

Definition at line 310 of file googletest-param-test-test.cc.

                                   {
  typedef ::std::vector<int> ContainerType;
  ContainerType values;
  values.push_back(3);
  values.push_back(5);
  values.push_back(8);
  const ParamGenerator<int> gen = ValuesIn(values);
 
  const int expected_values[] = {3, 5, 8};
  VerifyGenerator(gen, expected_values);
}

TEST() [28/31]

TEST	(	ValuesTest	,
		ValuesWithSingleParameter
	)

Definition at line 393 of file googletest-param-test-test.cc.

                                            {
  const ParamGenerator<int> gen = Values(42);
 
  const int expected_values[] = {42};
  VerifyGenerator(gen, expected_values);
}

TEST() [29/31]

TEST	(	ValuesTest	,
		ValuesWorks
	)

Definition at line 358 of file googletest-param-test-test.cc.

                              {
  const ParamGenerator<int> gen = Values(3, 5, 8);
 
  const int expected_values[] = {3, 5, 8};
  VerifyGenerator(gen, expected_values);
}

TEST() [30/31]

TEST	(	ValuesTest	,
		ValuesWorksForMaxLengthList
	)

Definition at line 374 of file googletest-param-test-test.cc.

                                              {
  const ParamGenerator<int> gen = Values(
      10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
      110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
      210, 220, 230, 240, 250, 260, 270, 280, 290, 300,
      310, 320, 330, 340, 350, 360, 370, 380, 390, 400,
      410, 420, 430, 440, 450, 460, 470, 480, 490, 500);
 
  const int expected_values[] = {
      10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
      110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
      210, 220, 230, 240, 250, 260, 270, 280, 290, 300,
      310, 320, 330, 340, 350, 360, 370, 380, 390, 400,
      410, 420, 430, 440, 450, 460, 470, 480, 490, 500};
  VerifyGenerator(gen, expected_values);
}

TEST() [31/31]

TEST	(	ValuesTest	,
		ValuesWorksForValuesOfCompatibleTypes
	)

Definition at line 367 of file googletest-param-test-test.cc.

                                                        {
  const ParamGenerator<double> gen = Values(3, 5.0f, 8.0);
 
  const double expected_values[] = {3.0, 5.0, 8.0};
  VerifyGenerator(gen, expected_values);
}

TEST_F() [1/3]

TEST_F	(	NonParameterizedBaseTest	,
		FixtureIsInitialized
	)

Definition at line 1039 of file googletest-param-test-test.cc.

                                                       {
  EXPECT_EQ(17, n_);
}

TEST_F() [2/3]

TEST_F	(	ParameterizedDeathTest	,
		GetParamDiesFromTestF
	)

Definition at line 1051 of file googletest-param-test-test.cc.

                                                      {
  EXPECT_DEATH_IF_SUPPORTED(GetParam(),
                            ".* value-parameterized test .*");
}

TEST_F() [3/3]

TEST_F	(	PREFIX_WITH_MACRO(NamingTestNonParametrized)	,
		PREFIX_WITH_FOO(SomeTestName)
	)

Definition at line 815 of file googletest-param-test-test.cc.

                                      {
  const ::testing::TestInfo* const test_info =
     ::testing::UnitTest::GetInstance()->current_test_info();
 
  EXPECT_STREQ("MacroNamingTestNonParametrized", test_info->test_suite_name());
  EXPECT_STREQ("FooSomeTestName", test_info->name());
}

TEST_P() [1/18]

TEST_P	(	CommentTest	,
		TestsCorrectlyReportUnstreamableParams
	)

Definition at line 1008 of file googletest-param-test-test.cc.

                                                            {
  const ::testing::TestInfo* const test_info =
     ::testing::UnitTest::GetInstance()->current_test_info();
 
  EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());
}

TEST_P() [2/18]

TEST_P	(	CustomFunctionNamingTest	,
		CustomTestNames
	)

Definition at line 882 of file googletest-param-test-test.cc.

{}

TEST_P() [3/18]

TEST_P	(	CustomFunctorNamingTest	,
		CustomTestNames
	)

Definition at line 859 of file googletest-param-test-test.cc.

{}

TEST_P() [4/18]

TEST_P	(	CustomIntegerNamingTest	,
		TestsReportCorrectNames
	)

Definition at line 925 of file googletest-param-test-test.cc.

                                                         {
  const ::testing::TestInfo* const test_info =
     ::testing::UnitTest::GetInstance()->current_test_info();
  Message test_name_stream;
  test_name_stream << "TestsReportCorrectNames/" << GetParam();
  EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
}

TEST_P() [5/18]

TEST_P	(	CustomLambdaNamingTest	,
		CustomTestNames
	)

Definition at line 895 of file googletest-param-test-test.cc.

{}

TEST_P() [6/18]

TEST_P	(	CustomStructNamingTest	,
		TestsReportCorrectNames
	)

Definition at line 950 of file googletest-param-test-test.cc.

                                                        {
  const ::testing::TestInfo* const test_info =
     ::testing::UnitTest::GetInstance()->current_test_info();
  Message test_name_stream;
  test_name_stream << "TestsReportCorrectNames/" << GetParam();
  EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
}

TEST_P() [7/18]

TEST_P	(	ExternalGeneratorTest	,
		ExternalGenerator
	)

Definition at line 713 of file googletest-param-test-test.cc.

                                                 {
  // Sequence produced by extern_gen contains only a single value
  // which we verify here.
  EXPECT_EQ(GetParam(), 33);
}

TEST_P() [8/18]

TEST_P	(	ExternalInstantiationTest	,
		IsMultipleOf33
	)

Definition at line 725 of file googletest-param-test-test.cc.

                                                  {
  EXPECT_EQ(0, GetParam() % 33);
}

TEST_P() [9/18]

TEST_P	(	GeneratorEvaluationTest	,
		GeneratorsEvaluatedInMain
	)

Definition at line 703 of file googletest-param-test-test.cc.

                                                           {
  EXPECT_EQ(1, GetParam());
}

TEST_P() [10/18]

TEST_P	(	InstantiationInMultipleTranslationUnitsTest	,
		IsMultipleOf42
	)

Definition at line 742 of file googletest-param-test-test.cc.

                                                                    {
  EXPECT_EQ(0, GetParam() % 42);
}

TEST_P() [11/18]

TEST_P	(	MultipleInstantiationTest	,
		AllowsMultipleInstances
	)

Definition at line 732 of file googletest-param-test-test.cc.

                                                           {
}

TEST_P() [12/18]

TEST_P	(	MyEnumTest	,
		ChecksParamMoreThanZero
	)

Definition at line 1068 of file googletest-param-test-test.cc.

{ EXPECT_GE(10, GetParam()); }

TEST_P() [13/18]

TEST_P	(	NamingTest	,
		TestsReportCorrectNamesAndParameters
	)

Definition at line 781 of file googletest-param-test-test.cc.

                                                         {
  const ::testing::TestInfo* const test_info =
     ::testing::UnitTest::GetInstance()->current_test_info();
 
  EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_suite_name());
 
  Message index_stream;
  index_stream << "TestsReportCorrectNamesAndParameters/" << GetParam();
  EXPECT_STREQ(index_stream.GetString().c_str(), test_info->name());
 
  EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());
}

TEST_P() [14/18]

TEST_P	(	ParameterizedDerivedTest	,
		SeesSequence
	)

Definition at line 1043 of file googletest-param-test-test.cc.

                                               {
  EXPECT_EQ(17, n_);
  EXPECT_EQ(0, count_++);
  EXPECT_EQ(GetParam(), global_count_++);
}

TEST_P() [15/18]

TEST_P	(	PREFIX_WITH_MACRO(NamingTest)	,
		PREFIX_WITH_FOO(SomeTestName)
	)

Definition at line 802 of file googletest-param-test-test.cc.

                                                                     {
  const ::testing::TestInfo* const test_info =
     ::testing::UnitTest::GetInstance()->current_test_info();
 
  EXPECT_STREQ("FortyTwo/MacroNamingTest", test_info->test_suite_name());
  EXPECT_STREQ("FooSomeTestName/0", test_info->name());
}

TEST_P() [16/18]

TEST_P	(	SeparateInstanceTest	,
		TestsRunInSeparateInstances
	)

Definition at line 768 of file googletest-param-test-test.cc.

                                                          {
  EXPECT_EQ(0, count_++);
  global_count_++;
}

TEST_P() [17/18]

TEST_P	(	StatefulNamingTest	,
		TestsReportCorrectNames
	)

Definition at line 980 of file googletest-param-test-test.cc.

                                                    {
  const ::testing::TestInfo* const test_info =
     ::testing::UnitTest::GetInstance()->current_test_info();
  sum_ += GetParam();
  Message test_name_stream;
  test_name_stream << "TestsReportCorrectNames/" << sum_;
  EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
}

TEST_P() [18/18]

TEST_P	(	TestGenerationTest	,
		TestsExpandedAndRun
	)

Definition at line 675 of file googletest-param-test-test.cc.

                                                {
  Environment::Instance()->TestBodyExecuted();
  EXPECT_EQ(current_parameter_, GetParam());
  collected_parameters_.push_back(GetParam());
}

VerifyGenerator()

template<typename T , size_t N>

void VerifyGenerator	(	const ParamGenerator< T > &	generator,
		const T(&)	expected_values[N]
	)

Definition at line 78 of file googletest-param-test-test.cc.

                                                    {
  typename ParamGenerator<T>::iterator it = generator.begin();
  for (size_t i = 0; i < N; ++i) {
    ASSERT_FALSE(it == generator.end())
        << "At element " << i << " when accessing via an iterator "
        << "created with the copy constructor.\n";
    // We cannot use EXPECT_EQ() here as the values may be tuples,
    // which don't support <<.
    EXPECT_TRUE(expected_values[i] == *it)
        << "where i is " << i
        << ", expected_values[i] is " << PrintValue(expected_values[i])
        << ", *it is " << PrintValue(*it)
        << ", and 'it' is an iterator created with the copy constructor.\n";
    ++it;
  }
  EXPECT_TRUE(it == generator.end())
        << "At the presumed end of sequence when accessing via an iterator "
        << "created with the copy constructor.\n";
 
  // Test the iterator assignment. The following lines verify that
  // the sequence accessed via an iterator initialized via the
  // assignment operator (as opposed to a copy constructor) matches
  // just the same.
  it = generator.begin();
  for (size_t i = 0; i < N; ++i) {
    ASSERT_FALSE(it == generator.end())
        << "At element " << i << " when accessing via an iterator "
        << "created with the assignment operator.\n";
    EXPECT_TRUE(expected_values[i] == *it)
        << "where i is " << i
        << ", expected_values[i] is " << PrintValue(expected_values[i])
        << ", *it is " << PrintValue(*it)
        << ", and 'it' is an iterator created with the copy constructor.\n";
    ++it;
  }
  EXPECT_TRUE(it == generator.end())
        << "At the presumed end of sequence when accessing via an iterator "
        << "created with the assignment operator.\n";
}

VerifyGeneratorIsEmpty()

template<typename T >

void VerifyGeneratorIsEmpty

(

const ParamGenerator< T > &

generator

)

Definition at line 120 of file googletest-param-test-test.cc.

                                                                {
  typename ParamGenerator<T>::iterator it = generator.begin();
  EXPECT_TRUE(it == generator.end());
 
  it = generator.begin();
  EXPECT_TRUE(it == generator.end());
}

Variable Documentation

extern_gen

ParamGenerator<int> extern_gen

extern

Definition at line 43 of file googletest-param-test2-test.cc.

test_generation_params

const int test_generation_params[] = {36, 42, 72}

Definition at line 609 of file googletest-param-test-test.cc.