"Fossies" - the Fresh Open Source Software Archive

Member "ponyc-0.33.0/lib/gtest/gtest/gtest-param-test.h.pump" (1 Nov 2019, 20042 Bytes) of package /linux/misc/ponyc-0.33.0.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    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 
   59 class 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 
   67 TEST_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 
   74 TEST_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 
  102 INSTANTIATE_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 
  125 const char* pets[] = {"cat", "dog"};
  126 INSTANTIATE_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 
  161 class BaseTest : public ::testing::Test {
  162   // You can inherit all the usual members for a non-parameterized test
  163   // fixture here.
  164 };
  165 
  166 class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
  167   // The usual test fixture members go here too.
  168 };
  169 
  170 TEST_F(BaseTest, HasFoo) {
  171   // This is an ordinary non-parameterized test.
  172 }
  173 
  174 TEST_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 
  196 namespace 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 //
  240 template <typename T, typename IncrementT>
  241 internal::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 
  246 template <typename T>
  247 internal::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 //
  306 template <typename ForwardIterator>
  307 internal::ParamGenerator<
  308   typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
  309 ValuesIn(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 
  316 template <typename T, size_t N>
  317 internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
  318   return ValuesIn(array, array + N);
  319 }
  320 
  321 template <class Container>
  322 internal::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 
  350 template <$for j, [[typename T$j]]>
  351 internal::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 //
  377 inline 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 
  434 template <$for j, [[typename Generator$j]]>
  435 internal::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_