Blame | Last modification | View Log | Download
$$ -*- mode: c++; -*-$var n = 50 $$ Maximum length of Values arguments we want to support.$var maxtuple = 10 $$ Maximum number of Combine arguments we want to support.// Copyright 2008, Google Inc.// All rights reserved.//// Redistribution and use in source and binary forms, with or without// modification, are permitted provided that the following conditions are// met://// * Redistributions of source code must retain the above copyright// notice, this list of conditions and the following disclaimer.// * Redistributions in binary form must reproduce the above// copyright notice, this list of conditions and the following disclaimer// in the documentation and/or other materials provided with the// distribution.// * Neither the name of Google Inc. nor the names of its// contributors may be used to endorse or promote products derived from// this software without specific prior written permission.//// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.//// Macros and functions for implementing parameterized tests// in Google C++ Testing and Mocking Framework (Google Test)//// This file is generated by a SCRIPT. DO NOT EDIT BY HAND!//// GOOGLETEST_CM0001 DO NOT DELETE#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_// Value-parameterized tests allow you to test your code with different// parameters without writing multiple copies of the same test.//// Here is how you use value-parameterized tests:#if 0// To write value-parameterized tests, first you should define a fixture// class. It is usually derived from testing::TestWithParam<T> (see below for// another inheritance scheme that's sometimes useful in more complicated// class hierarchies), where the type of your parameter values.// TestWithParam<T> is itself derived from testing::Test. T can be any// copyable type. If it's a raw pointer, you are responsible for managing the// lifespan of the pointed values.class FooTest : public ::testing::TestWithParam<const char*> {// You can implement all the usual class fixture members here.};// Then, use the TEST_P macro to define as many parameterized tests// for this fixture as you want. The _P suffix is for "parameterized"// or "pattern", whichever you prefer to think.TEST_P(FooTest, DoesBlah) {// Inside a test, access the test parameter with the GetParam() method// of the TestWithParam<T> class:EXPECT_TRUE(foo.Blah(GetParam()));...}TEST_P(FooTest, HasBlahBlah) {...}// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test// case with any set of parameters you want. Google Test defines a number// of functions for generating test parameters. They return what we call// (surprise!) parameter generators. Here is a summary of them, which// are all in the testing namespace:////// Range(begin, end [, step]) - Yields values {begin, begin+step,// begin+step+step, ...}. The values do not// include end. step defaults to 1.// Values(v1, v2, ..., vN) - Yields values {v1, v2, ..., vN}.// ValuesIn(container) - Yields values from a C-style array, an STL// ValuesIn(begin,end) container, or an iterator range [begin, end).// Bool() - Yields sequence {false, true}.// Combine(g1, g2, ..., gN) - Yields all combinations (the Cartesian product// for the math savvy) of the values generated// by the N generators.//// For more details, see comments at the definitions of these functions below// in this file.//// The following statement will instantiate tests from the FooTest test case// each with parameter values "meeny", "miny", and "moe".INSTANTIATE_TEST_CASE_P(InstantiationName,FooTest,Values("meeny", "miny", "moe"));// To distinguish different instances of the pattern, (yes, you// can instantiate it more then once) the first argument to the// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the// actual test case name. Remember to pick unique prefixes for different// instantiations. The tests from the instantiation above will have// these names://// * InstantiationName/FooTest.DoesBlah/0 for "meeny"// * InstantiationName/FooTest.DoesBlah/1 for "miny"// * InstantiationName/FooTest.DoesBlah/2 for "moe"// * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"// * InstantiationName/FooTest.HasBlahBlah/1 for "miny"// * InstantiationName/FooTest.HasBlahBlah/2 for "moe"//// You can use these names in --gtest_filter.//// This statement will instantiate all tests from FooTest again, each// with parameter values "cat" and "dog":const char* pets[] = {"cat", "dog"};INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));// The tests from the instantiation above will have these names://// * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"// * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"// * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"// * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"//// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests// in the given test case, whether their definitions come before or// AFTER the INSTANTIATE_TEST_CASE_P statement.//// Please also note that generator expressions (including parameters to the// generators) are evaluated in InitGoogleTest(), after main() has started.// This allows the user on one hand, to adjust generator parameters in order// to dynamically determine a set of tests to run and on the other hand,// give the user a chance to inspect the generated tests with Google Test// reflection API before RUN_ALL_TESTS() is executed.//// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc// for more examples.//// In the future, we plan to publish the API for defining new parameter// generators. But for now this interface remains part of the internal// implementation and is subject to change.////// A parameterized test fixture must be derived from testing::Test and from// testing::WithParamInterface<T>, where T is the type of the parameter// values. Inheriting from TestWithParam<T> satisfies that requirement because// TestWithParam<T> inherits from both Test and WithParamInterface. In more// complicated hierarchies, however, it is occasionally useful to inherit// separately from Test and WithParamInterface. For example:class BaseTest : public ::testing::Test {// You can inherit all the usual members for a non-parameterized test// fixture here.};class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {// The usual test fixture members go here too.};TEST_F(BaseTest, HasFoo) {// This is an ordinary non-parameterized test.}TEST_P(DerivedTest, DoesBlah) {// GetParam works just the same here as if you inherit from TestWithParam.EXPECT_TRUE(foo.Blah(GetParam()));}#endif // 0#include "gtest/internal/gtest-port.h"#if !GTEST_OS_SYMBIAN# include <utility>#endif#include "gtest/internal/gtest-internal.h"#include "gtest/internal/gtest-param-util.h"#include "gtest/internal/gtest-param-util-generated.h"namespace testing {// Functions producing parameter generators.//// Google Test uses these generators to produce parameters for value-// parameterized tests. When a parameterized test case is instantiated// with a particular generator, Google Test creates and runs tests// for each element in the sequence produced by the generator.//// In the following sample, tests from test case FooTest are instantiated// each three times with parameter values 3, 5, and 8://// class FooTest : public TestWithParam<int> { ... };//// TEST_P(FooTest, TestThis) {// }// TEST_P(FooTest, TestThat) {// }// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8));//// Range() returns generators providing sequences of values in a range.//// Synopsis:// Range(start, end)// - returns a generator producing a sequence of values {start, start+1,// start+2, ..., }.// Range(start, end, step)// - returns a generator producing a sequence of values {start, start+step,// start+step+step, ..., }.// Notes:// * The generated sequences never include end. For example, Range(1, 5)// returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)// returns a generator producing {1, 3, 5, 7}.// * start and end must have the same type. That type may be any integral or// floating-point type or a user defined type satisfying these conditions:// * It must be assignable (have operator=() defined).// * It must have operator+() (operator+(int-compatible type) for// two-operand version).// * It must have operator<() defined.// Elements in the resulting sequences will also have that type.// * Condition start < end must be satisfied in order for resulting sequences// to contain any elements.//template <typename T, typename IncrementT>internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {return internal::ParamGenerator<T>(new internal::RangeGenerator<T, IncrementT>(start, end, step));}template <typename T>internal::ParamGenerator<T> Range(T start, T end) {return Range(start, end, 1);}// ValuesIn() function allows generation of tests with parameters coming from// a container.//// Synopsis:// ValuesIn(const T (&array)[N])// - returns a generator producing sequences with elements from// a C-style array.// ValuesIn(const Container& container)// - returns a generator producing sequences with elements from// an STL-style container.// ValuesIn(Iterator begin, Iterator end)// - returns a generator producing sequences with elements from// a range [begin, end) defined by a pair of STL-style iterators. These// iterators can also be plain C pointers.//// Please note that ValuesIn copies the values from the containers// passed in and keeps them to generate tests in RUN_ALL_TESTS().//// Examples://// This instantiates tests from test case StringTest// each with C-string values of "foo", "bar", and "baz"://// const char* strings[] = {"foo", "bar", "baz"};// INSTANTIATE_TEST_CASE_P(StringSequence, StringTest, ValuesIn(strings));//// This instantiates tests from test case StlStringTest// each with STL strings with values "a" and "b"://// ::std::vector< ::std::string> GetParameterStrings() {// ::std::vector< ::std::string> v;// v.push_back("a");// v.push_back("b");// return v;// }//// INSTANTIATE_TEST_CASE_P(CharSequence,// StlStringTest,// ValuesIn(GetParameterStrings()));////// This will also instantiate tests from CharTest// each with parameter values 'a' and 'b'://// ::std::list<char> GetParameterChars() {// ::std::list<char> list;// list.push_back('a');// list.push_back('b');// return list;// }// ::std::list<char> l = GetParameterChars();// INSTANTIATE_TEST_CASE_P(CharSequence2,// CharTest,// ValuesIn(l.begin(), l.end()));//template <typename ForwardIterator>internal::ParamGenerator<typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>ValuesIn(ForwardIterator begin, ForwardIterator end) {typedef typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type ParamType;return internal::ParamGenerator<ParamType>(new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));}template <typename T, size_t N>internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {return ValuesIn(array, array + N);}template <class Container>internal::ParamGenerator<typename Container::value_type> ValuesIn(const Container& container) {return ValuesIn(container.begin(), container.end());}// Values() allows generating tests from explicitly specified list of// parameters.//// Synopsis:// Values(T v1, T v2, ..., T vN)// - returns a generator producing sequences with elements v1, v2, ..., vN.//// For example, this instantiates tests from test case BarTest each// with values "one", "two", and "three"://// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three"));//// This instantiates tests from test case BazTest each with values 1, 2, 3.5.// The exact type of values will depend on the type of parameter in BazTest.//// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));//// Currently, Values() supports from 1 to $n parameters.//$range i 1..n$for i [[$range j 1..itemplate <$for j, [[typename T$j]]>internal::ValueArray$i<$for j, [[T$j]]> Values($for j, [[T$j v$j]]) {return internal::ValueArray$i<$for j, [[T$j]]>($for j, [[v$j]]);}]]// Bool() allows generating tests with parameters in a set of (false, true).//// Synopsis:// Bool()// - returns a generator producing sequences with elements {false, true}.//// It is useful when testing code that depends on Boolean flags. Combinations// of multiple flags can be tested when several Bool()'s are combined using// Combine() function.//// In the following example all tests in the test case FlagDependentTest// will be instantiated twice with parameters false and true.//// class FlagDependentTest : public testing::TestWithParam<bool> {// virtual void SetUp() {// external_flag = GetParam();// }// }// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool());//inline internal::ParamGenerator<bool> Bool() {return Values(false, true);}# if GTEST_HAS_COMBINE// Combine() allows the user to combine two or more sequences to produce// values of a Cartesian product of those sequences' elements.//// Synopsis:// Combine(gen1, gen2, ..., genN)// - returns a generator producing sequences with elements coming from// the Cartesian product of elements from the sequences generated by// gen1, gen2, ..., genN. The sequence elements will have a type of// tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types// of elements from sequences produces by gen1, gen2, ..., genN.//// Combine can have up to $maxtuple arguments. This number is currently limited// by the maximum number of elements in the tuple implementation used by Google// Test.//// Example://// This will instantiate tests in test case AnimalTest each one with// the parameter values tuple("cat", BLACK), tuple("cat", WHITE),// tuple("dog", BLACK), and tuple("dog", WHITE)://// enum Color { BLACK, GRAY, WHITE };// class AnimalTest// : public testing::TestWithParam<tuple<const char*, Color> > {...};//// TEST_P(AnimalTest, AnimalLooksNice) {...}//// INSTANTIATE_TEST_CASE_P(AnimalVariations, AnimalTest,// Combine(Values("cat", "dog"),// Values(BLACK, WHITE)));//// This will instantiate tests in FlagDependentTest with all variations of two// Boolean flags://// class FlagDependentTest// : public testing::TestWithParam<tuple<bool, bool> > {// virtual void SetUp() {// // Assigns external_flag_1 and external_flag_2 values from the tuple.// tie(external_flag_1, external_flag_2) = GetParam();// }// };//// TEST_P(FlagDependentTest, TestFeature1) {// // Test your code using external_flag_1 and external_flag_2 here.// }// INSTANTIATE_TEST_CASE_P(TwoBoolSequence, FlagDependentTest,// Combine(Bool(), Bool()));//$range i 2..maxtuple$for i [[$range j 1..itemplate <$for j, [[typename Generator$j]]>internal::CartesianProductHolder$i<$for j, [[Generator$j]]> Combine($for j, [[const Generator$j& g$j]]) {return internal::CartesianProductHolder$i<$for j, [[Generator$j]]>($for j, [[g$j]]);}]]# endif // GTEST_HAS_COMBINE# define TEST_P(test_case_name, test_name) \class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \: public test_case_name { \public: \GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \virtual void TestBody(); \private: \static int AddToRegistry() { \::testing::UnitTest::GetInstance()->parameterized_test_registry(). \GetTestCasePatternHolder<test_case_name>(\#test_case_name, \::testing::internal::CodeLocation(\__FILE__, __LINE__))->AddTestPattern(\GTEST_STRINGIFY_(test_case_name), \GTEST_STRINGIFY_(test_name), \new ::testing::internal::TestMetaFactory< \GTEST_TEST_CLASS_NAME_(\test_case_name, test_name)>()); \return 0; \} \static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_; \GTEST_DISALLOW_COPY_AND_ASSIGN_(\GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \}; \int GTEST_TEST_CLASS_NAME_(test_case_name, \test_name)::gtest_registering_dummy_ = \GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()// The optional last argument to INSTANTIATE_TEST_CASE_P allows the user// to specify a function or functor that generates custom test name suffixes// based on the test parameters. The function should accept one argument of// type testing::TestParamInfo<class ParamType>, and return std::string.//// testing::PrintToStringParamName is a builtin test suffix generator that// returns the value of testing::PrintToString(GetParam()).//// Note: test names must be non-empty, unique, and may only contain ASCII// alphanumeric characters or underscore. Because PrintToString adds quotes// to std::string and C strings, it won't work for these types.# define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator, ...) \static ::testing::internal::ParamGenerator<test_case_name::ParamType> \gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \static ::std::string gtest_##prefix##test_case_name##_EvalGenerateName_( \const ::testing::TestParamInfo<test_case_name::ParamType>& info) { \return ::testing::internal::GetParamNameGen<test_case_name::ParamType> \(__VA_ARGS__)(info); \} \static int gtest_##prefix##test_case_name##_dummy_ GTEST_ATTRIBUTE_UNUSED_ = \::testing::UnitTest::GetInstance()->parameterized_test_registry(). \GetTestCasePatternHolder<test_case_name>(\#test_case_name, \::testing::internal::CodeLocation(\__FILE__, __LINE__))->AddTestCaseInstantiation(\#prefix, \>est_##prefix##test_case_name##_EvalGenerator_, \>est_##prefix##test_case_name##_EvalGenerateName_, \__FILE__, __LINE__)} // namespace testing#endif // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_