/thirdparty/breakpad/third_party/protobuf/protobuf/gtest/include/gtest/gtest-param-test.h.pump

  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 must be derived from testing::TestWithParam<T>, where T is
 53// the type of your parameter values. TestWithParam<T> is itself derived
 54// from testing::Test. T can be any copyable type. If it's a raw pointer,
 55// you are responsible for managing the lifespan of the pointed values.
 56
 57class FooTest : public ::testing::TestWithParam<const char*> {
 58  // You can implement all the usual class fixture members here.
 59};
 60
 61// Then, use the TEST_P macro to define as many parameterized tests
 62// for this fixture as you want. The _P suffix is for "parameterized"
 63// or "pattern", whichever you prefer to think.
 64
 65TEST_P(FooTest, DoesBlah) {
 66  // Inside a test, access the test parameter with the GetParam() method
 67  // of the TestWithParam<T> class:
 68  EXPECT_TRUE(foo.Blah(GetParam()));
 69  ...
 70}
 71
 72TEST_P(FooTest, HasBlahBlah) {
 73  ...
 74}
 75
 76// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test
 77// case with any set of parameters you want. Google Test defines a number
 78// of functions for generating test parameters. They return what we call
 79// (surprise!) parameter generators. Here is a  summary of them, which
 80// are all in the testing namespace:
 81//
 82//
 83//  Range(begin, end [, step]) - Yields values {begin, begin+step,
 84//                               begin+step+step, ...}. The values do not
 85//                               include end. step defaults to 1.
 86//  Values(v1, v2, ..., vN)    - Yields values {v1, v2, ..., vN}.
 87//  ValuesIn(container)        - Yields values from a C-style array, an STL
 88//  ValuesIn(begin,end)          container, or an iterator range [begin, end).
 89//  Bool()                     - Yields sequence {false, true}.
 90//  Combine(g1, g2, ..., gN)   - Yields all combinations (the Cartesian product
 91//                               for the math savvy) of the values generated
 92//                               by the N generators.
 93//
 94// For more details, see comments at the definitions of these functions below
 95// in this file.
 96//
 97// The following statement will instantiate tests from the FooTest test case
 98// each with parameter values "meeny", "miny", and "moe".
 99
