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