GCC Code Coverage Report

Directory:	./
File:	googletest/googletest/include/gtest/internal/gtest-param-util.h
Date:	2026-09-03 21:13:48
	Exec	Total	Coverage
Lines:	138	151	91.4%
Functions:	200	215	93.0%
Branches:	93	146	63.7%
  
      Line
      Branch
      Exec
      Source
    
      // Copyright 2008 Google Inc.
    
      // All Rights Reserved.
    
      //
    
      // Redistribution and use in source and binary forms, with or without
    
      // modification, are permitted provided that the following conditions are
    
      // met:
    
      //
    
      //     * Redistributions of source code must retain the above copyright
    
      // notice, this list of conditions and the following disclaimer.
    
      //     * Redistributions in binary form must reproduce the above
    
      // copyright notice, this list of conditions and the following disclaimer
    
      // in the documentation and/or other materials provided with the
    
      // distribution.
    
      //     * Neither the name of Google Inc. nor the names of its
    
      // contributors may be used to endorse or promote products derived from
    
      // this software without specific prior written permission.
    
      //
    
      // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    
      // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    
      // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    
      // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    
      // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    
      // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    
      // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    
      // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    
      // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    
      // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    
      // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    
      // Type and function utilities for implementing parameterized tests.
    
      // IWYU pragma: private, include "gtest/gtest.h"
    
      // IWYU pragma: friend gtest/.*
    
      // IWYU pragma: friend gmock/.*
    
      #ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
    
      #define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
    
      #include <ctype.h>
    
      #include <cassert>
    
      #include <iterator>
    
      #include <memory>
    
      #include <set>
    
      #include <tuple>
    
      #include <type_traits>
    
      #include <utility>
    
      #include <vector>
    
      #include "gtest/gtest-printers.h"
    
      #include "gtest/gtest-test-part.h"
    
      #include "gtest/internal/gtest-internal.h"
    
      #include "gtest/internal/gtest-port.h"
    
      namespace testing {
    
      // Input to a parameterized test name generator, describing a test parameter.
    
      // Consists of the parameter value and the integer parameter index.
    
      template <class ParamType>
    
      struct TestParamInfo {
    
      32
        TestParamInfo(const ParamType& a_param, size_t an_index)
    
      32
            : param(a_param), index(an_index) {}
    
        ParamType param;
    
        size_t index;
    
      };
    
      // A builtin parameterized test name generator which returns the result of
    
      // testing::PrintToString.
    
      struct PrintToStringParamName {
    
        template <class ParamType>
    
        std::string operator()(const TestParamInfo<ParamType>& info) const {
    
          return PrintToString(info.param);
    
        }
    
      };
    
      namespace internal {
    
      // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
    
      // Utility Functions
    
      // Outputs a message explaining invalid registration of different
    
      // fixture class for the same test suite. This may happen when
    
      // TEST_P macro is used to define two tests with the same name
    
      // but in different namespaces.
    
      GTEST_API_ void ReportInvalidTestSuiteType(const char* test_suite_name,
    
                                                 CodeLocation code_location);
    
      template <typename>
    
      class ParamGeneratorInterface;
    
      template <typename>
    
      class ParamGenerator;
    
      // Interface for iterating over elements provided by an implementation
    
      // of ParamGeneratorInterface<T>.
    
      template <typename T>
    
      class ParamIteratorInterface {
    
       public:
    
      58
        virtual ~ParamIteratorInterface() {}
    
        // A pointer to the base generator instance.
    
        // Used only for the purposes of iterator comparison
    
        // to make sure that two iterators belong to the same generator.
    
        virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0;
    
        // Advances iterator to point to the next element
    
        // provided by the generator. The caller is responsible
    
        // for not calling Advance() on an iterator equal to
    
        // BaseGenerator()->End().
    
        virtual void Advance() = 0;
    
        // Clones the iterator object. Used for implementing copy semantics
    
        // of ParamIterator<T>.
    
        virtual ParamIteratorInterface* Clone() const = 0;
    
        // Dereferences the current iterator and provides (read-only) access
    
        // to the pointed value. It is the caller's responsibility not to call
    
        // Current() on an iterator equal to BaseGenerator()->End().
    
        // Used for implementing ParamGenerator<T>::operator*().
    
        virtual const T* Current() const = 0;
    
        // Determines whether the given iterator and other point to the same
    
        // element in the sequence generated by the generator.
    
        // Used for implementing ParamGenerator<T>::operator==().
    
        virtual bool Equals(const ParamIteratorInterface& other) const = 0;
    
      };
    
      // Class iterating over elements provided by an implementation of
    
      // ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
    
      // and implements the const forward iterator concept.
    
      template <typename T>
    
      class ParamIterator {
    
       public:
    
        typedef T value_type;
    
        typedef const T& reference;
    
        typedef ptrdiff_t difference_type;
    
        // ParamIterator assumes ownership of the impl_ pointer.
    
        ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {}
    
        ParamIterator& operator=(const ParamIterator& other) {
    
          if (this != &other) impl_.reset(other.impl_->Clone());
    
          return *this;
    
        }
    
      96
        const T& operator*() const { return *impl_->Current(); }
    
        const T* operator->() const { return impl_->Current(); }
    
        // Prefix version of operator++.
    
      32
        ParamIterator& operator++() {
    
      32
          impl_->Advance();
    
      32
          return *this;
    
        }
    
        // Postfix version of operator++.
    
        ParamIterator operator++(int /*unused*/) {
    
          ParamIteratorInterface<T>* clone = impl_->Clone();
    
          impl_->Advance();
    
          return ParamIterator(clone);
    
        }
    
      41
        bool operator==(const ParamIterator& other) const {
    
        3/4✓ Branch 8 taken 24 times.
✗ Branch 9 not taken.
✓ Branch 26 taken 5 times.
✓ Branch 27 taken 19 times.

      41
          return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_);
    
        }
    
      41
        bool operator!=(const ParamIterator& other) const {
    
      41
          return !(*this == other);
    
        }
    
       private:
    
        friend class ParamGenerator<T>;
    
      50
        explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}
    
        std::unique_ptr<ParamIteratorInterface<T>> impl_;
    
      };
    
      // ParamGeneratorInterface<T> is the binary interface to access generators
    
      // defined in other translation units.
    
      template <typename T>
    
      class ParamGeneratorInterface {
    
       public:
    
        typedef T ParamType;
    
      10
        virtual ~ParamGeneratorInterface() {}
    
        // Generator interface definition
    
        virtual ParamIteratorInterface<T>* Begin() const = 0;
    
        virtual ParamIteratorInterface<T>* End() const = 0;
    
      };
    
      // Wraps ParamGeneratorInterface<T> and provides general generator syntax
    
      // compatible with the STL Container concept.
    
      // This class implements copy initialization semantics and the contained
    
      // ParamGeneratorInterface<T> instance is shared among all copies
    
      // of the original object. This is possible because that instance is immutable.
    
      template <typename T>
    
      class ParamGenerator {
    
       public:
    
        typedef ParamIterator<T> iterator;
    
      9
        explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {}
    
        ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {}
    
        ParamGenerator& operator=(const ParamGenerator& other) {
    
          impl_ = other.impl_;
    
          return *this;
    
        }
    
      9
        iterator begin() const { return iterator(impl_->Begin()); }
    
      41
        iterator end() const { return iterator(impl_->End()); }
    
       private:
    
        std::shared_ptr<const ParamGeneratorInterface<T>> impl_;
    
      };
    
      // Generates values from a range of two comparable values. Can be used to
    
      // generate sequences of user-defined types that implement operator+() and
    
      // operator<().
    
      // This class is used in the Range() function.
    
      template <typename T, typename IncrementT>
    
      class RangeGenerator : public ParamGeneratorInterface<T> {
    
       public:
    
        RangeGenerator(T begin, T end, IncrementT step)
    
            : begin_(begin),
    
              end_(end),
    
              step_(step),
    
              end_index_(CalculateEndIndex(begin, end, step)) {}
    
        ~RangeGenerator() override {}
    
        ParamIteratorInterface<T>* Begin() const override {
    
          return new Iterator(this, begin_, 0, step_);
    
        }
    
        ParamIteratorInterface<T>* End() const override {
    
          return new Iterator(this, end_, end_index_, step_);
    
        }
    
       private:
    
        class Iterator : public ParamIteratorInterface<T> {
    
         public:
    
          Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
    
                   IncrementT step)
    
              : base_(base), value_(value), index_(index), step_(step) {}
    
          ~Iterator() override {}
    
          const ParamGeneratorInterface<T>* BaseGenerator() const override {
    
            return base_;
    
          }
    
          void Advance() override {
    
            value_ = static_cast<T>(value_ + step_);
    
            index_++;
    
          }
    
          ParamIteratorInterface<T>* Clone() const override {
    
            return new Iterator(*this);
    
          }
    
          const T* Current() const override { return &value_; }
    
          bool Equals(const ParamIteratorInterface<T>& other) const override {
    
            // Having the same base generator guarantees that the other
    
            // iterator is of the same type and we can downcast.
    
            GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
    
                << "The program attempted to compare iterators "
    
                << "from different generators." << std::endl;
    
            const int other_index =
    
                CheckedDowncastToActualType<const Iterator>(&other)->index_;
    
            return index_ == other_index;
    
          }
    
         private:
    
          Iterator(const Iterator& other)
    
              : ParamIteratorInterface<T>(),
    
                base_(other.base_),
    
                value_(other.value_),
    
                index_(other.index_),
    
                step_(other.step_) {}
    
          // No implementation - assignment is unsupported.
    
          void operator=(const Iterator& other);
    
          const ParamGeneratorInterface<T>* const base_;
    
          T value_;
    
          int index_;
    
          const IncrementT step_;
    
        };  // class RangeGenerator::Iterator
    
        static int CalculateEndIndex(const T& begin, const T& end,
    
                                     const IncrementT& step) {
    
          int end_index = 0;
    
          for (T i = begin; i < end; i = static_cast<T>(i + step)) end_index++;
    
          return end_index;
    
        }
    
        // No implementation - assignment is unsupported.
    
        void operator=(const RangeGenerator& other);
    
        const T begin_;
    
        const T end_;
    
        const IncrementT step_;
    
        // The index for the end() iterator. All the elements in the generated
    
        // sequence are indexed (0-based) to aid iterator comparison.
    
        const int end_index_;
    
      };  // class RangeGenerator
    
      // Generates values from a pair of STL-style iterators. Used in the
    
      // ValuesIn() function. The elements are copied from the source range
    
      // since the source can be located on the stack, and the generator
    
      // is likely to persist beyond that stack frame.
    
      template <typename T>
    
      class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
    
       public:
    
        template <typename ForwardIterator>
    
      9
        ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
    
        1/1✓ Branch 10 taken 5 times.

      27
            : container_(begin, end) {}
    
      20
        ~ValuesInIteratorRangeGenerator() override {}
    
      9
        ParamIteratorInterface<T>* Begin() const override {
    
      9
          return new Iterator(this, container_.begin());
    
        }
    
      41
        ParamIteratorInterface<T>* End() const override {
    
      41
          return new Iterator(this, container_.end());
    
        }
    
       private:
    
        typedef typename ::std::vector<T> ContainerType;
    
        class Iterator : public ParamIteratorInterface<T> {
    
         public:
    
      50
          Iterator(const ParamGeneratorInterface<T>* base,
    
                   typename ContainerType::const_iterator iterator)
    
      50
              : base_(base), iterator_(iterator) {}
    
      116
          ~Iterator() override {}
    
      82
          const ParamGeneratorInterface<T>* BaseGenerator() const override {
    
      82
            return base_;
    
          }
    
      32
          void Advance() override {
    
      32
            ++iterator_;
    
      32
            value_.reset();
    
      32
          }
    
      ✗
          ParamIteratorInterface<T>* Clone() const override {
    
      ✗
            return new Iterator(*this);
    
          }
    
          // We need to use cached value referenced by iterator_ because *iterator_
    
          // can return a temporary object (and of type other then T), so just
    
          // having "return &*iterator_;" doesn't work.
    
          // value_ is updated here and not in Advance() because Advance()
    
          // can advance iterator_ beyond the end of the range, and we cannot
    
          // detect that fact. The client code, on the other hand, is
    
          // responsible for not calling Current() on an out-of-range iterator.
    
      96
          const T* Current() const override {
    
        3/5✓ Branch 4 taken 19 times.
✓ Branch 5 taken 38 times.
✓ Branch 19 taken 3 times.
✗ Branch 22 not taken.
✗ Branch 23 not taken.

      96
            if (value_.get() == nullptr) value_.reset(new T(*iterator_));
    
      96
            return value_.get();
    
          }
    
      41
          bool Equals(const ParamIteratorInterface<T>& other) const override {
    
            // Having the same base generator guarantees that the other
    
            // iterator is of the same type and we can downcast.
    
        1/3✗ Branch 15 not taken.
✓ Branch 16 taken 24 times.
✗ Branch 19 not taken.

      41
            GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
    
                << "The program attempted to compare iterators "
    
      ✗
                << "from different generators." << std::endl;
    
      41
            return iterator_ ==
    
      82
                   CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
    
          }
    
         private:
    
      ✗
          Iterator(const Iterator& other)
    
              // The explicit constructor call suppresses a false warning
    
              // emitted by gcc when supplied with the -Wextra option.
    
              : ParamIteratorInterface<T>(),
    
      ✗
                base_(other.base_),
    
      ✗
                iterator_(other.iterator_) {}
    
          const ParamGeneratorInterface<T>* const base_;
    
          typename ContainerType::const_iterator iterator_;
    
          // A cached value of *iterator_. We keep it here to allow access by
    
          // pointer in the wrapping iterator's operator->().
    
          // value_ needs to be mutable to be accessed in Current().
    
          // Use of std::unique_ptr helps manage cached value's lifetime,
    
          // which is bound by the lifespan of the iterator itself.
    
          mutable std::unique_ptr<const T> value_;
    
        };  // class ValuesInIteratorRangeGenerator::Iterator
    
        // No implementation - assignment is unsupported.
    
        void operator=(const ValuesInIteratorRangeGenerator& other);
    
        const ContainerType container_;
    
      };  // class ValuesInIteratorRangeGenerator
    
      // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
    
      //
    
      // Default parameterized test name generator, returns a string containing the
    
      // integer test parameter index.
    
      template <class ParamType>
    
      32
      std::string DefaultParamName(const TestParamInfo<ParamType>& info) {
    
        1/1✓ Branch 2 taken 19 times.

      32
        Message name_stream;
    
        1/1✓ Branch 6 taken 19 times.

      32
        name_stream << info.index;
    
        1/1✓ Branch 2 taken 19 times.

      64
        return name_stream.GetString();
    
      32
      }
    
      template <typename T = int>
    
      void TestNotEmpty() {
    
        static_assert(sizeof(T) == 0, "Empty arguments are not allowed.");
    
      }
    
      template <typename T = int>
    
      ✗
      void TestNotEmpty(const T&) {}
    
      // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
    
      //
    
      // Stores a parameter value and later creates tests parameterized with that
    
      // value.
    
      template <class TestClass>
    
      class ParameterizedTestFactory : public TestFactoryBase {
    
       public:
    
        typedef typename TestClass::ParamType ParamType;
    
      32
        explicit ParameterizedTestFactory(ParamType parameter)
    
        1/1✓ Branch 9 taken 3 times.

      32
            : parameter_(parameter) {}
    
      32
        Test* CreateTest() override {
    
      32
          TestClass::SetParam(&parameter_);
    
        1/3✓ Branch 2 taken 19 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.

      32
          return new TestClass();
    
        }
    
       private:
    
        const ParamType parameter_;
    
        ParameterizedTestFactory(const ParameterizedTestFactory&) = delete;
    
        ParameterizedTestFactory& operator=(const ParameterizedTestFactory&) = delete;
    
      };
    
      // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
    
      //
    
      // TestMetaFactoryBase is a base class for meta-factories that create
    
      // test factories for passing into MakeAndRegisterTestInfo function.
    
      template <class ParamType>
    
      class TestMetaFactoryBase {
    
       public:
    
      10
        virtual ~TestMetaFactoryBase() {}
    
        virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;
    
      };
    
      // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
    
      //
    
      // TestMetaFactory creates test factories for passing into
    
      // MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives
    
      // ownership of test factory pointer, same factory object cannot be passed
    
      // into that method twice. But ParameterizedTestSuiteInfo is going to call
    
      // it for each Test/Parameter value combination. Thus it needs meta factory
    
      // creator class.
    
      template <class TestSuite>
    
      class TestMetaFactory
    
          : public TestMetaFactoryBase<typename TestSuite::ParamType> {
    
       public:
    
        using ParamType = typename TestSuite::ParamType;
    
      9
        TestMetaFactory() {}
    
      32
        TestFactoryBase* CreateTestFactory(ParamType parameter) override {
    
        2/4✓ Branch 4 taken 3 times.
✓ Branch 7 taken 3 times.
✗ Branch 13 not taken.
✗ Branch 14 not taken.

      32
          return new ParameterizedTestFactory<TestSuite>(parameter);
    
        }
    
       private:
    
        TestMetaFactory(const TestMetaFactory&) = delete;
    
        TestMetaFactory& operator=(const TestMetaFactory&) = delete;
    
      };
    
      // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
    
      //
    
      // ParameterizedTestSuiteInfoBase is a generic interface
    
      // to ParameterizedTestSuiteInfo classes. ParameterizedTestSuiteInfoBase
    
      // accumulates test information provided by TEST_P macro invocations
    
      // and generators provided by INSTANTIATE_TEST_SUITE_P macro invocations
    
      // and uses that information to register all resulting test instances
    
      // in RegisterTests method. The ParameterizeTestSuiteRegistry class holds
    
      // a collection of pointers to the ParameterizedTestSuiteInfo objects
    
      // and calls RegisterTests() on each of them when asked.
    
      class ParameterizedTestSuiteInfoBase {
    
       public:
    
      10
        virtual ~ParameterizedTestSuiteInfoBase() {}
    
        // Base part of test suite name for display purposes.
    
        virtual const std::string& GetTestSuiteName() const = 0;
    
        // Test suite id to verify identity.
    
        virtual TypeId GetTestSuiteTypeId() const = 0;
    
        // UnitTest class invokes this method to register tests in this
    
        // test suite right before running them in RUN_ALL_TESTS macro.
    
        // This method should not be called more than once on any single
    
        // instance of a ParameterizedTestSuiteInfoBase derived class.
    
        virtual void RegisterTests() = 0;
    
       protected:
    
      5
        ParameterizedTestSuiteInfoBase() {}
    
       private:
    
        ParameterizedTestSuiteInfoBase(const ParameterizedTestSuiteInfoBase&) =
    
            delete;
    
        ParameterizedTestSuiteInfoBase& operator=(
    
            const ParameterizedTestSuiteInfoBase&) = delete;
    
      };
    
      // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
    
      //
    
      // Report a the name of a test_suit as safe to ignore
    
      // as the side effect of construction of this type.
    
      struct GTEST_API_ MarkAsIgnored {
    
        explicit MarkAsIgnored(const char* test_suite);
    
      };
    
      GTEST_API_ void InsertSyntheticTestCase(const std::string& name,
    
                                              CodeLocation location, bool has_test_p);
    
      // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
    
      //
    
      // ParameterizedTestSuiteInfo accumulates tests obtained from TEST_P
    
      // macro invocations for a particular test suite and generators
    
      // obtained from INSTANTIATE_TEST_SUITE_P macro invocations for that
    
      // test suite. It registers tests with all values generated by all
    
      // generators when asked.
    
      template <class TestSuite>
    
      class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
    
       public:
    
        // ParamType and GeneratorCreationFunc are private types but are required
    
        // for declarations of public methods AddTestPattern() and
    
        // AddTestSuiteInstantiation().
    
        using ParamType = typename TestSuite::ParamType;
    
        // A function that returns an instance of appropriate generator type.
    
        typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
    
        using ParamNameGeneratorFunc = std::string(const TestParamInfo<ParamType>&);
    
      9
        explicit ParameterizedTestSuiteInfo(const char* name,
    
                                            CodeLocation code_location)
    
        2/2✓ Branch 10 taken 5 times.
