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 >est_##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_ 458