1$$ -*- mode: c++; -*-
2$var n = 50  $$ Maximum length of Values arguments we want to support.
3$var maxtuple = 10  $$ Maximum number of Combine arguments we want to support.
4// Copyright 2008, Google Inc.
5// All rights reserved.
6//
7// Redistribution and use in source and binary forms, with or without
8// modification, are permitted provided that the following conditions are
9// met:
10//
11//     * Redistributions of source code must retain the above copyright
12// notice, this list of conditions and the following disclaimer.
13//     * Redistributions in binary form must reproduce the above
14// copyright notice, this list of conditions and the following disclaimer
15// in the documentation and/or other materials provided with the
16// distribution.
17//     * Neither the name of Google Inc. nor the names of its
18// contributors may be used to endorse or promote products derived from
19// this software without specific prior written permission.
20//
21// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32//
33// Authors: vladl@google.com (Vlad Losev)
34//
35// Macros and functions for implementing parameterized tests
36// in Google C++ Testing Framework (Google Test)
37//
38// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
39//
40#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
41#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
42
43
44// Value-parameterized tests allow you to test your code with different
45// parameters without writing multiple copies of the same test.
46//
47// Here is how you use value-parameterized tests:
48
49#if 0
50
51// To write value-parameterized tests, first you should define a fixture
52// class. It is usually derived from testing::TestWithParam<T> (see below for
53// another inheritance scheme that's sometimes useful in more complicated
54// class hierarchies), where the type of your parameter values.
55// TestWithParam<T> is itself derived from testing::Test. T can be any
56// copyable type. If it's a raw pointer, you are responsible for managing the
57// lifespan of the pointed values.
58
59class FooTest : public ::testing::TestWithParam<const char*> {
60  // You can implement all the usual class fixture members here.
61};
62
63// Then, use the TEST_P macro to define as many parameterized tests
64// for this fixture as you want. The _P suffix is for "parameterized"
65// or "pattern", whichever you prefer to think.
66
67TEST_P(FooTest, DoesBlah) {
68  // Inside a test, access the test parameter with the GetParam() method
69  // of the TestWithParam<T> class:
70  EXPECT_TRUE(foo.Blah(GetParam()));
71  ...
72}
73
74TEST_P(FooTest, HasBlahBlah) {
75  ...
76}
77
78// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test
79// case with any set of parameters you want. Google Test defines a number
80// of functions for generating test parameters. They return what we call
81// (surprise!) parameter generators. Here is a  summary of them, which
82// are all in the testing namespace:
83//
84//
85//  Range(begin, end [, step]) - Yields values {begin, begin+step,
86//                               begin+step+step, ...}. The values do not
87//                               include end. step defaults to 1.
88//  Values(v1, v2, ..., vN)    - Yields values {v1, v2, ..., vN}.
89//  ValuesIn(container)        - Yields values from a C-style array, an STL
90//  ValuesIn(begin,end)          container, or an iterator range [begin, end).
91//  Bool()                     - Yields sequence {false, true}.
92//  Combine(g1, g2, ..., gN)   - Yields all combinations (the Cartesian product
93//                               for the math savvy) of the values generated
94//                               by the N generators.
95//
96// For more details, see comments at the definitions of these functions below
97// in this file.
98//
99// The following statement will instantiate tests from the FooTest test case
100// each with parameter values "meeny", "miny", and "moe".
101
102INSTANTIATE_TEST_CASE_P(InstantiationName,
103                        FooTest,
104                        Values("meeny", "miny", "moe"));
105
106// To distinguish different instances of the pattern, (yes, you
107// can instantiate it more then once) the first argument to the
108// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the
109// actual test case name. Remember to pick unique prefixes for different
110// instantiations. The tests from the instantiation above will have
111// these names:
112//
113//    * InstantiationName/FooTest.DoesBlah/0 for "meeny"
114//    * InstantiationName/FooTest.DoesBlah/1 for "miny"
115//    * InstantiationName/FooTest.DoesBlah/2 for "moe"
116//    * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
117//    * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
118//    * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
119//
120// You can use these names in --gtest_filter.
121//
122// This statement will instantiate all tests from FooTest again, each
123// with parameter values "cat" and "dog":
124
125const char* pets[] = {"cat", "dog"};
126INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
127
128// The tests from the instantiation above will have these names:
129//
130//    * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
131//    * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
132//    * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
133//    * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
134//
135// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests
136// in the given test case, whether their definitions come before or
137// AFTER the INSTANTIATE_TEST_CASE_P statement.
138//
139// Please also note that generator expressions (including parameters to the
140// generators) are evaluated in InitGoogleTest(), after main() has started.
141// This allows the user on one hand, to adjust generator parameters in order
142// to dynamically determine a set of tests to run and on the other hand,
143// give the user a chance to inspect the generated tests with Google Test
144// reflection API before RUN_ALL_TESTS() is executed.
145//
146// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
147// for more examples.
148//
149// In the future, we plan to publish the API for defining new parameter
150// generators. But for now this interface remains part of the internal
151// implementation and is subject to change.
152//
153//
154// A parameterized test fixture must be derived from testing::Test and from
155// testing::WithParamInterface<T>, where T is the type of the parameter
156// values. Inheriting from TestWithParam<T> satisfies that requirement because
157// TestWithParam<T> inherits from both Test and WithParamInterface. In more
158// complicated hierarchies, however, it is occasionally useful to inherit
159// separately from Test and WithParamInterface. For example:
160
161class BaseTest : public ::testing::Test {
162  // You can inherit all the usual members for a non-parameterized test
163  // fixture here.
164};
165
166class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
167  // The usual test fixture members go here too.
168};
169
170TEST_F(BaseTest, HasFoo) {
171  // This is an ordinary non-parameterized test.
172}
173
174TEST_P(DerivedTest, DoesBlah) {
175  // GetParam works just the same here as if you inherit from TestWithParam.
176  EXPECT_TRUE(foo.Blah(GetParam()));
177}
178
179#endif  // 0
180
181#include "gtest/internal/gtest-port.h"
182
183#if !GTEST_OS_SYMBIAN
184# include <utility>
185#endif
186
187// scripts/fuse_gtest.py depends on gtest's own header being #included
188// *unconditionally*.  Therefore these #includes cannot be moved
189// inside #if GTEST_HAS_PARAM_TEST.
190#include "gtest/internal/gtest-internal.h"
191#include "gtest/internal/gtest-param-util.h"
192#include "gtest/internal/gtest-param-util-generated.h"
193
194#if GTEST_HAS_PARAM_TEST
195
196namespace testing {
197
198// Functions producing parameter generators.
199//
200// Google Test uses these generators to produce parameters for value-
201// parameterized tests. When a parameterized test case is instantiated
202// with a particular generator, Google Test creates and runs tests
203// for each element in the sequence produced by the generator.
204//
205// In the following sample, tests from test case FooTest are instantiated
206// each three times with parameter values 3, 5, and 8:
207//
208// class FooTest : public TestWithParam<int> { ... };
209//
210// TEST_P(FooTest, TestThis) {
211// }
212// TEST_P(FooTest, TestThat) {
213// }
214// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8));
215//
216
217// Range() returns generators providing sequences of values in a range.
218//
219// Synopsis:
220// Range(start, end)
221//   - returns a generator producing a sequence of values {start, start+1,
222//     start+2, ..., }.
223// Range(start, end, step)
224//   - returns a generator producing a sequence of values {start, start+step,
225//     start+step+step, ..., }.
226// Notes:
227//   * The generated sequences never include end. For example, Range(1, 5)
228//     returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
229//     returns a generator producing {1, 3, 5, 7}.
230//   * start and end must have the same type. That type may be any integral or
231//     floating-point type or a user defined type satisfying these conditions:
232//     * It must be assignable (have operator=() defined).
233//     * It must have operator+() (operator+(int-compatible type) for
234//       two-operand version).
235//     * It must have operator<() defined.
236//     Elements in the resulting sequences will also have that type.
237//   * Condition start < end must be satisfied in order for resulting sequences
238//     to contain any elements.
239//
240template <typename T, typename IncrementT>
241internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
242  return internal::ParamGenerator<T>(
243      new internal::RangeGenerator<T, IncrementT>(start, end, step));
244}
245
246template <typename T>
247internal::ParamGenerator<T> Range(T start, T end) {
248  return Range(start, end, 1);
249}
250
251// ValuesIn() function allows generation of tests with parameters coming from
252// a container.
253//
254// Synopsis:
255// ValuesIn(const T (&array)[N])
256//   - returns a generator producing sequences with elements from
257//     a C-style array.
258// ValuesIn(const Container& container)
259//   - returns a generator producing sequences with elements from
260//     an STL-style container.
261// ValuesIn(Iterator begin, Iterator end)
262//   - returns a generator producing sequences with elements from
263//     a range [begin, end) defined by a pair of STL-style iterators. These
264//     iterators can also be plain C pointers.
265//
266// Please note that ValuesIn copies the values from the containers
267// passed in and keeps them to generate tests in RUN_ALL_TESTS().
268//
269// Examples:
270//
271// This instantiates tests from test case StringTest
272// each with C-string values of "foo", "bar", and "baz":
273//
274// const char* strings[] = {"foo", "bar", "baz"};
275// INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings));
276//
277// This instantiates tests from test case StlStringTest
278// each with STL strings with values "a" and "b":
279//
280// ::std::vector< ::std::string> GetParameterStrings() {
281//   ::std::vector< ::std::string> v;
282//   v.push_back("a");
283//   v.push_back("b");
284//   return v;
285// }
286//
287// INSTANTIATE_TEST_CASE_P(CharSequence,
288//                         StlStringTest,
289//                         ValuesIn(GetParameterStrings()));
290//
291//
292// This will also instantiate tests from CharTest
293// each with parameter values 'a' and 'b':
294//
295// ::std::list<char> GetParameterChars() {
296//   ::std::list<char> list;
297//   list.push_back('a');
298//   list.push_back('b');
299//   return list;
300// }
301// ::std::list<char> l = GetParameterChars();
302// INSTANTIATE_TEST_CASE_P(CharSequence2,
303//                         CharTest,
304//                         ValuesIn(l.begin(), l.end()));
305//
306template <typename ForwardIterator>
307internal::ParamGenerator<
308  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
309ValuesIn(ForwardIterator begin, ForwardIterator end) {
310  typedef typename ::testing::internal::IteratorTraits<ForwardIterator>
311      ::value_type ParamType;
312  return internal::ParamGenerator<ParamType>(
313      new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
314}
315
316template <typename T, size_t N>
317internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
318  return ValuesIn(array, array + N);
319}
320
321template <class Container>
322internal::ParamGenerator<typename Container::value_type> ValuesIn(
323    const Container& container) {
324  return ValuesIn(container.begin(), container.end());
325}
326
327// Values() allows generating tests from explicitly specified list of
328// parameters.
329//
330// Synopsis:
331// Values(T v1, T v2, ..., T vN)
332//   - returns a generator producing sequences with elements v1, v2, ..., vN.
333//
334// For example, this instantiates tests from test case BarTest each
335// with values "one", "two", and "three":
336//
337// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three"));
338//
339// This instantiates tests from test case BazTest each with values 1, 2, 3.5.
340// The exact type of values will depend on the type of parameter in BazTest.
341//
342// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
343//
344// Currently, Values() supports from 1 to $n parameters.
345//
346$range i 1..n
347$for i [[
348$range j 1..i
349
350template <$for j, [[typename T$j]]>
351internal::ValueArray$i<$for j, [[T$j]]> Values($for j, [[T$j v$j]]) {
352  return internal::ValueArray$i<$for j, [[T$j]]>($for j, [[v$j]]);
353}
354
355]]
356
357// Bool() allows generating tests with parameters in a set of (false, true).
358//
359// Synopsis:
360// Bool()
361//   - returns a generator producing sequences with elements {false, true}.
362//
363// It is useful when testing code that depends on Boolean flags. Combinations
364// of multiple flags can be tested when several Bool()'s are combined using
365// Combine() function.
366//
367// In the following example all tests in the test case FlagDependentTest
368// will be instantiated twice with parameters false and true.
369//
370// class FlagDependentTest : public testing::TestWithParam<bool> {
371//   virtual void SetUp() {
372//     external_flag = GetParam();
373//   }
374// }
375// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool());
376//
377inline internal::ParamGenerator<bool> Bool() {
378  return Values(false, true);
379}
380
381# if GTEST_HAS_COMBINE
382// Combine() allows the user to combine two or more sequences to produce
383// values of a Cartesian product of those sequences' elements.
384//
385// Synopsis:
386// Combine(gen1, gen2, ..., genN)
387//   - returns a generator producing sequences with elements coming from
388//     the Cartesian product of elements from the sequences generated by
389//     gen1, gen2, ..., genN. The sequence elements will have a type of
390//     tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
391//     of elements from sequences produces by gen1, gen2, ..., genN.
392//
393// Combine can have up to $maxtuple arguments. This number is currently limited
394// by the maximum number of elements in the tuple implementation used by Google
395// Test.
396//
397// Example:
398//
399// This will instantiate tests in test case AnimalTest each one with
400// the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
401// tuple("dog", BLACK), and tuple("dog", WHITE):
402//
403// enum Color { BLACK, GRAY, WHITE };
404// class AnimalTest
405//     : public testing::TestWithParam<tuple<const char*, Color> > {...};
406//
407// TEST_P(AnimalTest, AnimalLooksNice) {...}
408//
409// INSTANTIATE_TEST_CASE_P(AnimalVariations, AnimalTest,
410//                         Combine(Values("cat", "dog"),
411//                                 Values(BLACK, WHITE)));
412//
413// This will instantiate tests in FlagDependentTest with all variations of two
414// Boolean flags:
415//
416// class FlagDependentTest
417//     : public testing::TestWithParam<tuple<bool, bool> > {
418//   virtual void SetUp() {
419//     // Assigns external_flag_1 and external_flag_2 values from the tuple.
420//     tie(external_flag_1, external_flag_2) = GetParam();
421//   }
422// };
423//
424// TEST_P(FlagDependentTest, TestFeature1) {
425//   // Test your code using external_flag_1 and external_flag_2 here.
426// }
427// INSTANTIATE_TEST_CASE_P(TwoBoolSequence, FlagDependentTest,
428//                         Combine(Bool(), Bool()));
429//
430$range i 2..maxtuple
431$for i [[
432$range j 1..i
433
434template <$for j, [[typename Generator$j]]>
435internal::CartesianProductHolder$i<$for j, [[Generator$j]]> Combine(
436    $for j, [[const Generator$j& g$j]]) {
437  return internal::CartesianProductHolder$i<$for j, [[Generator$j]]>(
438      $for j, [[g$j]]);
439}
440
441]]
442# endif  // GTEST_HAS_COMBINE
443
444
445
446# define TEST_P(test_case_name, test_name) \
447  class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
448      : public test_case_name { \
449   public: \
450    GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \
451    virtual void TestBody(); \
452   private: \
453    static int AddToRegistry() { \
454      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
455          GetTestCasePatternHolder<test_case_name>(\
456              #test_case_name, \
457              ::testing::internal::CodeLocation(\
458                  __FILE__, __LINE__))->AddTestPattern(\
459                      #test_case_name, \
460                      #test_name, \
461                      new ::testing::internal::TestMetaFactory< \
462                          GTEST_TEST_CLASS_NAME_(\
463                              test_case_name, test_name)>()); \
464      return 0; \
465    } \
466    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_; \
467    GTEST_DISALLOW_COPY_AND_ASSIGN_(\
468        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
469  }; \
470  int GTEST_TEST_CLASS_NAME_(test_case_name, \
471                             test_name)::gtest_registering_dummy_ = \
472      GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
473  void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
474
475// The optional last argument to INSTANTIATE_TEST_CASE_P allows the user
476// to specify a function or functor that generates custom test name suffixes
477// based on the test parameters. The function should accept one argument of
478// type testing::TestParamInfo<class ParamType>, and return std::string.
479//
480// testing::PrintToStringParamName is a builtin test suffix generator that
481// returns the value of testing::PrintToString(GetParam()).
482//
483// Note: test names must be non-empty, unique, and may only contain ASCII
484// alphanumeric characters or underscore. Because PrintToString adds quotes
485// to std::string and C strings, it won't work for these types.
486
487# define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator, ...) \
488  ::testing::internal::ParamGenerator<test_case_name::ParamType> \
489      gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \
490  ::std::string gtest_##prefix##test_case_name##_EvalGenerateName_( \
491      const ::testing::TestParamInfo<test_case_name::ParamType>& info) { \
492    return ::testing::internal::GetParamNameGen<test_case_name::ParamType> \
493        (__VA_ARGS__)(info); \
494  } \
495  int gtest_##prefix##test_case_name##_dummy_ GTEST_ATTRIBUTE_UNUSED_ = \
496      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
497          GetTestCasePatternHolder<test_case_name>(\
498              #test_case_name, \
499              ::testing::internal::CodeLocation(\
500                  __FILE__, __LINE__))->AddTestCaseInstantiation(\
501                      #prefix, \
502                      &gtest_##prefix##test_case_name##_EvalGenerator_, \
503                      &gtest_##prefix##test_case_name##_EvalGenerateName_, \
504                      __FILE__, __LINE__)
505
506}  // namespace testing
507
508#endif  // GTEST_HAS_PARAM_TEST
509
510#endif  // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
511