gtest-param-test_test.cc File Reference

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

Include dependency graph for gtest-param-test_test.cc:

Go to the source code of this file.

Classes
class	DogAdder
class	IntWrapper
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	CustomIntegerNamingTest
struct	CustomStruct
class	CustomStructNamingTest
struct	StatefulNamingFunctor
class	StatefulNamingTest
class	Unstreamable
class	CommentTest
class	NonParameterizedBaseTest
class	ParameterizedDerivedTest
class	ParameterizedDeathTest

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

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 (ParamGeneratorTest, AssignmentWorks)
	TEST_P (TestGenerationTest, TestsExpandedAndRun)
	INSTANTIATE_TEST_CASE_P (TestExpansionModule, TestGenerationTest, ValuesIn(test_generation_params))
	TEST_P (GeneratorEvaluationTest, GeneratorsEvaluatedInMain)
	INSTANTIATE_TEST_CASE_P (GenEvalModule, GeneratorEvaluationTest, Values(GeneratorEvaluationTest::param_value()))
	TEST_P (ExternalGeneratorTest, ExternalGenerator)
	INSTANTIATE_TEST_CASE_P (ExternalGeneratorModule, ExternalGeneratorTest, extern_gen)
	TEST_P (ExternalInstantiationTest, IsMultipleOf33)
	TEST_P (MultipleInstantiationTest, AllowsMultipleInstances)
	INSTANTIATE_TEST_CASE_P (Sequence1, MultipleInstantiationTest, Values(1, 2))
	INSTANTIATE_TEST_CASE_P (Sequence2, MultipleInstantiationTest, Range(3, 5))
	TEST_P (InstantiationInMultipleTranslaionUnitsTest, IsMultipleOf42)
	INSTANTIATE_TEST_CASE_P (Sequence1, InstantiationInMultipleTranslaionUnitsTest, Values(42, 42 *2))
	TEST_P (SeparateInstanceTest, TestsRunInSeparateInstances)
	INSTANTIATE_TEST_CASE_P (FourElemSequence, SeparateInstanceTest, Range(1, 4))
	TEST_P (NamingTest, TestsReportCorrectNamesAndParameters)
	INSTANTIATE_TEST_CASE_P (ZeroToFiveSequence, NamingTest, Range(0, 5))
	TEST_P (PREFIX_WITH_MACRO(NamingTest), PREFIX_WITH_FOO(SomeTestName))
	INSTANTIATE_TEST_CASE_P (FortyTwo, MacroNamingTest, Values(42))
	TEST_F (PREFIX_WITH_MACRO(NamingTestNonParametrized), PREFIX_WITH_FOO(SomeTestName))
	TEST_P (CustomFunctorNamingTest, CustomTestNames)
	INSTANTIATE_TEST_CASE_P (CustomParamNameFunctor, CustomFunctorNamingTest, Values(std::string("FunctorName")), CustomParamNameFunctor())
	INSTANTIATE_TEST_CASE_P (AllAllowedCharacters, CustomFunctorNamingTest, Values("abcdefghijklmnopqrstuvwxyz", "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "01234567890_"), CustomParamNameFunctor())
std::string	CustomParamNameFunction (const ::testing::TestParamInfo< std::string > &inf)
	TEST_P (CustomFunctionNamingTest, CustomTestNames)
	INSTANTIATE_TEST_CASE_P (CustomParamNameFunction, CustomFunctionNamingTest, Values(std::string("FunctionName")), CustomParamNameFunction)
	TEST (CustomNamingTest, CheckNameRegistry)
	TEST_P (CustomIntegerNamingTest, TestsReportCorrectNames)
	INSTANTIATE_TEST_CASE_P (PrintToString, CustomIntegerNamingTest, Range(0, 5), ::testing::PrintToStringParamName())
std::ostream &	operator<< (std::ostream &stream, const CustomStruct &val)
	TEST_P (CustomStructNamingTest, TestsReportCorrectNames)
	INSTANTIATE_TEST_CASE_P (PrintToString, CustomStructNamingTest, Values(CustomStruct(0), CustomStruct(1)), ::testing::PrintToStringParamName())
	TEST_P (StatefulNamingTest, TestsReportCorrectNames)
	INSTANTIATE_TEST_CASE_P (StatefulNamingFunctor, StatefulNamingTest, Range(0, 5), StatefulNamingFunctor())
	TEST_P (CommentTest, TestsCorrectlyReportUnstreamableParams)
	INSTANTIATE_TEST_CASE_P (InstantiationWithComments, CommentTest, Values(Unstreamable(1)))
	TEST_F (NonParameterizedBaseTest, FixtureIsInitialized)
	TEST_P (ParameterizedDerivedTest, SeesSequence)
	TEST_F (ParameterizedDeathTest, GetParamDiesFromTestF)
	INSTANTIATE_TEST_CASE_P (RangeZeroToFive, ParameterizedDerivedTest, Range(0, 5))
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

)

Value:

Foo##test_name

Definition at line 854 of file gtest-param-test_test.cc.

PREFIX_WITH_MACRO

#define PREFIX_WITH_MACRO

(

test_name

)

Value:

Macro##test_name

Definition at line 855 of file gtest-param-test_test.cc.

Function Documentation

CustomParamNameFunction()

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

inline

Definition at line 904 of file gtest-param-test_test.cc.

                                                {
  return inf.param;
}

INSTANTIATE_TEST_CASE_P() [1/17]

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

INSTANTIATE_TEST_CASE_P() [2/17]

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

INSTANTIATE_TEST_CASE_P() [3/17]

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

INSTANTIATE_TEST_CASE_P() [4/17]

INSTANTIATE_TEST_CASE_P	(	ExternalGeneratorModule	,
		ExternalGeneratorTest	,
		extern_gen	)

INSTANTIATE_TEST_CASE_P() [5/17]

INSTANTIATE_TEST_CASE_P	(	FortyTwo	,
		MacroNamingTest	,
		Values(42)	)

INSTANTIATE_TEST_CASE_P() [6/17]

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

INSTANTIATE_TEST_CASE_P() [7/17]

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

INSTANTIATE_TEST_CASE_P() [8/17]

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

INSTANTIATE_TEST_CASE_P() [9/17]

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

INSTANTIATE_TEST_CASE_P() [10/17]

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

INSTANTIATE_TEST_CASE_P() [11/17]

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

INSTANTIATE_TEST_CASE_P() [12/17]

INSTANTIATE_TEST_CASE_P	(	Sequence1	,
		InstantiationInMultipleTranslaionUnitsTest	,
		Values(42, 42 *2)	)

INSTANTIATE_TEST_CASE_P() [13/17]

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

INSTANTIATE_TEST_CASE_P() [14/17]

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

INSTANTIATE_TEST_CASE_P() [15/17]

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

INSTANTIATE_TEST_CASE_P() [16/17]

INSTANTIATE_TEST_CASE_P	(	TestExpansionModule	,
		TestGenerationTest	,
		ValuesIn(test_generation_params)	)

INSTANTIATE_TEST_CASE_P() [17/17]

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

main()

int main	(	int	argc,
		char **	argv )

Definition at line 1095 of file gtest-param-test_test.cc.

                                {
  // Used in TestGenerationTest test case.
  AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());
  // Used in GeneratorEvaluationTest test case. 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 case. Tests that value updated
  // here will NOT be used for instantiating tests in
  // GeneratorEvaluationTest.
  GeneratorEvaluationTest::set_param_value(2);
 
  return RUN_ALL_TESTS();
}

