1 // Copyright 2008 Google Inc.
2 // All Rights Reserved.
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
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
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.
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.
31 // Type and function utilities for implementing parameterized tests.
33 // GOOGLETEST_CM0001 DO NOT DELETE
35 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
36 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
48 #include "gtest/internal/gtest-internal.h"
49 #include "gtest/internal/gtest-port.h"
50 #include "gtest/gtest-printers.h"
53 // Input to a parameterized test name generator, describing a test parameter.
54 // Consists of the parameter value and the integer parameter index.
55 template <class ParamType
>
56 struct TestParamInfo
{
57 TestParamInfo(const ParamType
& a_param
, size_t an_index
) :
64 // A builtin parameterized test name generator which returns the result of
65 // testing::PrintToString.
66 struct PrintToStringParamName
{
67 template <class ParamType
>
68 std::string
operator()(const TestParamInfo
<ParamType
>& info
) const {
69 return PrintToString(info
.param
);
75 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
78 // Outputs a message explaining invalid registration of different
79 // fixture class for the same test suite. This may happen when
80 // TEST_P macro is used to define two tests with the same name
81 // but in different namespaces.
82 GTEST_API_
void ReportInvalidTestSuiteType(const char* test_suite_name
,
83 CodeLocation code_location
);
85 template <typename
> class ParamGeneratorInterface
;
86 template <typename
> class ParamGenerator
;
88 // Interface for iterating over elements provided by an implementation
89 // of ParamGeneratorInterface<T>.
91 class ParamIteratorInterface
{
93 virtual ~ParamIteratorInterface() {}
94 // A pointer to the base generator instance.
95 // Used only for the purposes of iterator comparison
96 // to make sure that two iterators belong to the same generator.
97 virtual const ParamGeneratorInterface
<T
>* BaseGenerator() const = 0;
98 // Advances iterator to point to the next element
99 // provided by the generator. The caller is responsible
100 // for not calling Advance() on an iterator equal to
101 // BaseGenerator()->End().
102 virtual void Advance() = 0;
103 // Clones the iterator object. Used for implementing copy semantics
104 // of ParamIterator<T>.
105 virtual ParamIteratorInterface
* Clone() const = 0;
106 // Dereferences the current iterator and provides (read-only) access
107 // to the pointed value. It is the caller's responsibility not to call
108 // Current() on an iterator equal to BaseGenerator()->End().
109 // Used for implementing ParamGenerator<T>::operator*().
110 virtual const T
* Current() const = 0;
111 // Determines whether the given iterator and other point to the same
112 // element in the sequence generated by the generator.
113 // Used for implementing ParamGenerator<T>::operator==().
114 virtual bool Equals(const ParamIteratorInterface
& other
) const = 0;
117 // Class iterating over elements provided by an implementation of
118 // ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
119 // and implements the const forward iterator concept.
120 template <typename T
>
121 class ParamIterator
{
123 typedef T value_type
;
124 typedef const T
& reference
;
125 typedef ptrdiff_t difference_type
;
127 // ParamIterator assumes ownership of the impl_ pointer.
128 ParamIterator(const ParamIterator
& other
) : impl_(other
.impl_
->Clone()) {}
129 ParamIterator
& operator=(const ParamIterator
& other
) {
131 impl_
.reset(other
.impl_
->Clone());
135 const T
& operator*() const { return *impl_
->Current(); }
136 const T
* operator->() const { return impl_
->Current(); }
137 // Prefix version of operator++.
138 ParamIterator
& operator++() {
142 // Postfix version of operator++.
143 ParamIterator
operator++(int /*unused*/) {
144 ParamIteratorInterface
<T
>* clone
= impl_
->Clone();
146 return ParamIterator(clone
);
148 bool operator==(const ParamIterator
& other
) const {
149 return impl_
.get() == other
.impl_
.get() || impl_
->Equals(*other
.impl_
);
151 bool operator!=(const ParamIterator
& other
) const {
152 return !(*this == other
);
156 friend class ParamGenerator
<T
>;
157 explicit ParamIterator(ParamIteratorInterface
<T
>* impl
) : impl_(impl
) {}
158 std::unique_ptr
<ParamIteratorInterface
<T
> > impl_
;
161 // ParamGeneratorInterface<T> is the binary interface to access generators
162 // defined in other translation units.
163 template <typename T
>
164 class ParamGeneratorInterface
{
168 virtual ~ParamGeneratorInterface() {}
170 // Generator interface definition
171 virtual ParamIteratorInterface
<T
>* Begin() const = 0;
172 virtual ParamIteratorInterface
<T
>* End() const = 0;
175 // Wraps ParamGeneratorInterface<T> and provides general generator syntax
176 // compatible with the STL Container concept.
177 // This class implements copy initialization semantics and the contained
178 // ParamGeneratorInterface<T> instance is shared among all copies
179 // of the original object. This is possible because that instance is immutable.
181 class ParamGenerator
{
183 typedef ParamIterator
<T
> iterator
;
185 explicit ParamGenerator(ParamGeneratorInterface
<T
>* impl
) : impl_(impl
) {}
186 ParamGenerator(const ParamGenerator
& other
) : impl_(other
.impl_
) {}
188 ParamGenerator
& operator=(const ParamGenerator
& other
) {
193 iterator
begin() const { return iterator(impl_
->Begin()); }
194 iterator
end() const { return iterator(impl_
->End()); }
197 std::shared_ptr
<const ParamGeneratorInterface
<T
> > impl_
;
200 // Generates values from a range of two comparable values. Can be used to
201 // generate sequences of user-defined types that implement operator+() and
203 // This class is used in the Range() function.
204 template <typename T
, typename IncrementT
>
205 class RangeGenerator
: public ParamGeneratorInterface
<T
> {
207 RangeGenerator(T begin
, T end
, IncrementT step
)
208 : begin_(begin
), end_(end
),
209 step_(step
), end_index_(CalculateEndIndex(begin
, end
, step
)) {}
210 ~RangeGenerator() override
{}
212 ParamIteratorInterface
<T
>* Begin() const override
{
213 return new Iterator(this, begin_
, 0, step_
);
215 ParamIteratorInterface
<T
>* End() const override
{
216 return new Iterator(this, end_
, end_index_
, step_
);
220 class Iterator
: public ParamIteratorInterface
<T
> {
222 Iterator(const ParamGeneratorInterface
<T
>* base
, T value
, int index
,
224 : base_(base
), value_(value
), index_(index
), step_(step
) {}
225 ~Iterator() override
{}
227 const ParamGeneratorInterface
<T
>* BaseGenerator() const override
{
230 void Advance() override
{
231 value_
= static_cast<T
>(value_
+ step_
);
234 ParamIteratorInterface
<T
>* Clone() const override
{
235 return new Iterator(*this);
237 const T
* Current() const override
{ return &value_
; }
238 bool Equals(const ParamIteratorInterface
<T
>& other
) const override
{
239 // Having the same base generator guarantees that the other
240 // iterator is of the same type and we can downcast.
241 GTEST_CHECK_(BaseGenerator() == other
.BaseGenerator())
242 << "The program attempted to compare iterators "
243 << "from different generators." << std::endl
;
244 const int other_index
=
245 CheckedDowncastToActualType
<const Iterator
>(&other
)->index_
;
246 return index_
== other_index
;
250 Iterator(const Iterator
& other
)
251 : ParamIteratorInterface
<T
>(),
252 base_(other
.base_
), value_(other
.value_
), index_(other
.index_
),
253 step_(other
.step_
) {}
255 // No implementation - assignment is unsupported.
256 void operator=(const Iterator
& other
);
258 const ParamGeneratorInterface
<T
>* const base_
;
261 const IncrementT step_
;
262 }; // class RangeGenerator::Iterator
264 static int CalculateEndIndex(const T
& begin
,
266 const IncrementT
& step
) {
268 for (T i
= begin
; i
< end
; i
= static_cast<T
>(i
+ step
))
273 // No implementation - assignment is unsupported.
274 void operator=(const RangeGenerator
& other
);
278 const IncrementT step_
;
279 // The index for the end() iterator. All the elements in the generated
280 // sequence are indexed (0-based) to aid iterator comparison.
281 const int end_index_
;
282 }; // class RangeGenerator
285 // Generates values from a pair of STL-style iterators. Used in the
286 // ValuesIn() function. The elements are copied from the source range
287 // since the source can be located on the stack, and the generator
288 // is likely to persist beyond that stack frame.
289 template <typename T
>
290 class ValuesInIteratorRangeGenerator
: public ParamGeneratorInterface
<T
> {
292 template <typename ForwardIterator
>
293 ValuesInIteratorRangeGenerator(ForwardIterator begin
, ForwardIterator end
)
294 : container_(begin
, end
) {}
295 ~ValuesInIteratorRangeGenerator() override
{}
297 ParamIteratorInterface
<T
>* Begin() const override
{
298 return new Iterator(this, container_
.begin());
300 ParamIteratorInterface
<T
>* End() const override
{
301 return new Iterator(this, container_
.end());
305 typedef typename ::std::vector
<T
> ContainerType
;
307 class Iterator
: public ParamIteratorInterface
<T
> {
309 Iterator(const ParamGeneratorInterface
<T
>* base
,
310 typename
ContainerType::const_iterator iterator
)
311 : base_(base
), iterator_(iterator
) {}
312 ~Iterator() override
{}
314 const ParamGeneratorInterface
<T
>* BaseGenerator() const override
{
317 void Advance() override
{
321 ParamIteratorInterface
<T
>* Clone() const override
{
322 return new Iterator(*this);
324 // We need to use cached value referenced by iterator_ because *iterator_
325 // can return a temporary object (and of type other then T), so just
326 // having "return &*iterator_;" doesn't work.
327 // value_ is updated here and not in Advance() because Advance()
328 // can advance iterator_ beyond the end of the range, and we cannot
329 // detect that fact. The client code, on the other hand, is
330 // responsible for not calling Current() on an out-of-range iterator.
331 const T
* Current() const override
{
332 if (value_
.get() == nullptr) value_
.reset(new T(*iterator_
));
335 bool Equals(const ParamIteratorInterface
<T
>& other
) const override
{
336 // Having the same base generator guarantees that the other
337 // iterator is of the same type and we can downcast.
338 GTEST_CHECK_(BaseGenerator() == other
.BaseGenerator())
339 << "The program attempted to compare iterators "
340 << "from different generators." << std::endl
;
342 CheckedDowncastToActualType
<const Iterator
>(&other
)->iterator_
;
346 Iterator(const Iterator
& other
)
347 // The explicit constructor call suppresses a false warning
348 // emitted by gcc when supplied with the -Wextra option.
349 : ParamIteratorInterface
<T
>(),
351 iterator_(other
.iterator_
) {}
353 const ParamGeneratorInterface
<T
>* const base_
;
354 typename
ContainerType::const_iterator iterator_
;
355 // A cached value of *iterator_. We keep it here to allow access by
356 // pointer in the wrapping iterator's operator->().
357 // value_ needs to be mutable to be accessed in Current().
358 // Use of std::unique_ptr helps manage cached value's lifetime,
359 // which is bound by the lifespan of the iterator itself.
360 mutable std::unique_ptr
<const T
> value_
;
361 }; // class ValuesInIteratorRangeGenerator::Iterator
363 // No implementation - assignment is unsupported.
364 void operator=(const ValuesInIteratorRangeGenerator
& other
);
366 const ContainerType container_
;
367 }; // class ValuesInIteratorRangeGenerator
369 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
371 // Default parameterized test name generator, returns a string containing the
372 // integer test parameter index.
373 template <class ParamType
>
374 std::string
DefaultParamName(const TestParamInfo
<ParamType
>& info
) {
376 name_stream
<< info
.index
;
377 return name_stream
.GetString();
380 template <typename T
= int>
381 void TestNotEmpty() {
382 static_assert(sizeof(T
) == 0, "Empty arguments are not allowed.");
384 template <typename T
= int>
385 void TestNotEmpty(const T
&) {}
387 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
389 // Stores a parameter value and later creates tests parameterized with that
391 template <class TestClass
>
392 class ParameterizedTestFactory
: public TestFactoryBase
{
394 typedef typename
TestClass::ParamType ParamType
;
395 explicit ParameterizedTestFactory(ParamType parameter
) :
396 parameter_(parameter
) {}
397 Test
* CreateTest() override
{
398 TestClass::SetParam(¶meter_
);
399 return new TestClass();
403 const ParamType parameter_
;
405 GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory
);
408 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
410 // TestMetaFactoryBase is a base class for meta-factories that create
411 // test factories for passing into MakeAndRegisterTestInfo function.
412 template <class ParamType
>
413 class TestMetaFactoryBase
{
415 virtual ~TestMetaFactoryBase() {}
417 virtual TestFactoryBase
* CreateTestFactory(ParamType parameter
) = 0;
420 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
422 // TestMetaFactory creates test factories for passing into
423 // MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives
424 // ownership of test factory pointer, same factory object cannot be passed
425 // into that method twice. But ParameterizedTestSuiteInfo is going to call
426 // it for each Test/Parameter value combination. Thus it needs meta factory
428 template <class TestSuite
>
429 class TestMetaFactory
430 : public TestMetaFactoryBase
<typename
TestSuite::ParamType
> {
432 using ParamType
= typename
TestSuite::ParamType
;
436 TestFactoryBase
* CreateTestFactory(ParamType parameter
) override
{
437 return new ParameterizedTestFactory
<TestSuite
>(parameter
);
441 GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory
);
444 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
446 // ParameterizedTestSuiteInfoBase is a generic interface
447 // to ParameterizedTestSuiteInfo classes. ParameterizedTestSuiteInfoBase
448 // accumulates test information provided by TEST_P macro invocations
449 // and generators provided by INSTANTIATE_TEST_SUITE_P macro invocations
450 // and uses that information to register all resulting test instances
451 // in RegisterTests method. The ParameterizeTestSuiteRegistry class holds
452 // a collection of pointers to the ParameterizedTestSuiteInfo objects
453 // and calls RegisterTests() on each of them when asked.
454 class ParameterizedTestSuiteInfoBase
{
456 virtual ~ParameterizedTestSuiteInfoBase() {}
458 // Base part of test suite name for display purposes.
459 virtual const std::string
& GetTestSuiteName() const = 0;
460 // Test case id to verify identity.
461 virtual TypeId
GetTestSuiteTypeId() const = 0;
462 // UnitTest class invokes this method to register tests in this
463 // test suite right before running them in RUN_ALL_TESTS macro.
464 // This method should not be called more than once on any single
465 // instance of a ParameterizedTestSuiteInfoBase derived class.
466 virtual void RegisterTests() = 0;
469 ParameterizedTestSuiteInfoBase() {}
472 GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfoBase
);
475 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
477 // ParameterizedTestSuiteInfo accumulates tests obtained from TEST_P
478 // macro invocations for a particular test suite and generators
479 // obtained from INSTANTIATE_TEST_SUITE_P macro invocations for that
480 // test suite. It registers tests with all values generated by all
481 // generators when asked.
482 template <class TestSuite
>
483 class ParameterizedTestSuiteInfo
: public ParameterizedTestSuiteInfoBase
{
485 // ParamType and GeneratorCreationFunc are private types but are required
486 // for declarations of public methods AddTestPattern() and
487 // AddTestSuiteInstantiation().
488 using ParamType
= typename
TestSuite::ParamType
;
489 // A function that returns an instance of appropriate generator type.
490 typedef ParamGenerator
<ParamType
>(GeneratorCreationFunc
)();
491 using ParamNameGeneratorFunc
= std::string(const TestParamInfo
<ParamType
>&);
493 explicit ParameterizedTestSuiteInfo(const char* name
,
494 CodeLocation code_location
)
495 : test_suite_name_(name
), code_location_(code_location
) {}
497 // Test case base name for display purposes.
498 const std::string
& GetTestSuiteName() const override
{
499 return test_suite_name_
;
501 // Test case id to verify identity.
502 TypeId
GetTestSuiteTypeId() const override
{ return GetTypeId
<TestSuite
>(); }
503 // TEST_P macro uses AddTestPattern() to record information
504 // about a single test in a LocalTestInfo structure.
505 // test_suite_name is the base name of the test suite (without invocation
506 // prefix). test_base_name is the name of an individual test without
507 // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
508 // test suite base name and DoBar is test base name.
509 void AddTestPattern(const char* test_suite_name
, const char* test_base_name
,
510 TestMetaFactoryBase
<ParamType
>* meta_factory
) {
511 tests_
.push_back(std::shared_ptr
<TestInfo
>(
512 new TestInfo(test_suite_name
, test_base_name
, meta_factory
)));
514 // INSTANTIATE_TEST_SUITE_P macro uses AddGenerator() to record information
515 // about a generator.
516 int AddTestSuiteInstantiation(const std::string
& instantiation_name
,
517 GeneratorCreationFunc
* func
,
518 ParamNameGeneratorFunc
* name_func
,
519 const char* file
, int line
) {
520 instantiations_
.push_back(
521 InstantiationInfo(instantiation_name
, func
, name_func
, file
, line
));
522 return 0; // Return value used only to run this method in namespace scope.
524 // UnitTest class invokes this method to register tests in this test suite
525 // test suites right before running tests in RUN_ALL_TESTS macro.
526 // This method should not be called more than once on any single
527 // instance of a ParameterizedTestSuiteInfoBase derived class.
528 // UnitTest has a guard to prevent from calling this method more than once.
529 void RegisterTests() override
{
530 for (typename
TestInfoContainer::iterator test_it
= tests_
.begin();
531 test_it
!= tests_
.end(); ++test_it
) {
532 std::shared_ptr
<TestInfo
> test_info
= *test_it
;
533 for (typename
InstantiationContainer::iterator gen_it
=
534 instantiations_
.begin(); gen_it
!= instantiations_
.end();
536 const std::string
& instantiation_name
= gen_it
->name
;
537 ParamGenerator
<ParamType
> generator((*gen_it
->generator
)());
538 ParamNameGeneratorFunc
* name_func
= gen_it
->name_func
;
539 const char* file
= gen_it
->file
;
540 int line
= gen_it
->line
;
542 std::string test_suite_name
;
543 if ( !instantiation_name
.empty() )
544 test_suite_name
= instantiation_name
+ "/";
545 test_suite_name
+= test_info
->test_suite_base_name
;
548 std::set
<std::string
> test_param_names
;
549 for (typename ParamGenerator
<ParamType
>::iterator param_it
=
551 param_it
!= generator
.end(); ++param_it
, ++i
) {
552 Message test_name_stream
;
554 std::string param_name
= name_func(
555 TestParamInfo
<ParamType
>(*param_it
, i
));
557 GTEST_CHECK_(IsValidParamName(param_name
))
558 << "Parameterized test name '" << param_name
559 << "' is invalid, in " << file
560 << " line " << line
<< std::endl
;
562 GTEST_CHECK_(test_param_names
.count(param_name
) == 0)
563 << "Duplicate parameterized test name '" << param_name
564 << "', in " << file
<< " line " << line
<< std::endl
;
566 test_param_names
.insert(param_name
);
568 if (!test_info
->test_base_name
.empty()) {
569 test_name_stream
<< test_info
->test_base_name
<< "/";
571 test_name_stream
<< param_name
;
572 MakeAndRegisterTestInfo(
573 test_suite_name
.c_str(), test_name_stream
.GetString().c_str(),
574 nullptr, // No type parameter.
575 PrintToString(*param_it
).c_str(), code_location_
,
576 GetTestSuiteTypeId(),
577 SuiteApiResolver
<TestSuite
>::GetSetUpCaseOrSuite(file
, line
),
578 SuiteApiResolver
<TestSuite
>::GetTearDownCaseOrSuite(file
, line
),
579 test_info
->test_meta_factory
->CreateTestFactory(*param_it
));
586 // LocalTestInfo structure keeps information about a single test registered
587 // with TEST_P macro.
589 TestInfo(const char* a_test_suite_base_name
, const char* a_test_base_name
,
590 TestMetaFactoryBase
<ParamType
>* a_test_meta_factory
)
591 : test_suite_base_name(a_test_suite_base_name
),
592 test_base_name(a_test_base_name
),
593 test_meta_factory(a_test_meta_factory
) {}
595 const std::string test_suite_base_name
;
596 const std::string test_base_name
;
597 const std::unique_ptr
<TestMetaFactoryBase
<ParamType
> > test_meta_factory
;
599 using TestInfoContainer
= ::std::vector
<std::shared_ptr
<TestInfo
> >;
600 // Records data received from INSTANTIATE_TEST_SUITE_P macros:
601 // <Instantiation name, Sequence generator creation function,
602 // Name generator function, Source file, Source line>
603 struct InstantiationInfo
{
604 InstantiationInfo(const std::string
&name_in
,
605 GeneratorCreationFunc
* generator_in
,
606 ParamNameGeneratorFunc
* name_func_in
,
610 generator(generator_in
),
611 name_func(name_func_in
),
616 GeneratorCreationFunc
* generator
;
617 ParamNameGeneratorFunc
* name_func
;
621 typedef ::std::vector
<InstantiationInfo
> InstantiationContainer
;
623 static bool IsValidParamName(const std::string
& name
) {
624 // Check for empty string
628 // Check for invalid characters
629 for (std::string::size_type index
= 0; index
< name
.size(); ++index
) {
630 if (!isalnum(name
[index
]) && name
[index
] != '_')
637 const std::string test_suite_name_
;
638 CodeLocation code_location_
;
639 TestInfoContainer tests_
;
640 InstantiationContainer instantiations_
;
642 GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfo
);
643 }; // class ParameterizedTestSuiteInfo
645 // Legacy API is deprecated but still available
646 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
647 template <class TestCase
>
648 using ParameterizedTestCaseInfo
= ParameterizedTestSuiteInfo
<TestCase
>;
649 #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
651 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
653 // ParameterizedTestSuiteRegistry contains a map of
654 // ParameterizedTestSuiteInfoBase classes accessed by test suite names. TEST_P
655 // and INSTANTIATE_TEST_SUITE_P macros use it to locate their corresponding
656 // ParameterizedTestSuiteInfo descriptors.
657 class ParameterizedTestSuiteRegistry
{
659 ParameterizedTestSuiteRegistry() {}
660 ~ParameterizedTestSuiteRegistry() {
661 for (auto& test_suite_info
: test_suite_infos_
) {
662 delete test_suite_info
;
666 // Looks up or creates and returns a structure containing information about
667 // tests and instantiations of a particular test suite.
668 template <class TestSuite
>
669 ParameterizedTestSuiteInfo
<TestSuite
>* GetTestSuitePatternHolder(
670 const char* test_suite_name
, CodeLocation code_location
) {
671 ParameterizedTestSuiteInfo
<TestSuite
>* typed_test_info
= nullptr;
672 for (auto& test_suite_info
: test_suite_infos_
) {
673 if (test_suite_info
->GetTestSuiteName() == test_suite_name
) {
674 if (test_suite_info
->GetTestSuiteTypeId() != GetTypeId
<TestSuite
>()) {
675 // Complain about incorrect usage of Google Test facilities
676 // and terminate the program since we cannot guaranty correct
677 // test suite setup and tear-down in this case.
678 ReportInvalidTestSuiteType(test_suite_name
, code_location
);
681 // At this point we are sure that the object we found is of the same
682 // type we are looking for, so we downcast it to that type
683 // without further checks.
684 typed_test_info
= CheckedDowncastToActualType
<
685 ParameterizedTestSuiteInfo
<TestSuite
> >(test_suite_info
);
690 if (typed_test_info
== nullptr) {
691 typed_test_info
= new ParameterizedTestSuiteInfo
<TestSuite
>(
692 test_suite_name
, code_location
);
693 test_suite_infos_
.push_back(typed_test_info
);
695 return typed_test_info
;
697 void RegisterTests() {
698 for (auto& test_suite_info
: test_suite_infos_
) {
699 test_suite_info
->RegisterTests();
702 // Legacy API is deprecated but still available
703 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
704 template <class TestCase
>
705 ParameterizedTestCaseInfo
<TestCase
>* GetTestCasePatternHolder(
706 const char* test_case_name
, CodeLocation code_location
) {
707 return GetTestSuitePatternHolder
<TestCase
>(test_case_name
, code_location
);
710 #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
713 using TestSuiteInfoContainer
= ::std::vector
<ParameterizedTestSuiteInfoBase
*>;
715 TestSuiteInfoContainer test_suite_infos_
;
717 GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteRegistry
);
720 } // namespace internal
722 // Forward declarations of ValuesIn(), which is implemented in
723 // include/gtest/gtest-param-test.h.
724 template <class Container
>
725 internal::ParamGenerator
<typename
Container::value_type
> ValuesIn(
726 const Container
& container
);
729 // Used in the Values() function to provide polymorphic capabilities.
731 template <typename
... Ts
>
734 ValueArray(Ts
... v
) : v_
{std::move(v
)...} {}
736 template <typename T
>
737 operator ParamGenerator
<T
>() const { // NOLINT
738 return ValuesIn(MakeVector
<T
>(MakeIndexSequence
<sizeof...(Ts
)>()));
742 template <typename T
, size_t... I
>
743 std::vector
<T
> MakeVector(IndexSequence
<I
...>) const {
744 return std::vector
<T
>{static_cast<T
>(v_
.template Get
<I
>())...};
750 template <typename
... T
>
751 class CartesianProductGenerator
752 : public ParamGeneratorInterface
<::std::tuple
<T
...>> {
754 typedef ::std::tuple
<T
...> ParamType
;
756 CartesianProductGenerator(const std::tuple
<ParamGenerator
<T
>...>& g
)
758 ~CartesianProductGenerator() override
{}
760 ParamIteratorInterface
<ParamType
>* Begin() const override
{
761 return new Iterator(this, generators_
, false);
763 ParamIteratorInterface
<ParamType
>* End() const override
{
764 return new Iterator(this, generators_
, true);
770 template <size_t... I
>
771 class IteratorImpl
<IndexSequence
<I
...>>
772 : public ParamIteratorInterface
<ParamType
> {
774 IteratorImpl(const ParamGeneratorInterface
<ParamType
>* base
,
775 const std::tuple
<ParamGenerator
<T
>...>& generators
, bool is_end
)
777 begin_(std::get
<I
>(generators
).begin()...),
778 end_(std::get
<I
>(generators
).end()...),
779 current_(is_end
? end_
: begin_
) {
780 ComputeCurrentValue();
782 ~IteratorImpl() override
{}
784 const ParamGeneratorInterface
<ParamType
>* BaseGenerator() const override
{
787 // Advance should not be called on beyond-of-range iterators
788 // so no component iterators must be beyond end of range, either.
789 void Advance() override
{
791 // Advance the last iterator.
792 ++std::get
<sizeof...(T
) - 1>(current_
);
793 // if that reaches end, propagate that up.
794 AdvanceIfEnd
<sizeof...(T
) - 1>();
795 ComputeCurrentValue();
797 ParamIteratorInterface
<ParamType
>* Clone() const override
{
798 return new IteratorImpl(*this);
801 const ParamType
* Current() const override
{ return current_value_
.get(); }
803 bool Equals(const ParamIteratorInterface
<ParamType
>& other
) const override
{
804 // Having the same base generator guarantees that the other
805 // iterator is of the same type and we can downcast.
806 GTEST_CHECK_(BaseGenerator() == other
.BaseGenerator())
807 << "The program attempted to compare iterators "
808 << "from different generators." << std::endl
;
809 const IteratorImpl
* typed_other
=
810 CheckedDowncastToActualType
<const IteratorImpl
>(&other
);
812 // We must report iterators equal if they both point beyond their
813 // respective ranges. That can happen in a variety of fashions,
814 // so we have to consult AtEnd().
815 if (AtEnd() && typed_other
->AtEnd()) return true;
819 (same
= same
&& std::get
<I
>(current_
) ==
820 std::get
<I
>(typed_other
->current_
))...};
826 template <size_t ThisI
>
827 void AdvanceIfEnd() {
828 if (std::get
<ThisI
>(current_
) != std::get
<ThisI
>(end_
)) return;
830 bool last
= ThisI
== 0;
832 // We are done. Nothing else to propagate.
836 constexpr size_t NextI
= ThisI
- (ThisI
!= 0);
837 std::get
<ThisI
>(current_
) = std::get
<ThisI
>(begin_
);
838 ++std::get
<NextI
>(current_
);
839 AdvanceIfEnd
<NextI
>();
842 void ComputeCurrentValue() {
844 current_value_
= std::make_shared
<ParamType
>(*std::get
<I
>(current_
)...);
849 (at_end
= at_end
|| std::get
<I
>(current_
) == std::get
<I
>(end_
))...};
854 const ParamGeneratorInterface
<ParamType
>* const base_
;
855 std::tuple
<typename ParamGenerator
<T
>::iterator
...> begin_
;
856 std::tuple
<typename ParamGenerator
<T
>::iterator
...> end_
;
857 std::tuple
<typename ParamGenerator
<T
>::iterator
...> current_
;
858 std::shared_ptr
<ParamType
> current_value_
;
861 using Iterator
= IteratorImpl
<typename MakeIndexSequence
<sizeof...(T
)>::type
>;
863 std::tuple
<ParamGenerator
<T
>...> generators_
;
866 template <class... Gen
>
867 class CartesianProductHolder
{
869 CartesianProductHolder(const Gen
&... g
) : generators_(g
...) {}
870 template <typename
... T
>
871 operator ParamGenerator
<::std::tuple
<T
...>>() const {
872 return ParamGenerator
<::std::tuple
<T
...>>(
873 new CartesianProductGenerator
<T
...>(generators_
));
877 std::tuple
<Gen
...> generators_
;
880 } // namespace internal
881 } // namespace testing
883 #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_