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 | // Author: vladl@google.com (Vlad Losev) |
---|
31 | |
---|
32 | // Type and function utilities for implementing parameterized tests. |
---|
33 | |
---|
34 | #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ |
---|
35 | #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ |
---|
36 | |
---|
37 | #include <iterator> |
---|
38 | #include <utility> |
---|
39 | #include <vector> |
---|
40 | |
---|
41 | // scripts/fuse_gtest.py depends on gtest's own header being #included |
---|
42 | // *unconditionally*. Therefore these #includes cannot be moved |
---|
43 | // inside #if GTEST_HAS_PARAM_TEST. |
---|
44 | #include "gtest/internal/gtest-internal.h" |
---|
45 | #include "gtest/internal/gtest-linked_ptr.h" |
---|
46 | #include "gtest/internal/gtest-port.h" |
---|
47 | #include "gtest/gtest-printers.h" |
---|
48 | |
---|
49 | #if GTEST_HAS_PARAM_TEST |
---|
50 | |
---|
51 | namespace testing { |
---|
52 | namespace internal { |
---|
53 | |
---|
54 | // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. |
---|
55 | // |
---|
56 | // Outputs a message explaining invalid registration of different |
---|
57 | // fixture class for the same test case. This may happen when |
---|
58 | // TEST_P macro is used to define two tests with the same name |
---|
59 | // but in different namespaces. |
---|
60 | GTEST_API_ void ReportInvalidTestCaseType(const char* test_case_name, |
---|
61 | const char* file, int line); |
---|
62 | |
---|
63 | template <typename> class ParamGeneratorInterface; |
---|
64 | template <typename> class ParamGenerator; |
---|
65 | |
---|
66 | // Interface for iterating over elements provided by an implementation |
---|
67 | // of ParamGeneratorInterface<T>. |
---|
68 | template <typename T> |
---|
69 | class ParamIteratorInterface { |
---|
70 | public: |
---|
71 | virtual ~ParamIteratorInterface() {} |
---|
72 | // A pointer to the base generator instance. |
---|
73 | // Used only for the purposes of iterator comparison |
---|
74 | // to make sure that two iterators belong to the same generator. |
---|
75 | virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0; |
---|
76 | // Advances iterator to point to the next element |
---|
77 | // provided by the generator. The caller is responsible |
---|
78 | // for not calling Advance() on an iterator equal to |
---|
79 | // BaseGenerator()->End(). |
---|
80 | virtual void Advance() = 0; |
---|
81 | // Clones the iterator object. Used for implementing copy semantics |
---|
82 | // of ParamIterator<T>. |
---|
83 | virtual ParamIteratorInterface* Clone() const = 0; |
---|
84 | // Dereferences the current iterator and provides (read-only) access |
---|
85 | // to the pointed value. It is the caller's responsibility not to call |
---|
86 | // Current() on an iterator equal to BaseGenerator()->End(). |
---|
87 | // Used for implementing ParamGenerator<T>::operator*(). |
---|
88 | virtual const T* Current() const = 0; |
---|
89 | // Determines whether the given iterator and other point to the same |
---|
90 | // element in the sequence generated by the generator. |
---|
91 | // Used for implementing ParamGenerator<T>::operator==(). |
---|
92 | virtual bool Equals(const ParamIteratorInterface& other) const = 0; |
---|
93 | }; |
---|
94 | |
---|
95 | // Class iterating over elements provided by an implementation of |
---|
96 | // ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T> |
---|
97 | // and implements the const forward iterator concept. |
---|
98 | template <typename T> |
---|
99 | class ParamIterator { |
---|
100 | public: |
---|
101 | typedef T value_type; |
---|
102 | typedef const T& reference; |
---|
103 | typedef ptrdiff_t difference_type; |
---|
104 | |
---|
105 | // ParamIterator assumes ownership of the impl_ pointer. |
---|
106 | ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {} |
---|
107 | ParamIterator& operator=(const ParamIterator& other) { |
---|
108 | if (this != &other) |
---|
109 | impl_.reset(other.impl_->Clone()); |
---|
110 | return *this; |
---|
111 | } |
---|
112 | |
---|
113 | const T& operator*() const { return *impl_->Current(); } |
---|
114 | const T* operator->() const { return impl_->Current(); } |
---|
115 | // Prefix version of operator++. |
---|
116 | ParamIterator& operator++() { |
---|
117 | impl_->Advance(); |
---|
118 | return *this; |
---|
119 | } |
---|
120 | // Postfix version of operator++. |
---|
121 | ParamIterator operator++(int /*unused*/) { |
---|
122 | ParamIteratorInterface<T>* clone = impl_->Clone(); |
---|
123 | impl_->Advance(); |
---|
124 | return ParamIterator(clone); |
---|
125 | } |
---|
126 | bool operator==(const ParamIterator& other) const { |
---|
127 | return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_); |
---|
128 | } |
---|
129 | bool operator!=(const ParamIterator& other) const { |
---|
130 | return !(*this == other); |
---|
131 | } |
---|
132 | |
---|
133 | private: |
---|
134 | friend class ParamGenerator<T>; |
---|
135 | explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {} |
---|
136 | scoped_ptr<ParamIteratorInterface<T> > impl_; |
---|
137 | }; |
---|
138 | |
---|
139 | // ParamGeneratorInterface<T> is the binary interface to access generators |
---|
140 | // defined in other translation units. |
---|
141 | template <typename T> |
---|
142 | class ParamGeneratorInterface { |
---|
143 | public: |
---|
144 | typedef T ParamType; |
---|
145 | |
---|
146 | virtual ~ParamGeneratorInterface() {} |
---|
147 | |
---|
148 | // Generator interface definition |
---|
149 | virtual ParamIteratorInterface<T>* Begin() const = 0; |
---|
150 | virtual ParamIteratorInterface<T>* End() const = 0; |
---|
151 | }; |
---|
152 | |
---|
153 | // Wraps ParamGeneratorInterface<T> and provides general generator syntax |
---|
154 | // compatible with the STL Container concept. |
---|
155 | // This class implements copy initialization semantics and the contained |
---|
156 | // ParamGeneratorInterface<T> instance is shared among all copies |
---|
157 | // of the original object. This is possible because that instance is immutable. |
---|
158 | template<typename T> |
---|
159 | class ParamGenerator { |
---|
160 | public: |
---|
161 | typedef ParamIterator<T> iterator; |
---|
162 | |
---|
163 | explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {} |
---|
164 | ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {} |
---|
165 | |
---|
166 | ParamGenerator& operator=(const ParamGenerator& other) { |
---|
167 | impl_ = other.impl_; |
---|
168 | return *this; |
---|
169 | } |
---|
170 | |
---|
171 | iterator begin() const { return iterator(impl_->Begin()); } |
---|
172 | iterator end() const { return iterator(impl_->End()); } |
---|
173 | |
---|
174 | private: |
---|
175 | linked_ptr<const ParamGeneratorInterface<T> > impl_; |
---|
176 | }; |
---|
177 | |
---|
178 | // Generates values from a range of two comparable values. Can be used to |
---|
179 | // generate sequences of user-defined types that implement operator+() and |
---|
180 | // operator<(). |
---|
181 | // This class is used in the Range() function. |
---|
182 | template <typename T, typename IncrementT> |
---|
183 | class RangeGenerator : public ParamGeneratorInterface<T> { |
---|
184 | public: |
---|
185 | RangeGenerator(T begin, T end, IncrementT step) |
---|
186 | : begin_(begin), end_(end), |
---|
187 | step_(step), end_index_(CalculateEndIndex(begin, end, step)) {} |
---|
188 | virtual ~RangeGenerator() {} |
---|
189 | |
---|
190 | virtual ParamIteratorInterface<T>* Begin() const { |
---|
191 | return new Iterator(this, begin_, 0, step_); |
---|
192 | } |
---|
193 | virtual ParamIteratorInterface<T>* End() const { |
---|
194 | return new Iterator(this, end_, end_index_, step_); |
---|
195 | } |
---|
196 | |
---|
197 | private: |
---|
198 | class Iterator : public ParamIteratorInterface<T> { |
---|
199 | public: |
---|
200 | Iterator(const ParamGeneratorInterface<T>* base, T value, int index, |
---|
201 | IncrementT step) |
---|
202 | : base_(base), value_(value), index_(index), step_(step) {} |
---|
203 | virtual ~Iterator() {} |
---|
204 | |
---|
205 | virtual const ParamGeneratorInterface<T>* BaseGenerator() const { |
---|
206 | return base_; |
---|
207 | } |
---|
208 | virtual void Advance() { |
---|
209 | value_ = value_ + step_; |
---|
210 | index_++; |
---|
211 | } |
---|
212 | virtual ParamIteratorInterface<T>* Clone() const { |
---|
213 | return new Iterator(*this); |
---|
214 | } |
---|
215 | virtual const T* Current() const { return &value_; } |
---|
216 | virtual bool Equals(const ParamIteratorInterface<T>& other) const { |
---|
217 | // Having the same base generator guarantees that the other |
---|
218 | // iterator is of the same type and we can downcast. |
---|
219 | GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) |
---|
220 | << "The program attempted to compare iterators " |
---|
221 | << "from different generators." << std::endl; |
---|
222 | const int other_index = |
---|
223 | CheckedDowncastToActualType<const Iterator>(&other)->index_; |
---|
224 | return index_ == other_index; |
---|
225 | } |
---|
226 | |
---|
227 | private: |
---|
228 | Iterator(const Iterator& other) |
---|
229 | : ParamIteratorInterface<T>(), |
---|
230 | base_(other.base_), value_(other.value_), index_(other.index_), |
---|
231 | step_(other.step_) {} |
---|
232 | |
---|
233 | // No implementation - assignment is unsupported. |
---|
234 | void operator=(const Iterator& other); |
---|
235 | |
---|
236 | const ParamGeneratorInterface<T>* const base_; |
---|
237 | T value_; |
---|
238 | int index_; |
---|
239 | const IncrementT step_; |
---|
240 | }; // class RangeGenerator::Iterator |
---|
241 | |
---|
242 | static int CalculateEndIndex(const T& begin, |
---|
243 | const T& end, |
---|
244 | const IncrementT& step) { |
---|
245 | int end_index = 0; |
---|
246 | for (T i = begin; i < end; i = i + step) |
---|
247 | end_index++; |
---|
248 | return end_index; |
---|
249 | } |
---|
250 | |
---|
251 | // No implementation - assignment is unsupported. |
---|
252 | void operator=(const RangeGenerator& other); |
---|
253 | |
---|
254 | const T begin_; |
---|
255 | const T end_; |
---|
256 | const IncrementT step_; |
---|
257 | // The index for the end() iterator. All the elements in the generated |
---|
258 | // sequence are indexed (0-based) to aid iterator comparison. |
---|
259 | const int end_index_; |
---|
260 | }; // class RangeGenerator |
---|
261 | |
---|
262 | |
---|
263 | // Generates values from a pair of STL-style iterators. Used in the |
---|
264 | // ValuesIn() function. The elements are copied from the source range |
---|
265 | // since the source can be located on the stack, and the generator |
---|
266 | // is likely to persist beyond that stack frame. |
---|
267 | template <typename T> |
---|
268 | class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> { |
---|
269 | public: |
---|
270 | template <typename ForwardIterator> |
---|
271 | ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end) |
---|
272 | : container_(begin, end) {} |
---|
273 | virtual ~ValuesInIteratorRangeGenerator() {} |
---|
274 | |
---|
275 | virtual ParamIteratorInterface<T>* Begin() const { |
---|
276 | return new Iterator(this, container_.begin()); |
---|
277 | } |
---|
278 | virtual ParamIteratorInterface<T>* End() const { |
---|
279 | return new Iterator(this, container_.end()); |
---|
280 | } |
---|
281 | |
---|
282 | private: |
---|
283 | typedef typename ::std::vector<T> ContainerType; |
---|
284 | |
---|
285 | class Iterator : public ParamIteratorInterface<T> { |
---|
286 | public: |
---|
287 | Iterator(const ParamGeneratorInterface<T>* base, |
---|
288 | typename ContainerType::const_iterator iterator) |
---|
289 | : base_(base), iterator_(iterator) {} |
---|
290 | virtual ~Iterator() {} |
---|
291 | |
---|
292 | virtual const ParamGeneratorInterface<T>* BaseGenerator() const { |
---|
293 | return base_; |
---|
294 | } |
---|
295 | virtual void Advance() { |
---|
296 | ++iterator_; |
---|
297 | value_.reset(); |
---|
298 | } |
---|
299 | virtual ParamIteratorInterface<T>* Clone() const { |
---|
300 | return new Iterator(*this); |
---|
301 | } |
---|
302 | // We need to use cached value referenced by iterator_ because *iterator_ |
---|
303 | // can return a temporary object (and of type other then T), so just |
---|
304 | // having "return &*iterator_;" doesn't work. |
---|
305 | // value_ is updated here and not in Advance() because Advance() |
---|
306 | // can advance iterator_ beyond the end of the range, and we cannot |
---|
307 | // detect that fact. The client code, on the other hand, is |
---|
308 | // responsible for not calling Current() on an out-of-range iterator. |
---|
309 | virtual const T* Current() const { |
---|
310 | if (value_.get() == NULL) |
---|
311 | value_.reset(new T(*iterator_)); |
---|
312 | return value_.get(); |
---|
313 | } |
---|
314 | virtual bool Equals(const ParamIteratorInterface<T>& other) const { |
---|
315 | // Having the same base generator guarantees that the other |
---|
316 | // iterator is of the same type and we can downcast. |
---|
317 | GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) |
---|
318 | << "The program attempted to compare iterators " |
---|
319 | << "from different generators." << std::endl; |
---|
320 | return iterator_ == |
---|
321 | CheckedDowncastToActualType<const Iterator>(&other)->iterator_; |
---|
322 | } |
---|
323 | |
---|
324 | private: |
---|
325 | Iterator(const Iterator& other) |
---|
326 | // The explicit constructor call suppresses a false warning |
---|
327 | // emitted by gcc when supplied with the -Wextra option. |
---|
328 | : ParamIteratorInterface<T>(), |
---|
329 | base_(other.base_), |
---|
330 | iterator_(other.iterator_) {} |
---|
331 | |
---|
332 | const ParamGeneratorInterface<T>* const base_; |
---|
333 | typename ContainerType::const_iterator iterator_; |
---|
334 | // A cached value of *iterator_. We keep it here to allow access by |
---|
335 | // pointer in the wrapping iterator's operator->(). |
---|
336 | // value_ needs to be mutable to be accessed in Current(). |
---|
337 | // Use of scoped_ptr helps manage cached value's lifetime, |
---|
338 | // which is bound by the lifespan of the iterator itself. |
---|
339 | mutable scoped_ptr<const T> value_; |
---|
340 | }; // class ValuesInIteratorRangeGenerator::Iterator |
---|
341 | |
---|
342 | // No implementation - assignment is unsupported. |
---|
343 | void operator=(const ValuesInIteratorRangeGenerator& other); |
---|
344 | |
---|
345 | const ContainerType container_; |
---|
346 | }; // class ValuesInIteratorRangeGenerator |
---|
347 | |
---|
348 | // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. |
---|
349 | // |
---|
350 | // Stores a parameter value and later creates tests parameterized with that |
---|
351 | // value. |
---|
352 | template <class TestClass> |
---|
353 | class ParameterizedTestFactory : public TestFactoryBase { |
---|
354 | public: |
---|
355 | typedef typename TestClass::ParamType ParamType; |
---|
356 | explicit ParameterizedTestFactory(ParamType parameter) : |
---|
357 | parameter_(parameter) {} |
---|
358 | virtual Test* CreateTest() { |
---|
359 | TestClass::SetParam(¶meter_); |
---|
360 | return new TestClass(); |
---|
361 | } |
---|
362 | |
---|
363 | private: |
---|
364 | const ParamType parameter_; |
---|
365 | |
---|
366 | GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory); |
---|
367 | }; |
---|
368 | |
---|
369 | // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. |
---|
370 | // |
---|
371 | // TestMetaFactoryBase is a base class for meta-factories that create |
---|
372 | // test factories for passing into MakeAndRegisterTestInfo function. |
---|
373 | template <class ParamType> |
---|
374 | class TestMetaFactoryBase { |
---|
375 | public: |
---|
376 | virtual ~TestMetaFactoryBase() {} |
---|
377 | |
---|
378 | virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0; |
---|
379 | }; |
---|
380 | |
---|
381 | // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. |
---|
382 | // |
---|
383 | // TestMetaFactory creates test factories for passing into |
---|
384 | // MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives |
---|
385 | // ownership of test factory pointer, same factory object cannot be passed |
---|
386 | // into that method twice. But ParameterizedTestCaseInfo is going to call |
---|
387 | // it for each Test/Parameter value combination. Thus it needs meta factory |
---|
388 | // creator class. |
---|
389 | template <class TestCase> |
---|
390 | class TestMetaFactory |
---|
391 | : public TestMetaFactoryBase<typename TestCase::ParamType> { |
---|
392 | public: |
---|
393 | typedef typename TestCase::ParamType ParamType; |
---|
394 | |
---|
395 | TestMetaFactory() {} |
---|
396 | |
---|
397 | virtual TestFactoryBase* CreateTestFactory(ParamType parameter) { |
---|
398 | return new ParameterizedTestFactory<TestCase>(parameter); |
---|
399 | } |
---|
400 | |
---|
401 | private: |
---|
402 | GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory); |
---|
403 | }; |
---|
404 | |
---|
405 | // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. |
---|
406 | // |
---|
407 | // ParameterizedTestCaseInfoBase is a generic interface |
---|
408 | // to ParameterizedTestCaseInfo classes. ParameterizedTestCaseInfoBase |
---|
409 | // accumulates test information provided by TEST_P macro invocations |
---|
410 | // and generators provided by INSTANTIATE_TEST_CASE_P macro invocations |
---|
411 | // and uses that information to register all resulting test instances |
---|
412 | // in RegisterTests method. The ParameterizeTestCaseRegistry class holds |
---|
413 | // a collection of pointers to the ParameterizedTestCaseInfo objects |
---|
414 | // and calls RegisterTests() on each of them when asked. |
---|
415 | class ParameterizedTestCaseInfoBase { |
---|
416 | public: |
---|
417 | virtual ~ParameterizedTestCaseInfoBase() {} |
---|
418 | |
---|
419 | // Base part of test case name for display purposes. |
---|
420 | virtual const string& GetTestCaseName() const = 0; |
---|
421 | // Test case id to verify identity. |
---|
422 | virtual TypeId GetTestCaseTypeId() const = 0; |
---|
423 | // UnitTest class invokes this method to register tests in this |
---|
424 | // test case right before running them in RUN_ALL_TESTS macro. |
---|
425 | // This method should not be called more then once on any single |
---|
426 | // instance of a ParameterizedTestCaseInfoBase derived class. |
---|
427 | virtual void RegisterTests() = 0; |
---|
428 | |
---|
429 | protected: |
---|
430 | ParameterizedTestCaseInfoBase() {} |
---|
431 | |
---|
432 | private: |
---|
433 | GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfoBase); |
---|
434 | }; |
---|
435 | |
---|
436 | // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. |
---|
437 | // |
---|
438 | // ParameterizedTestCaseInfo accumulates tests obtained from TEST_P |
---|
439 | // macro invocations for a particular test case and generators |
---|
440 | // obtained from INSTANTIATE_TEST_CASE_P macro invocations for that |
---|
441 | // test case. It registers tests with all values generated by all |
---|
442 | // generators when asked. |
---|
443 | template <class TestCase> |
---|
444 | class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase { |
---|
445 | public: |
---|
446 | // ParamType and GeneratorCreationFunc are private types but are required |
---|
447 | // for declarations of public methods AddTestPattern() and |
---|
448 | // AddTestCaseInstantiation(). |
---|
449 | typedef typename TestCase::ParamType ParamType; |
---|
450 | // A function that returns an instance of appropriate generator type. |
---|
451 | typedef ParamGenerator<ParamType>(GeneratorCreationFunc)(); |
---|
452 | |
---|
453 | explicit ParameterizedTestCaseInfo(const char* name) |
---|
454 | : test_case_name_(name) {} |
---|
455 | |
---|
456 | // Test case base name for display purposes. |
---|
457 | virtual const string& GetTestCaseName() const { return test_case_name_; } |
---|
458 | // Test case id to verify identity. |
---|
459 | virtual TypeId GetTestCaseTypeId() const { return GetTypeId<TestCase>(); } |
---|
460 | // TEST_P macro uses AddTestPattern() to record information |
---|
461 | // about a single test in a LocalTestInfo structure. |
---|
462 | // test_case_name is the base name of the test case (without invocation |
---|
463 | // prefix). test_base_name is the name of an individual test without |
---|
464 | // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is |
---|
465 | // test case base name and DoBar is test base name. |
---|
466 | void AddTestPattern(const char* test_case_name, |
---|
467 | const char* test_base_name, |
---|
468 | TestMetaFactoryBase<ParamType>* meta_factory) { |
---|
469 | tests_.push_back(linked_ptr<TestInfo>(new TestInfo(test_case_name, |
---|
470 | test_base_name, |
---|
471 | meta_factory))); |
---|
472 | } |
---|
473 | // INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record information |
---|
474 | // about a generator. |
---|
475 | int AddTestCaseInstantiation(const string& instantiation_name, |
---|
476 | GeneratorCreationFunc* func, |
---|
477 | const char* /* file */, |
---|
478 | int /* line */) { |
---|
479 | instantiations_.push_back(::std::make_pair(instantiation_name, func)); |
---|
480 | return 0; // Return value used only to run this method in namespace scope. |
---|
481 | } |
---|
482 | // UnitTest class invokes this method to register tests in this test case |
---|
483 | // test cases right before running tests in RUN_ALL_TESTS macro. |
---|
484 | // This method should not be called more then once on any single |
---|
485 | // instance of a ParameterizedTestCaseInfoBase derived class. |
---|
486 | // UnitTest has a guard to prevent from calling this method more then once. |
---|
487 | virtual void RegisterTests() { |
---|
488 | for (typename TestInfoContainer::iterator test_it = tests_.begin(); |
---|
489 | test_it != tests_.end(); ++test_it) { |
---|
490 | linked_ptr<TestInfo> test_info = *test_it; |
---|
491 | for (typename InstantiationContainer::iterator gen_it = |
---|
492 | instantiations_.begin(); gen_it != instantiations_.end(); |
---|
493 | ++gen_it) { |
---|
494 | const string& instantiation_name = gen_it->first; |
---|
495 | ParamGenerator<ParamType> generator((*gen_it->second)()); |
---|
496 | |
---|
497 | Message test_case_name_stream; |
---|
498 | if ( !instantiation_name.empty() ) |
---|
499 | test_case_name_stream << instantiation_name << "/"; |
---|
500 | test_case_name_stream << test_info->test_case_base_name; |
---|
501 | |
---|
502 | int i = 0; |
---|
503 | for (typename ParamGenerator<ParamType>::iterator param_it = |
---|
504 | generator.begin(); |
---|
505 | param_it != generator.end(); ++param_it, ++i) { |
---|
506 | Message test_name_stream; |
---|
507 | test_name_stream << test_info->test_base_name << "/" << i; |
---|
508 | MakeAndRegisterTestInfo( |
---|
509 | test_case_name_stream.GetString().c_str(), |
---|
510 | test_name_stream.GetString().c_str(), |
---|
511 | NULL, // No type parameter. |
---|
512 | PrintToString(*param_it).c_str(), |
---|
513 | GetTestCaseTypeId(), |
---|
514 | TestCase::SetUpTestCase, |
---|
515 | TestCase::TearDownTestCase, |
---|
516 | test_info->test_meta_factory->CreateTestFactory(*param_it)); |
---|
517 | } // for param_it |
---|
518 | } // for gen_it |
---|
519 | } // for test_it |
---|
520 | } // RegisterTests |
---|
521 | |
---|
522 | private: |
---|
523 | // LocalTestInfo structure keeps information about a single test registered |
---|
524 | // with TEST_P macro. |
---|
525 | struct TestInfo { |
---|
526 | TestInfo(const char* a_test_case_base_name, |
---|
527 | const char* a_test_base_name, |
---|
528 | TestMetaFactoryBase<ParamType>* a_test_meta_factory) : |
---|
529 | test_case_base_name(a_test_case_base_name), |
---|
530 | test_base_name(a_test_base_name), |
---|
531 | test_meta_factory(a_test_meta_factory) {} |
---|
532 | |
---|
533 | const string test_case_base_name; |
---|
534 | const string test_base_name; |
---|
535 | const scoped_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory; |
---|
536 | }; |
---|
537 | typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer; |
---|
538 | // Keeps pairs of <Instantiation name, Sequence generator creation function> |
---|
539 | // received from INSTANTIATE_TEST_CASE_P macros. |
---|
540 | typedef ::std::vector<std::pair<string, GeneratorCreationFunc*> > |
---|
541 | InstantiationContainer; |
---|
542 | |
---|
543 | const string test_case_name_; |
---|
544 | TestInfoContainer tests_; |
---|
545 | InstantiationContainer instantiations_; |
---|
546 | |
---|
547 | GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfo); |
---|
548 | }; // class ParameterizedTestCaseInfo |
---|
549 | |
---|
550 | // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. |
---|
551 | // |
---|
552 | // ParameterizedTestCaseRegistry contains a map of ParameterizedTestCaseInfoBase |
---|
553 | // classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P |
---|
554 | // macros use it to locate their corresponding ParameterizedTestCaseInfo |
---|
555 | // descriptors. |
---|
556 | class ParameterizedTestCaseRegistry { |
---|
557 | public: |
---|
558 | ParameterizedTestCaseRegistry() {} |
---|
559 | ~ParameterizedTestCaseRegistry() { |
---|
560 | for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); |
---|
561 | it != test_case_infos_.end(); ++it) { |
---|
562 | delete *it; |
---|
563 | } |
---|
564 | } |
---|
565 | |
---|
566 | // Looks up or creates and returns a structure containing information about |
---|
567 | // tests and instantiations of a particular test case. |
---|
568 | template <class TestCase> |
---|
569 | ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder( |
---|
570 | const char* test_case_name, |
---|
571 | const char* file, |
---|
572 | int line) { |
---|
573 | ParameterizedTestCaseInfo<TestCase>* typed_test_info = NULL; |
---|
574 | for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); |
---|
575 | it != test_case_infos_.end(); ++it) { |
---|
576 | if ((*it)->GetTestCaseName() == test_case_name) { |
---|
577 | if ((*it)->GetTestCaseTypeId() != GetTypeId<TestCase>()) { |
---|
578 | // Complain about incorrect usage of Google Test facilities |
---|
579 | // and terminate the program since we cannot guaranty correct |
---|
580 | // test case setup and tear-down in this case. |
---|
581 | ReportInvalidTestCaseType(test_case_name, file, line); |
---|
582 | posix::Abort(); |
---|
583 | } else { |
---|
584 | // At this point we are sure that the object we found is of the same |
---|
585 | // type we are looking for, so we downcast it to that type |
---|
586 | // without further checks. |
---|
587 | typed_test_info = CheckedDowncastToActualType< |
---|
588 | ParameterizedTestCaseInfo<TestCase> >(*it); |
---|
589 | } |
---|
590 | break; |
---|
591 | } |
---|
592 | } |
---|
593 | if (typed_test_info == NULL) { |
---|
594 | typed_test_info = new ParameterizedTestCaseInfo<TestCase>(test_case_name); |
---|
595 | test_case_infos_.push_back(typed_test_info); |
---|
596 | } |
---|
597 | return typed_test_info; |
---|
598 | } |
---|
599 | void RegisterTests() { |
---|
600 | for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); |
---|
601 | it != test_case_infos_.end(); ++it) { |
---|
602 | (*it)->RegisterTests(); |
---|
603 | } |
---|
604 | } |
---|
605 | |
---|
606 | private: |
---|
607 | typedef ::std::vector<ParameterizedTestCaseInfoBase*> TestCaseInfoContainer; |
---|
608 | |
---|
609 | TestCaseInfoContainer test_case_infos_; |
---|
610 | |
---|
611 | GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseRegistry); |
---|
612 | }; |
---|
613 | |
---|
614 | } // namespace internal |
---|
615 | } // namespace testing |
---|
616 | |
---|
617 | #endif // GTEST_HAS_PARAM_TEST |
---|
618 | |
---|
619 | #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ |
---|