Here is the call graph for this function:

operator<<()

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

Definition at line 977 of file gtest-param-test_test.cc.

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

PrintValue()

template<typename T >

::std::string PrintValue

(

const T &

value

)

Definition at line 76 of file gtest-param-test_test.cc.

                                     {
  ::std::stringstream stream;
  stream << value;
  return stream.str();
}

Here is the caller graph for this function:

TEST() [1/22]

TEST	(	BoolTest	,
		BoolWorks	)

Definition at line 447 of file gtest-param-test_test.cc.

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

Here is the call graph for this function:

TEST() [2/22]

TEST	(	CustomNamingTest	,
		CheckNameRegistry	)

Definition at line 932 of file gtest-param-test_test.cc.

                                          {
  ::testing::UnitTest* unit_test = ::testing::UnitTest::GetInstance();
  std::set<std::string> test_names;
  for (int case_num = 0;
       case_num < unit_test->total_test_case_count();
       ++case_num) {
    const ::testing::TestCase* test_case = unit_test->GetTestCase(case_num);
    for (int test_num = 0;
         test_num < test_case->total_test_count();
         ++test_num) {
      const ::testing::TestInfo* test_info = test_case->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"));
#if GTEST_LANG_CXX11
  EXPECT_EQ(1u, test_names.count("CustomTestNames/LambdaName"));
#endif  // GTEST_LANG_CXX11
}

Here is the call graph for this function:

TEST() [3/22]

TEST	(	IteratorTest	,
		ParamIteratorConformsToForwardIteratorConcept	)

Definition at line 183 of file gtest-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() [4/22]

TEST	(	ParamGeneratorTest	,
		AssignmentWorks	)

Definition at line 588 of file gtest-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);
}

