[12177] | 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_ |
---|