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 and Mocking 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#include "gtest/internal/gtest-internal.h" 188#include "gtest/internal/gtest-param-util.h" 189#include "gtest/internal/gtest-param-util-generated.h" 190 191namespace testing { 192 193// Functions producing parameter generators. 194// 195// Google Test uses these generators to produce parameters for value- 196// parameterized tests. When a parameterized test case is instantiated 197// with a particular generator, Google Test creates and runs tests 198// for each element in the sequence produced by the generator. 199// 200// In the following sample, tests from test case FooTest are instantiated 201// each three times with parameter values 3, 5, and 8: 202// 203// class FooTest : public TestWithParam<int> { ... }; 204// 205// TEST_P(FooTest, TestThis) { 206// } 207// TEST_P(FooTest, TestThat) { 208// } 209// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8)); 210// 211 212// Range() returns generators providing sequences of values in a range. 213// 214// Synopsis: 215// Range(start, end) 216// - returns a generator producing a sequence of values {start, start+1, 217// start+2, ..., }. 218// Range(start, end, step) 219// - returns a generator producing a sequence of values {start, start+step, 220// start+step+step, ..., }. 221// Notes: 222// * The generated sequences never include end. For example, Range(1, 5) 223// returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2) 224// returns a generator producing {1, 3, 5, 7}. 225// * start and end must have the same type. That type may be any integral or 226// floating-point type or a user defined type satisfying these conditions: 227// * It must be assignable (have operator=() defined). 228// * It must have operator+() (operator+(int-compatible type) for 229// two-operand version). 230// * It must have operator<() defined. 231// Elements in the resulting sequences will also have that type. 232// * Condition start < end must be satisfied in order for resulting sequences 233// to contain any elements. 234// 235template <typename T, typename IncrementT> 236internal::ParamGenerator<T> Range(T start, T end, IncrementT step) { 237 return internal::ParamGenerator<T>( 238 new internal::RangeGenerator<T, IncrementT>(start, end, step)); 239} 240 241template <typename T> 242internal::ParamGenerator<T> Range(T start, T end) { 243 return Range(start, end, 1); 244} 245 246// ValuesIn() function allows generation of tests with parameters coming from 247// a container. 248// 249// Synopsis: 250// ValuesIn(const T (&array)[N]) 251// - returns a generator producing sequences with elements from 252// a C-style array. 253// ValuesIn(const Container& container) 254// - returns a generator producing sequences with elements from 255// an STL-style container. 256// ValuesIn(Iterator begin, Iterator end) 257// - returns a generator producing sequences with elements from 258// a range [begin, end) defined by a pair of STL-style iterators. These 259// iterators can also be plain C pointers. 260// 261// Please note that ValuesIn copies the values from the containers 262// passed in and keeps them to generate tests in RUN_ALL_TESTS(). 263// 264// Examples: 265// 266// This instantiates tests from test case StringTest 267// each with C-string values of "foo", "bar", and "baz": 268// 269// const char* strings[] = {"foo", "bar", "baz"}; 270// INSTANTIATE_TEST_CASE_P(StringSequence, StringTest, ValuesIn(strings)); 271// 272// This instantiates tests from test case StlStringTest 273// each with STL strings with values "a" and "b": 274// 275// ::std::vector< ::std::string> GetParameterStrings() { 276// ::std::vector< ::std::string> v; 277// v.push_back("a"); 278// v.push_back("b"); 279// return v; 280// } 281// 282// INSTANTIATE_TEST_CASE_P(CharSequence, 283// StlStringTest, 284// ValuesIn(GetParameterStrings())); 285// 286// 287// This will also instantiate tests from CharTest 288// each with parameter values 'a' and 'b': 289// 290// ::std::list<char> GetParameterChars() { 291// ::std::list<char> list; 292// list.push_back('a'); 293// list.push_back('b'); 294// return list; 295// } 296// ::std::list<char> l = GetParameterChars(); 297// INSTANTIATE_TEST_CASE_P(CharSequence2, 298// CharTest, 299// ValuesIn(l.begin(), l.end())); 300// 301template <typename ForwardIterator> 302internal::ParamGenerator< 303 typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type> 304ValuesIn(ForwardIterator begin, ForwardIterator end) { 305 typedef typename ::testing::internal::IteratorTraits<ForwardIterator> 306 ::value_type ParamType; 307 return internal::ParamGenerator<ParamType>( 308 new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end)); 309} 310 311template <typename T, size_t N> 312internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) { 313 return ValuesIn(array, array + N); 314} 315 316template <class Container> 317internal::ParamGenerator<typename Container::value_type> ValuesIn( 318 const Container& container) { 319 return ValuesIn(container.begin(), container.end()); 320} 321 322// Values() allows generating tests from explicitly specified list of 323// parameters. 324// 325// Synopsis: 326// Values(T v1, T v2, ..., T vN) 327// - returns a generator producing sequences with elements v1, v2, ..., vN. 328// 329// For example, this instantiates tests from test case BarTest each 330// with values "one", "two", and "three": 331// 332// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three")); 333// 334// This instantiates tests from test case BazTest each with values 1, 2, 3.5. 335// The exact type of values will depend on the type of parameter in BazTest. 336// 337// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5)); 338// 339// Currently, Values() supports from 1 to $n parameters. 340// 341$range i 1..n 342$for i [[ 343$range j 1..i 344 345template <$for j, [[typename T$j]]> 346internal::ValueArray$i<$for j, [[T$j]]> Values($for j, [[T$j v$j]]) { 347 return internal::ValueArray$i<$for j, [[T$j]]>($for j, [[v$j]]); 348} 349 350]] 351 352// Bool() allows generating tests with parameters in a set of (false, true). 353// 354// Synopsis: 355// Bool() 356// - returns a generator producing sequences with elements {false, true}. 357// 358// It is useful when testing code that depends on Boolean flags. Combinations 359// of multiple flags can be tested when several Bool()'s are combined using 360// Combine() function. 361// 362// In the following example all tests in the test case FlagDependentTest 363// will be instantiated twice with parameters false and true. 364// 365// class FlagDependentTest : public testing::TestWithParam<bool> { 366// virtual void SetUp() { 367// external_flag = GetParam(); 368// } 369// } 370// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool()); 371// 372inline internal::ParamGenerator<bool> Bool() { 373 return Values(false, true); 374} 375 376# if GTEST_HAS_COMBINE 377// Combine() allows the user to combine two or more sequences to produce 378// values of a Cartesian product of those sequences' elements. 379// 380// Synopsis: 381// Combine(gen1, gen2, ..., genN) 382// - returns a generator producing sequences with elements coming from 383// the Cartesian product of elements from the sequences generated by 384// gen1, gen2, ..., genN. The sequence elements will have a type of 385// tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types 386// of elements from sequences produces by gen1, gen2, ..., genN. 387// 388// Combine can have up to $maxtuple arguments. This number is currently limited 389// by the maximum number of elements in the tuple implementation used by Google 390// Test. 391// 392// Example: 393// 394// This will instantiate tests in test case AnimalTest each one with 395// the parameter values tuple("cat", BLACK), tuple("cat", WHITE), 396// tuple("dog", BLACK), and tuple("dog", WHITE): 397// 398// enum Color { BLACK, GRAY, WHITE }; 399// class AnimalTest 400// : public testing::TestWithParam<tuple<const char*, Color> > {...}; 401// 402// TEST_P(AnimalTest, AnimalLooksNice) {...} 403// 404// INSTANTIATE_TEST_CASE_P(AnimalVariations, AnimalTest, 405// Combine(Values("cat", "dog"), 406// Values(BLACK, WHITE))); 407// 408// This will instantiate tests in FlagDependentTest with all variations of two 409// Boolean flags: 410// 411// class FlagDependentTest 412// : public testing::TestWithParam<tuple<bool, bool> > { 413// virtual void SetUp() { 414// // Assigns external_flag_1 and external_flag_2 values from the tuple. 415// tie(external_flag_1, external_flag_2) = GetParam(); 416// } 417// }; 418// 419// TEST_P(FlagDependentTest, TestFeature1) { 420// // Test your code using external_flag_1 and external_flag_2 here. 421// } 422// INSTANTIATE_TEST_CASE_P(TwoBoolSequence, FlagDependentTest, 423// Combine(Bool(), Bool())); 424// 425$range i 2..maxtuple 426$for i [[ 427$range j 1..i 428 429template <$for j, [[typename Generator$j]]> 430internal::CartesianProductHolder$i<$for j, [[Generator$j]]> Combine( 431 $for j, [[const Generator$j& g$j]]) { 432 return internal::CartesianProductHolder$i<$for j, [[Generator$j]]>( 433 $for j, [[g$j]]); 434} 435 436]] 437# endif // GTEST_HAS_COMBINE 438 439# define TEST_P(test_case_name, test_name) \ 440 class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \ 441 : public test_case_name { \ 442 public: \ 443 GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \ 444 virtual void TestBody(); \ 445 private: \ 446 static int AddToRegistry() { \ 447 ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \ 448 GetTestCasePatternHolder<test_case_name>(\ 449 #test_case_name, \ 450 ::testing::internal::CodeLocation(\ 451 __FILE__, __LINE__))->AddTestPattern(\ 452 GTEST_STRINGIFY_(test_case_name), \ 453 GTEST_STRINGIFY_(test_name), \ 454 new ::testing::internal::TestMetaFactory< \ 455 GTEST_TEST_CLASS_NAME_(\ 456 test_case_name, test_name)>()); \ 457 return 0; \ 458 } \ 459 static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_; \ 460 GTEST_DISALLOW_COPY_AND_ASSIGN_(\ 461 GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \ 462 }; \ 463 int GTEST_TEST_CLASS_NAME_(test_case_name, \ 464 test_name)::gtest_registering_dummy_ = \ 465 GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \ 466 void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() 467 468// The optional last argument to INSTANTIATE_TEST_CASE_P allows the user 469// to specify a function or functor that generates custom test name suffixes 470// based on the test parameters. The function should accept one argument of 471// type testing::TestParamInfo<class ParamType>, and return std::string. 472// 473// testing::PrintToStringParamName is a builtin test suffix generator that 474// returns the value of testing::PrintToString(GetParam()). 475// 476// Note: test names must be non-empty, unique, and may only contain ASCII 477// alphanumeric characters or underscore. Because PrintToString adds quotes 478// to std::string and C strings, it won't work for these types. 479 480# define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator, ...) \ 481 static ::testing::internal::ParamGenerator<test_case_name::ParamType> \ 482 gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \ 483 static ::std::string gtest_##prefix##test_case_name##_EvalGenerateName_( \ 484 const ::testing::TestParamInfo<test_case_name::ParamType>& info) { \ 485 return ::testing::internal::GetParamNameGen<test_case_name::ParamType> \ 486 (__VA_ARGS__)(info); \ 487 } \ 488 static int gtest_##prefix##test_case_name##_dummy_ GTEST_ATTRIBUTE_UNUSED_ = \ 489 ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \ 490 GetTestCasePatternHolder<test_case_name>(\ 491 #test_case_name, \ 492 ::testing::internal::CodeLocation(\ 493 __FILE__, __LINE__))->AddTestCaseInstantiation(\ 494 #prefix, \ 495 >est_##prefix##test_case_name##_EvalGenerator_, \ 496 >est_##prefix##test_case_name##_EvalGenerateName_, \ 497 __FILE__, __LINE__) 498 499} // namespace testing 500 501#endif // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ 502