Here is the call graph for this function:

TEST() [5/22]

TEST	(	RangeTest	,
		IntRangeEmpty	)

Definition at line 234 of file gtest-param-test_test.cc.

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

Here is the call graph for this function:

TEST() [6/22]

TEST	(	RangeTest	,
		IntRangeSingleValue	)

Definition at line 226 of file gtest-param-test_test.cc.

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

Here is the call graph for this function:

TEST() [7/22]

TEST	(	RangeTest	,
		IntRangeWithCustomStep	)

Definition at line 241 of file gtest-param-test_test.cc.

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

Here is the call graph for this function:

TEST() [8/22]

TEST	(	RangeTest	,
		IntRangeWithCustomStepOverUpperBound	)

Definition at line 251 of file gtest-param-test_test.cc.

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

Here is the call graph for this function:

TEST() [9/22]

TEST	(	RangeTest	,
		IntRangeWithDefaultStep	)

Definition at line 218 of file gtest-param-test_test.cc.

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

Here is the call graph for this function:

TEST() [10/22]

TEST	(	RangeTest	,
		WorksWithACustomType	)

Definition at line 283 of file gtest-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() [11/22]

TEST	(	RangeTest	,
		WorksWithACustomTypeWithDifferentIncrementType	)

Definition at line 317 of file gtest-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() [12/22]

TEST	(	ValuesInTest	,
		ValuesInArray	)

Definition at line 332 of file gtest-param-test_test.cc.

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

Here is the call graph for this function:

TEST() [13/22]

TEST	(	ValuesInTest	,
		ValuesInConstArray	)

Definition at line 340 of file gtest-param-test_test.cc.

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

Here is the call graph for this function:

TEST() [14/22]

TEST	(	ValuesInTest	,
		ValuesInEmptyIteratorRange	)

Definition at line 395 of file gtest-param-test_test.cc.

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

Here is the call graph for this function:

TEST() [15/22]

TEST	(	ValuesInTest	,
		ValuesInIteratorRange	)

Definition at line 369 of file gtest-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);
}

Here is the call graph for this function:

TEST() [16/22]

TEST	(	ValuesInTest	,
		ValuesInSingleElementArray	)

Definition at line 348 of file gtest-param-test_test.cc.

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

Here is the call graph for this function:

TEST() [17/22]

TEST	(	ValuesInTest	,
		ValuesInSingleElementIteratorRange	)

Definition at line 383 of file gtest-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);
}

Here is the call graph for this function:

TEST() [18/22]

TEST	(	ValuesInTest	,
		ValuesInVector	)

Definition at line 356 of file gtest-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);
}

Here is the call graph for this function:

TEST() [19/22]

TEST	(	ValuesTest	,
		ValuesWithSingleParameter	)

Definition at line 439 of file gtest-param-test_test.cc.

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

Here is the call graph for this function:

TEST() [20/22]

TEST	(	ValuesTest	,
		ValuesWorks	)

Definition at line 404 of file gtest-param-test_test.cc.

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

Here is the call graph for this function:

TEST() [21/22]

TEST	(	ValuesTest	,
		ValuesWorksForMaxLengthList	)

Definition at line 420 of file gtest-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);
}

Here is the call graph for this function:

TEST() [22/22]

TEST	(	ValuesTest	,
		ValuesWorksForValuesOfCompatibleTypes	)

Definition at line 413 of file gtest-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);
}

Here is the call graph for this function:

TEST_F() [1/3]

TEST_F	(	NonParameterizedBaseTest	,
		FixtureIsInitialized	)

