ext/googletest/include/gtest/gtest-param-test.h.pump - amd/gem5 - Git at Google

 $$ -*- 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.
 //
 // Authors: vladl@google.com (Vlad Losev)
 //
 // Macros and functions for implementing parameterized tests
 // in Google C++ Testing Framework (Google Test)
 //
 // This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
 //
 #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

 // scripts/fuse_gtest.py depends on gtest's own header being #included
 // *unconditionally*.  Therefore these #includes cannot be moved
 // inside #if GTEST_HAS_PARAM_TEST.
 #include "gtest/internal/gtest-internal.h"
 #include "gtest/internal/gtest-param-util.h"
 #include "gtest/internal/gtest-param-util-generated.h"

 #if GTEST_HAS_PARAM_TEST

 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, SrtingTest, 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..i

 template <$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..i

 template <$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(\
                       #test_case_name, \
                       #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, ...) \
   ::testing::internal::ParamGenerator<test_case_name::ParamType> \
       gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \
   ::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); \
   } \
   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, \
                       &gtest_##prefix##test_case_name##_EvalGenerator_, \
                       &gtest_##prefix##test_case_name##_EvalGenerateName_, \
                       __FILE__, __LINE__)

 }  // namespace testing

 #endif  // GTEST_HAS_PARAM_TEST

 #endif  // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
	$$ -- 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.
	//
	// Authors: vladl@google.com (Vlad Losev)
	//
	// Macros and functions for implementing parameterized tests
	// in Google C++ Testing Framework (Google Test)
	//
	// This file is generated by a SCRIPT. DO NOT EDIT BY HAND!
	//
	#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

	// scripts/fuse_gtest.py depends on gtest's own header being #included
	// unconditionally. Therefore these #includes cannot be moved
	// inside #if GTEST_HAS_PARAM_TEST.
	#include "gtest/internal/gtest-internal.h"
	#include "gtest/internal/gtest-param-util.h"
	#include "gtest/internal/gtest-param-util-generated.h"

	#if GTEST_HAS_PARAM_TEST

	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, SrtingTest, 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..i

	template <$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..i

	template <$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(\
	#test_case_name, \
	#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, ...) \
	::testing::internal::ParamGenerator<test_case_name::ParamType> \
	gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \
	::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); \
	} \
	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, \
	&gtest_##prefix##test_case_name##_EvalGenerator_, \
	&gtest_##prefix##test_case_name##_EvalGenerateName_, \
	__FILE__, __LINE__)

	} // namespace testing

	#endif // GTEST_HAS_PARAM_TEST

	#endif // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_