Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  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, __FILE__, __LINE__)->AddTestPattern(\
  457.                   #test_case_name, \
  458.                   #test_name, \
  459.                   new ::testing::internal::TestMetaFactory< \
  460.                       GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>()); \
  461.       return 0; \
  462.     } \
  463.     static int gtest_registering_dummy_; \
  464.     GTEST_DISALLOW_COPY_AND_ASSIGN_(\
  465.         GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
  466.   }; \
  467.   int GTEST_TEST_CLASS_NAME_(test_case_name, \
  468.                              test_name)::gtest_registering_dummy_ = \
  469.       GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
  470.   void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
  471.  
  472. # define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator) \
  473.   ::testing::internal::ParamGenerator<test_case_name::ParamType> \
  474.       gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \
  475.   int gtest_##prefix##test_case_name##_dummy_ = \
  476.       ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
  477.           GetTestCasePatternHolder<test_case_name>(\
  478.               #test_case_name, __FILE__, __LINE__)->AddTestCaseInstantiation(\
  479.                   #prefix, \
  480.                   &gtest_##prefix##test_case_name##_EvalGenerator_, \
  481.                   __FILE__, __LINE__)
  482.  
  483. }  // namespace testing
  484.  
  485. #endif  // GTEST_HAS_PARAM_TEST
  486.  
  487. #endif  // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
  488.