100INSTANTIATE_TEST_CASE_P(InstantiationName,
101                        FooTest,
102                        Values("meeny", "miny", "moe"));
103
104// To distinguish different instances of the pattern, (yes, you
105// can instantiate it more then once) the first argument to the
106// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the
107// actual test case name. Remember to pick unique prefixes for different
108// instantiations. The tests from the instantiation above will have
109// these names:
110//
111//    * InstantiationName/FooTest.DoesBlah/0 for "meeny"
112//    * InstantiationName/FooTest.DoesBlah/1 for "miny"
113//    * InstantiationName/FooTest.DoesBlah/2 for "moe"
114//    * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
115//    * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
116//    * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
117//
118// You can use these names in --gtest_filter.
119//
120// This statement will instantiate all tests from FooTest again, each
121// with parameter values "cat" and "dog":
122
123const char* pets[] = {"cat", "dog"};
124INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
125
126// The tests from the instantiation above will have these names:
127//
128//    * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
129//    * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
130//    * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
131//    * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
132//
133// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests
134// in the given test case, whether their definitions come before or
135// AFTER the INSTANTIATE_TEST_CASE_P statement.
136//
137// Please also note that generator expressions are evaluated in
138// RUN_ALL_TESTS(), after main() has started. This allows evaluation of
139// parameter list based on command line parameters.
140//
141// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
142// for more examples.
143//
144// In the future, we plan to publish the API for defining new parameter
145// generators. But for now this interface remains part of the internal
146// implementation and is subject to change.
147
148#endif  // 0
149
150#include <gtest/internal/gtest-port.h>
151
152#if !GTEST_OS_SYMBIAN
153#include <utility>
154#endif
155
156// scripts/fuse_gtest.py depends on gtest's own header being #included
157// *unconditionally*.  Therefore these #includes cannot be moved
158// inside #if GTEST_HAS_PARAM_TEST.
159#include <gtest/internal/gtest-internal.h>
160#include <gtest/internal/gtest-param-util.h>
161#include <gtest/internal/gtest-param-util-generated.h>
162
163#if GTEST_HAS_PARAM_TEST
164
165namespace testing {
166
167// Functions producing parameter generators.
168//
169// Google Test uses these generators to produce parameters for value-
170// parameterized tests. When a parameterized test case is instantiated
171// with a particular generator, Google Test creates and runs tests
172// for each element in the sequence produced by the generator.
173//
174// In the following sample, tests from test case FooTest are instantiated
175// each three times with parameter values 3, 5, and 8:
176//
177// class FooTest : public TestWithParam<int> { ... };
178//
179// TEST_P(FooTest, TestThis) {
180// }
181// TEST_P(FooTest, TestThat) {
182// }
183// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8));
184//
185
186// Range() returns generators providing sequences of values in a range.
187//
188// Synopsis:
189// Range(start, end)
190//   - returns a generator producing a sequence of values {start, start+1,
191//     start+2, ..., }.
192// Range(start, end, step)
193//   - returns a generator producing a sequence of values {start, start+step,
194//     start+step+step, ..., }.
195// Notes:
196//   * The generated sequences never include end. For example, Range(1, 5)
197//     returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
198//     returns a generator producing {1, 3, 5, 7}.
199//   * start and end must have the same type. That type may be any integral or
200//     floating-point type or a user defined type satisfying these conditions:
201//     * It must be assignable (have operator=() defined).
202//     * It must have operator+() (operator+(int-compatible type) for
203//       two-operand version).
204//     * It must have operator<() defined.
205//     Elements in the resulting sequences will also have that type.
206//   * Condition start < end must be satisfied in order for resulting sequences
207//     to contain any elements.
208//
209template <typename T, typename IncrementT>
210internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
211  return internal::ParamGenerator<T>(
212      new internal::RangeGenerator<T, IncrementT>(start, end, step));
213}
214
215template <typename T>
216internal::ParamGenerator<T> Range(T start, T end) {
217  return Range(start, end, 1);
218}
219
220// ValuesIn() function allows generation of tests with parameters coming from
221// a container.
222//
223// Synopsis:
224// ValuesIn(const T (&array)[N])
225//   - returns a generator producing sequences with elements from
226//     a C-style array.
227// ValuesIn(const Container& container)
228//   - returns a generator producing sequences with elements from
229//     an STL-style container.
230// ValuesIn(Iterator begin, Iterator end)
231//   - returns a generator producing sequences with elements from
232//     a range [begin, end) defined by a pair of STL-style iterators. These
233//     iterators can also be plain C pointers.
234//
235// Please note that ValuesIn copies the values from the containers
236// passed in and keeps them to generate tests in RUN_ALL_TESTS().
237//
238// Examples:
239//
240// This instantiates tests from test case StringTest
241// each with C-string values of "foo", "bar", and "baz":
242//
243// const char* strings[] = {"foo", "bar", "baz"};
244// INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings));
245//
246// This instantiates tests from test case StlStringTest
247// each with STL strings with values "a" and "b":
248//
249// ::std::vector< ::std::string> GetParameterStrings() {
250//   ::std::vector< ::std::string> v;
251//   v.push_back("a");
252//   v.push_back("b");
253//   return v;
254// }
255//
256// INSTANTIATE_TEST_CASE_P(CharSequence,
257//                         StlStringTest,
258//                         ValuesIn(GetParameterStrings()));
259//
260//
261// This will also instantiate tests from CharTest
262// each with parameter values 'a' and 'b':
263//
264// ::std::list<char> GetParameterChars() {
265//   ::std::list<char> list;
266//   list.push_back('a');
267//   list.push_back('b');
268//   return list;
269// }
270// ::std::list<char> l = GetParameterChars();
271// INSTANTIATE_TEST_CASE_P(CharSequence2,
272//                         CharTest,
273//                         ValuesIn(l.begin(), l.end()));
274//
275template <typename ForwardIterator>
276internal::ParamGenerator<
277    typename ::std::iterator_traits<ForwardIterator>::value_type> ValuesIn(
278  ForwardIterator begin,
279  ForwardIterator end) {
280  typedef typename ::std::iterator_traits<ForwardIterator>::value_type
281      ParamType;
282  return internal::ParamGenerator<ParamType>(
283      new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
284}
285
286template <typename T, size_t N>
287internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
288  return ValuesIn(array, array + N);
289}
290
291template <class Container>
292internal::ParamGenerator<typename Container::value_type> ValuesIn(
293    const Container& container) {
294  return ValuesIn(container.begin(), container.end());
295}
296
297// Values() allows generating tests from explicitly specified list of
298// parameters.
299//
300// Synopsis:
301// Values(T v1, T v2, ..., T vN)
302//   - returns a generator producing sequences with elements v1, v2, ..., vN.
303//
304// For example, this instantiates tests from test case BarTest each
305// with values "one", "two", and "three":
306//
307// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three"));
308//
309// This instantiates tests from test case BazTest each with values 1, 2, 3.5.
310// The exact type of values will depend on the type of parameter in BazTest.
311//
312// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
313//
314// Currently, Values() supports from 1 to $n parameters.
315//
316$range i 1..n
317$for i [[
318$range j 1..i
319
320template <$for j, [[typename T$j]]>
321internal::ValueArray$i<$for j, [[T$j]]> Values($for j, [[T$j v$j]]) {
322  return internal::ValueArray$i<$for j, [[T$j]]>($for j, [[v$j]]);
323}
324
325]]
326
327// Bool() allows generating tests with parameters in a set of (false, true).
328//
329// Synopsis:
330// Bool()
331//   - returns a generator producing sequences with elements {false, true}.
332//
333// It is useful when testing code that depends on Boolean flags. Combinations
334// of multiple flags can be tested when several Bool()'s are combined using
335// Combine() function.
336//
337// In the following example all tests in the test case FlagDependentTest
338// will be instantiated twice with parameters false and true.
339//
340// class FlagDependentTest : public testing::TestWithParam<bool> {
341//   virtual void SetUp() {
342//     external_flag = GetParam();
343//   }
344// }
345// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool());
346//
347inline internal::ParamGenerator<bool> Bool() {
348  return Values(false, true);
349}
350
351#if GTEST_HAS_COMBINE
352// Combine() allows the user to combine two or more sequences to produce
353// values of a Cartesian product of those sequences' elements.
354//
355// Synopsis:
356// Combine(gen1, gen2, ..., genN)
357//   - returns a generator producing sequences with elements coming from
358//     the Cartesian product of elements from the sequences generated by
359//     gen1, gen2, ..., genN. The sequence elements will have a type of
360//     tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
361//     of elements from sequences produces by gen1, gen2, ..., genN.
362//
363// Combine can have up to $maxtuple arguments. This number is currently limited
364// by the maximum number of elements in the tuple implementation used by Google
365// Test.
366//
367// Example:
368//
369// This will instantiate tests in test case AnimalTest each one with
370// the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
371// tuple("dog", BLACK), and tuple("dog", WHITE):
372//
373// enum Color { BLACK, GRAY, WHITE };
374// class AnimalTest
375//     : public testing::TestWithParam<tuple<const char*, Color> > {...};
376//
377// TEST_P(AnimalTest, AnimalLooksNice) {...}
378//
379// INSTANTIATE_TEST_CASE_P(AnimalVariations, AnimalTest,
380//                         Combine(Values("cat", "dog"),
381//                                 Values(BLACK, WHITE)));
382//
383// This will instantiate tests in FlagDependentTest with all variations of two
384// Boolean flags:
385//
386// class FlagDependentTest
387//     : public testing::TestWithParam<tuple(bool, bool)> > {
388//   virtual void SetUp() {
389//     // Assigns external_flag_1 and external_flag_2 values from the tuple.
390//     tie(external_flag_1, external_flag_2) = GetParam();
391//   }
392// };
393//
394// TEST_P(FlagDependentTest, TestFeature1) {
395//   // Test your code using external_flag_1 and external_flag_2 here.
396// }
397// INSTANTIATE_TEST_CASE_P(TwoBoolSequence, FlagDependentTest,
398//                         Combine(Bool(), Bool()));
399//
400$range i 2..maxtuple
401$for i [[
402$range j 1..i
403
404template <$for j, [[typename Generator$j]]>
405internal::CartesianProductHolder$i<$for j, [[Generator$j]]> Combine(
406    $for j, [[const Generator$j& g$j]]) {
407  return internal::CartesianProductHolder$i<$for j, [[Generator$j]]>(
408      $for j, [[g$j]]);
409}
410
411]]
412#endif  // GTEST_HAS_COMBINE
413
414
415
416#define TEST_P(test_case_name, test_name) \
417  class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
418      : public test_case_name { \
419   public: \
420    GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \
421    virtual void TestBody(); \
422   private: \
423    static int AddToRegistry() { \
424      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
425          GetTestCasePatternHolder<test_case_name>(\
426              #test_case_name, __FILE__, __LINE__)->AddTestPattern(\
427                  #test_case_name, \
428                  #test_name, \
429                  new ::testing::internal::TestMetaFactory< \
430                      GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>()); \
431      return 0; \
432    } \
433    static int gtest_registering_dummy_; \
434    GTEST_DISALLOW_COPY_AND_ASSIGN_(\
435        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
436  }; \
437  int GTEST_TEST_CLASS_NAME_(test_case_name, \
438                             test_name)::gtest_registering_dummy_ = \
439      GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
440  void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
441
442#define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator) \
443  ::testing::internal::ParamGenerator<test_case_name::ParamType> \
444      gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \
445  int gtest_##prefix##test_case_name##_dummy_ = \
446      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
447          GetTestCasePatternHolder<test_case_name>(\
448              #test_case_name, __FILE__, __LINE__)->AddTestCaseInstantiation(\
449                  #prefix, \
450                  &gtest_##prefix##test_case_name##_EvalGenerator_, \
451                  __FILE__, __LINE__)
452
453}  // namespace testing
454
455#endif  // GTEST_HAS_PARAM_TEST
456
457#endif  // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_