✓ Branch 17 taken 5 times.

      27
            : test_suite_name_(name), code_location_(code_location) {}
    
        // Test suite base name for display purposes.
    
      25
        const std::string& GetTestSuiteName() const override {
    
      25
          return test_suite_name_;
    
        }
    
        // Test suite id to verify identity.
    
      41
        TypeId GetTestSuiteTypeId() const override { return GetTypeId<TestSuite>(); }
    
        // TEST_P macro uses AddTestPattern() to record information
    
        // about a single test in a LocalTestInfo structure.
    
        // test_suite_name is the base name of the test suite (without invocation
    
        // prefix). test_base_name is the name of an individual test without
    
        // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
    
        // test suite base name and DoBar is test base name.
    
      9
        void AddTestPattern(const char* test_suite_name, const char* test_base_name,
    
                            TestMetaFactoryBase<ParamType>* meta_factory,
    
                            CodeLocation code_location) {
    
        5/7✓ Branch 5 taken 5 times.
✓ Branch 10 taken 5 times.
✓ Branch 13 taken 5 times.
✓ Branch 16 taken 5 times.
✓ Branch 20 taken 5 times.
✗ Branch 29 not taken.
✗ Branch 30 not taken.

      9
          tests_.push_back(std::shared_ptr<TestInfo>(new TestInfo(
    
              test_suite_name, test_base_name, meta_factory, code_location)));
    
      9
        }
    
        // INSTANTIATE_TEST_SUITE_P macro uses AddGenerator() to record information
    
        // about a generator.
    
      9
        int AddTestSuiteInstantiation(const std::string& instantiation_name,
    
                                      GeneratorCreationFunc* func,
    
                                      ParamNameGeneratorFunc* name_func,
    
                                      const char* file, int line) {
    
        1/1✓ Branch 4 taken 5 times.

      18
          instantiations_.push_back(
    
        1/1✓ Branch 2 taken 5 times.

      18
              InstantiationInfo(instantiation_name, func, name_func, file, line));
    
      9
          return 0;  // Return value used only to run this method in namespace scope.
    
        }
    
        // UnitTest class invokes this method to register tests in this test suite
    
        // right before running tests in RUN_ALL_TESTS macro.
    
        // This method should not be called more than once on any single
    
        // instance of a ParameterizedTestSuiteInfoBase derived class.
    
        // UnitTest has a guard to prevent from calling this method more than once.
    
      9
        void RegisterTests() override {
    
      9
          bool generated_instantiations = false;
    
      18
          for (typename TestInfoContainer::iterator test_it = tests_.begin();
    
        2/2✓ Branch 9 taken 5 times.
✓ Branch 10 taken 5 times.

      18
               test_it != tests_.end(); ++test_it) {
    
      9
            std::shared_ptr<TestInfo> test_info = *test_it;
    
      27
            for (typename InstantiationContainer::iterator gen_it =
    
      9
                     instantiations_.begin();
    
        2/2✓ Branch 9 taken 5 times.
✓ Branch 10 taken 5 times.

      18
                 gen_it != instantiations_.end(); ++gen_it) {
    
      9
              const std::string& instantiation_name = gen_it->name;
    
        1/1✓ Branch 5 taken 5 times.

      9
              ParamGenerator<ParamType> generator((*gen_it->generator)());
    
      9
              ParamNameGeneratorFunc* name_func = gen_it->name_func;
    
      9
              const char* file = gen_it->file;
    
      9
              int line = gen_it->line;
    
      9
              std::string test_suite_name;
    
        1/2✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.

      9
              if (!instantiation_name.empty())
    
        1/1✓ Branch 3 taken 5 times.

      9
                test_suite_name = instantiation_name + "/";
    
        1/1✓ Branch 4 taken 5 times.

      9
              test_suite_name += test_info->test_suite_base_name;
    
      9
              size_t i = 0;
    
      9
              std::set<std::string> test_param_names;
    
        1/1✓ Branch 2 taken 5 times.

      82
              for (typename ParamGenerator<ParamType>::iterator param_it =
    
                       generator.begin();
    
        5/5✓ Branch 1 taken 19 times.
✓ Branch 5 taken 24 times.
✓ Branch 9 taken 24 times.
✓ Branch 13 taken 19 times.
✓ Branch 14 taken 5 times.

      73
                   param_it != generator.end(); ++param_it, ++i) {
    
      32
                generated_instantiations = true;
    
        1/1✓ Branch 2 taken 19 times.

      32
                Message test_name_stream;
    
        1/1✓ Branch 2 taken 19 times.

      64
                std::string param_name =
    
        2/2✓ Branch 2 taken 19 times.
✓ Branch 5 taken 3 times.

      64
                    name_func(TestParamInfo<ParamType>(*param_it, i));
    
        2/4✓ Branch 2 taken 19 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 19 times.
✗ Branch 8 not taken.

      32
                GTEST_CHECK_(IsValidParamName(param_name))
    
                    << "Parameterized test name '" << param_name
    
      ✗
                    << "' is invalid, in " << file << " line " << line << std::endl;
    
        3/5✓ Branch 1 taken 19 times.
✓ Branch 4 taken 19 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 19 times.
✗ Branch 10 not taken.

      32
                GTEST_CHECK_(test_param_names.count(param_name) == 0)
    
                    << "Duplicate parameterized test name '" << param_name << "', in "
    
      ✗
                    << file << " line " << line << std::endl;
    
        1/1✓ Branch 1 taken 19 times.

      32
                test_param_names.insert(param_name);
    
        1/2✓ Branch 5 taken 19 times.
✗ Branch 6 not taken.

      32
                if (!test_info->test_base_name.empty()) {
    
        2/2✓ Branch 5 taken 19 times.
✓ Branch 9 taken 19 times.

      32
                  test_name_stream << test_info->test_base_name << "/";
    
                }
    
        1/1✓ Branch 1 taken 19 times.

      32
                test_name_stream << param_name;
    
        8/8✓ Branch 1 taken 16 times.
✓ Branch 4 taken 16 times.
✓ Branch 7 taken 16 times.
✓ Branch 10 taken 16 times.
✓ Branch 14 taken 19 times.
✓ Branch 17 taken 3 times.
✓ Branch 20 taken 16 times.
✓ Branch 27 taken 3 times.

      192
                MakeAndRegisterTestInfo(
    
        1/1✓ Branch 2 taken 19 times.

      64
                    test_suite_name.c_str(), test_name_stream.GetString().c_str(),
    
                    nullptr,  // No type parameter.
    
        2/2✓ Branch 6 taken 19 times.
✓ Branch 9 taken 19 times.

      96
                    PrintToString(*param_it).c_str(), test_info->code_location,
    
      32
                    GetTestSuiteTypeId(),
    
                    SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(file, line),
    
                    SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(file, line),
    
        1/1✓ Branch 12 taken 16 times.

      32
                    test_info->test_meta_factory->CreateTestFactory(*param_it));
    
              }  // for param_it
    
            }    // for gen_it
    
          }      // for test_it
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.

      9
          if (!generated_instantiations) {
    
            // There are no generaotrs, or they all generate nothing ...
    
      ✗
            InsertSyntheticTestCase(GetTestSuiteName(), code_location_,
    
      ✗
                                    !tests_.empty());
    
          }
    
      9
        }  // RegisterTests
    
       private:
    
        // LocalTestInfo structure keeps information about a single test registered
    
        // with TEST_P macro.
    
        struct TestInfo {
    
      9
          TestInfo(const char* a_test_suite_base_name, const char* a_test_base_name,
    
                   TestMetaFactoryBase<ParamType>* a_test_meta_factory,
    
                   CodeLocation a_code_location)
    
        1/1✓ Branch 4 taken 5 times.

      27
              : test_suite_base_name(a_test_suite_base_name),
    
        1/1✓ Branch 5 taken 5 times.

      27
                test_base_name(a_test_base_name),
    
      9
                test_meta_factory(a_test_meta_factory),
    
        1/1✓ Branch 4 taken 5 times.

      9
                code_location(a_code_location) {}
    
          const std::string test_suite_base_name;
    
          const std::string test_base_name;
    
          const std::unique_ptr<TestMetaFactoryBase<ParamType>> test_meta_factory;
    
          const CodeLocation code_location;
    
        };
    
        using TestInfoContainer = ::std::vector<std::shared_ptr<TestInfo>>;
    
        // Records data received from INSTANTIATE_TEST_SUITE_P macros:
    
        //  <Instantiation name, Sequence generator creation function,
    
        //     Name generator function, Source file, Source line>
    
        struct InstantiationInfo {
    
      9
          InstantiationInfo(const std::string& name_in,
    
                            GeneratorCreationFunc* generator_in,
    
                            ParamNameGeneratorFunc* name_func_in, const char* file_in,
    
                            int line_in)
    
      9
              : name(name_in),
    
      9
                generator(generator_in),
    
      9
                name_func(name_func_in),
    
      9
                file(file_in),
    
      9
                line(line_in) {}
    
          std::string name;
    
          GeneratorCreationFunc* generator;
    
          ParamNameGeneratorFunc* name_func;
    
          const char* file;
    
          int line;
    
        };
    
        typedef ::std::vector<InstantiationInfo> InstantiationContainer;
    
      32
        static bool IsValidParamName(const std::string& name) {
    
          // Check for empty string
    
        1/2✗ Branch 2 not taken.
✓ Branch 3 taken 19 times.

      32
          if (name.empty()) return false;
    
          // Check for invalid characters
    
        2/2✓ Branch 2 taken 19 times.
✓ Branch 3 taken 19 times.

      64
          for (std::string::size_type index = 0; index < name.size(); ++index) {
    
        2/6✗ Branch 4 not taken.
✓ Branch 5 taken 19 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✓ Branch 12 taken 19 times.

      32
            if (!IsAlNum(name[index]) && name[index] != '_') return false;
    
          }
    
      32
          return true;
    
        }
    
        const std::string test_suite_name_;
    
        CodeLocation code_location_;
    
        TestInfoContainer tests_;
    
        InstantiationContainer instantiations_;
    
        ParameterizedTestSuiteInfo(const ParameterizedTestSuiteInfo&) = delete;
    
        ParameterizedTestSuiteInfo& operator=(const ParameterizedTestSuiteInfo&) =
    
            delete;
    
      };  // class ParameterizedTestSuiteInfo
    
      //  Legacy API is deprecated but still available
    
      #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    
      template <class TestCase>
    
      using ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo<TestCase>;
    
      #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    
      // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
    
      //
    
      // ParameterizedTestSuiteRegistry contains a map of
    
      // ParameterizedTestSuiteInfoBase classes accessed by test suite names. TEST_P
    
      // and INSTANTIATE_TEST_SUITE_P macros use it to locate their corresponding
    
      // ParameterizedTestSuiteInfo descriptors.
    
      class ParameterizedTestSuiteRegistry {
    
       public:
    
        ParameterizedTestSuiteRegistry() {}
    
        ~ParameterizedTestSuiteRegistry() {
    
          for (auto& test_suite_info : test_suite_infos_) {
    
            delete test_suite_info;
    
          }
    
        }
    
        // Looks up or creates and returns a structure containing information about
    
        // tests and instantiations of a particular test suite.
    
        template <class TestSuite>
    
      18
        ParameterizedTestSuiteInfo<TestSuite>* GetTestSuitePatternHolder(
    
            const char* test_suite_name, CodeLocation code_location) {
    
      18
          ParameterizedTestSuiteInfo<TestSuite>* typed_test_info = nullptr;
    
        2/2✓ Branch 12 taken 13 times.
✓ Branch 13 taken 5 times.

      30
          for (auto& test_suite_info : test_suite_infos_) {
    
        3/3✓ Branch 11 taken 13 times.
✓ Branch 15 taken 5 times.
✓ Branch 16 taken 8 times.

      21
            if (test_suite_info->GetTestSuiteName() == test_suite_name) {
    
        2/3✓ Branch 11 taken 5 times.
✗ Branch 14 not taken.
✓ Branch 15 taken 5 times.

      9
              if (test_suite_info->GetTestSuiteTypeId() != GetTypeId<TestSuite>()) {
    
                // Complain about incorrect usage of Google Test facilities
    
                // and terminate the program since we cannot guaranty correct
    
                // test suite setup and tear-down in this case.
    
      ✗
                ReportInvalidTestSuiteType(test_suite_name, code_location);
    
      ✗
                posix::Abort();
    
              } else {
    
                // At this point we are sure that the object we found is of the same
    
                // type we are looking for, so we downcast it to that type
    
                // without further checks.
    
                typed_test_info = CheckedDowncastToActualType<
    
        1/1✓ Branch 2 taken 5 times.

      9
                    ParameterizedTestSuiteInfo<TestSuite>>(test_suite_info);
    
              }
    
      9
              break;
    
            }
    
          }
    
        2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.

      18
          if (typed_test_info == nullptr) {
    
        2/4✓ Branch 4 taken 5 times.
✓ Branch 7 taken 5 times.
✗ Branch 13 not taken.
✗ Branch 14 not taken.

      9
            typed_test_info = new ParameterizedTestSuiteInfo<TestSuite>(
    
                test_suite_name, code_location);
    
        1/1✓ Branch 5 taken 5 times.

      9
            test_suite_infos_.push_back(typed_test_info);
    
          }
    
      18
          return typed_test_info;
    
        }
    
        void RegisterTests() {
    
          for (auto& test_suite_info : test_suite_infos_) {
    
            test_suite_info->RegisterTests();
    
          }
    
        }
    
      //  Legacy API is deprecated but still available
    
      #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    
        template <class TestCase>
    
        ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
    
            const char* test_case_name, CodeLocation code_location) {
    
          return GetTestSuitePatternHolder<TestCase>(test_case_name, code_location);
    
        }
    
      #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    
       private:
    
        using TestSuiteInfoContainer = ::std::vector<ParameterizedTestSuiteInfoBase*>;
    
        TestSuiteInfoContainer test_suite_infos_;
    
        ParameterizedTestSuiteRegistry(const ParameterizedTestSuiteRegistry&) =
    
            delete;
    
        ParameterizedTestSuiteRegistry& operator=(
    
            const ParameterizedTestSuiteRegistry&) = delete;
    
      };
    
      // Keep track of what type-parameterized test suite are defined and
    
      // where as well as which are intatiated. This allows susequently
    
      // identifying suits that are defined but never used.
    
      class TypeParameterizedTestSuiteRegistry {
    
       public:
    
        // Add a suite definition
    
        void RegisterTestSuite(const char* test_suite_name,
    
                               CodeLocation code_location);
    
        // Add an instantiation of a suit.
    
        void RegisterInstantiation(const char* test_suite_name);
    
        // For each suit repored as defined but not reported as instantiation,
    
        // emit a test that reports that fact (configurably, as an error).
    
        void CheckForInstantiations();
    
       private:
    
        struct TypeParameterizedTestSuiteInfo {
    
          explicit TypeParameterizedTestSuiteInfo(CodeLocation c)
    
              : code_location(c), instantiated(false) {}
    
          CodeLocation code_location;
    
          bool instantiated;
    
        };
    
        std::map<std::string, TypeParameterizedTestSuiteInfo> suites_;
    
      };
    
      }  // namespace internal
    
      // Forward declarations of ValuesIn(), which is implemented in
    
      // include/gtest/gtest-param-test.h.
    
      template <class Container>
    
      internal::ParamGenerator<typename Container::value_type> ValuesIn(
    
          const Container& container);
    
      namespace internal {
    
      // Used in the Values() function to provide polymorphic capabilities.
    
      #ifdef _MSC_VER
    
      #pragma warning(push)
    
      #pragma warning(disable : 4100)
    
      #endif
    
      template <typename... Ts>
    
      class ValueArray {
    
       public:
    
      9
        explicit ValueArray(Ts... v) : v_(FlatTupleConstructTag{}, std::move(v)...) {}
    
        template <typename T>
    
      9
        operator ParamGenerator<T>() const {  // NOLINT
    
        2/2✓ Branch 2 taken 5 times.
✓ Branch 7 taken 5 times.

      9
          return ValuesIn(MakeVector<T>(MakeIndexSequence<sizeof...(Ts)>()));
    
        }
    
       private:
    
        template <typename T, size_t... I>
    
      7
        std::vector<T> MakeVector(IndexSequence<I...>) const {
    
        5/7✓ Branch 11 taken 1 times.
✓ Branch 15 taken 3 times.
✓ Branch 16 taken 1 times.
✗ Branch 23 not taken.
✗ Branch 24 not taken.
✓ Branch 27 taken 1 times.
✓ Branch 39 taken 1 times.

      33
          return std::vector<T>{static_cast<T>(v_.template Get<I>())...};
    
      8
        }
    
        FlatTuple<Ts...> v_;
    
      };
    
      #ifdef _MSC_VER
    
      #pragma warning(pop)
    
      #endif
    
      template <typename... T>
    
      class CartesianProductGenerator
    
          : public ParamGeneratorInterface<::std::tuple<T...>> {
    
       public:
    
        typedef ::std::tuple<T...> ParamType;
    
        CartesianProductGenerator(const std::tuple<ParamGenerator<T>...>& g)
    
            : generators_(g) {}
    
        ~CartesianProductGenerator() override {}
    
        ParamIteratorInterface<ParamType>* Begin() const override {
    
          return new Iterator(this, generators_, false);
    
        }
    
        ParamIteratorInterface<ParamType>* End() const override {
    
          return new Iterator(this, generators_, true);
    
        }
    
       private:
    
        template <class I>
    
        class IteratorImpl;
    
        template <size_t... I>
    
        class IteratorImpl<IndexSequence<I...>>
    
            : public ParamIteratorInterface<ParamType> {
    
         public:
    
          IteratorImpl(const ParamGeneratorInterface<ParamType>* base,
    
                       const std::tuple<ParamGenerator<T>...>& generators,
    
                       bool is_end)
    
              : base_(base),
    
                begin_(std::get<I>(generators).begin()...),
    
                end_(std::get<I>(generators).end()...),
    
                current_(is_end ? end_ : begin_) {
    
            ComputeCurrentValue();
    
          }
    
          ~IteratorImpl() override {}
    
          const ParamGeneratorInterface<ParamType>* BaseGenerator() const override {
    
            return base_;
    
          }
    
          // Advance should not be called on beyond-of-range iterators
    
          // so no component iterators must be beyond end of range, either.
    
          void Advance() override {
    
            assert(!AtEnd());
    
            // Advance the last iterator.
    
            ++std::get<sizeof...(T) - 1>(current_);
    
            // if that reaches end, propagate that up.
    
            AdvanceIfEnd<sizeof...(T) - 1>();
    
            ComputeCurrentValue();
    
          }
    
          ParamIteratorInterface<ParamType>* Clone() const override {
    
            return new IteratorImpl(*this);
    
          }
    
          const ParamType* Current() const override { return current_value_.get(); }
    
          bool Equals(const ParamIteratorInterface<ParamType>& other) const override {
    
            // Having the same base generator guarantees that the other
    
            // iterator is of the same type and we can downcast.
    
            GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
    
                << "The program attempted to compare iterators "
    
                << "from different generators." << std::endl;
    
            const IteratorImpl* typed_other =
    
                CheckedDowncastToActualType<const IteratorImpl>(&other);
    
            // We must report iterators equal if they both point beyond their
    
            // respective ranges. That can happen in a variety of fashions,
    
            // so we have to consult AtEnd().
    
            if (AtEnd() && typed_other->AtEnd()) return true;
    
            bool same = true;
    
            bool dummy[] = {
    
                (same = same && std::get<I>(current_) ==
    
                                    std::get<I>(typed_other->current_))...};
    
            (void)dummy;
    
            return same;
    
          }
    
         private:
    
          template <size_t ThisI>
    
          void AdvanceIfEnd() {
    
            if (std::get<ThisI>(current_) != std::get<ThisI>(end_)) return;
    
            bool last = ThisI == 0;
    
            if (last) {
    
              // We are done. Nothing else to propagate.
    
              return;
    
            }
    
            constexpr size_t NextI = ThisI - (ThisI != 0);
    
            std::get<ThisI>(current_) = std::get<ThisI>(begin_);
    
            ++std::get<NextI>(current_);
    
            AdvanceIfEnd<NextI>();
    
          }
    
          void ComputeCurrentValue() {
    
            if (!AtEnd())
    
              current_value_ = std::make_shared<ParamType>(*std::get<I>(current_)...);
    
          }
    
          bool AtEnd() const {
    
            bool at_end = false;
    
            bool dummy[] = {
    
                (at_end = at_end || std::get<I>(current_) == std::get<I>(end_))...};
    
            (void)dummy;
    
            return at_end;
    
          }
    
          const ParamGeneratorInterface<ParamType>* const base_;
    
          std::tuple<typename ParamGenerator<T>::iterator...> begin_;
    
          std::tuple<typename ParamGenerator<T>::iterator...> end_;
    
          std::tuple<typename ParamGenerator<T>::iterator...> current_;
    
          std::shared_ptr<ParamType> current_value_;
    
        };
    
        using Iterator = IteratorImpl<typename MakeIndexSequence<sizeof...(T)>::type>;
    
        std::tuple<ParamGenerator<T>...> generators_;
    
      };
    
      template <class... Gen>
    
      class CartesianProductHolder {
    
       public:
    
        CartesianProductHolder(const Gen&... g) : generators_(g...) {}
    
        template <typename... T>
    
        operator ParamGenerator<::std::tuple<T...>>() const {
    
          return ParamGenerator<::std::tuple<T...>>(
    
              new CartesianProductGenerator<T...>(generators_));
    
        }
    
       private:
    
        std::tuple<Gen...> generators_;
    
      };
    
      }  // namespace internal
    
      }  // namespace testing
    
      #endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_