Definition at line 1075 of file gtest-param-test_test.cc.

                                                       {
  EXPECT_EQ(17, n_);
}

TEST_F() [2/3]

TEST_F	(	ParameterizedDeathTest	,
		GetParamDiesFromTestF	)

Definition at line 1087 of file gtest-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 870 of file gtest-param-test_test.cc.

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

Here is the call graph for this function:

TEST_P() [1/16]

TEST_P	(	CommentTest	,
		TestsCorrectlyReportUnstreamableParams	)

Definition at line 1043 of file gtest-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());
}

Here is the call graph for this function:

TEST_P() [2/16]

TEST_P	(	CustomFunctionNamingTest	,
		CustomTestNames	)

Definition at line 910 of file gtest-param-test_test.cc.

{}

TEST_P() [3/16]

TEST_P	(	CustomFunctorNamingTest	,
		CustomTestNames	)

Definition at line 884 of file gtest-param-test_test.cc.

{}

TEST_P() [4/16]

TEST_P	(	CustomIntegerNamingTest	,
		TestsReportCorrectNames	)

Definition at line 957 of file gtest-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());
}

Here is the call graph for this function:

TEST_P() [5/16]

TEST_P	(	CustomStructNamingTest	,
		TestsReportCorrectNames	)

Definition at line 984 of file gtest-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());
}

Here is the call graph for this function:

TEST_P() [6/16]

TEST_P	(	ExternalGeneratorTest	,
		ExternalGenerator	)

Definition at line 766 of file gtest-param-test_test.cc.

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

TEST_P() [7/16]

TEST_P	(	ExternalInstantiationTest	,
		IsMultipleOf33	)

Definition at line 779 of file gtest-param-test_test.cc.

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

TEST_P() [8/16]

TEST_P	(	GeneratorEvaluationTest	,
		GeneratorsEvaluatedInMain	)

Definition at line 755 of file gtest-param-test_test.cc.

                                                           {
  EXPECT_EQ(1, GetParam());
}

TEST_P() [9/16]

TEST_P	(	InstantiationInMultipleTranslaionUnitsTest	,
		IsMultipleOf42	)

Definition at line 796 of file gtest-param-test_test.cc.

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

TEST_P() [10/16]

TEST_P	(	MultipleInstantiationTest	,
		AllowsMultipleInstances	)

Definition at line 786 of file gtest-param-test_test.cc.

                                                           {
}

TEST_P() [11/16]

TEST_P	(	NamingTest	,
		TestsReportCorrectNamesAndParameters	)

Definition at line 836 of file gtest-param-test_test.cc.

                                                         {
  const ::testing::TestInfo* const test_info =
     ::testing::UnitTest::GetInstance()->current_test_info();
 
  EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_case_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());
}

Here is the call graph for this function:

TEST_P() [12/16]

TEST_P	(	ParameterizedDerivedTest	,
		SeesSequence	)

Definition at line 1079 of file gtest-param-test_test.cc.

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

TEST_P() [13/16]

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

Definition at line 857 of file gtest-param-test_test.cc.

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

Here is the call graph for this function:

TEST_P() [14/16]

TEST_P	(	SeparateInstanceTest	,
		TestsRunInSeparateInstances	)

Definition at line 823 of file gtest-param-test_test.cc.

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

TEST_P() [15/16]

TEST_P	(	StatefulNamingTest	,
		TestsReportCorrectNames	)

Definition at line 1015 of file gtest-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());
}

Here is the call graph for this function:

TEST_P() [16/16]

TEST_P	(	TestGenerationTest	,
		TestsExpandedAndRun	)

Definition at line 727 of file gtest-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 124 of file gtest-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";
}

Here is the call graph for this function:

Here is the caller graph for this function:

VerifyGeneratorIsEmpty()

template<typename T >

void VerifyGeneratorIsEmpty

(

const ParamGenerator< T > &

generator

)

Definition at line 166 of file gtest-param-test_test.cc.

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

Here is the caller graph for this function:

Variable Documentation

extern_gen

ParamGenerator<int> extern_gen

extern

Definition at line 44 of file gtest-param-test2_test.cc.

test_generation_params

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

Definition at line 661 of file gtest-param-test_test.cc.

{36, 42, 72};