214 end_index_(CalculateEndIndex(begin, end, step)) {}
218 return new Iterator(
this, begin_, 0, step_);
221 return new Iterator(
this, end_, end_index_, step_);
229 : base_(base), value_(value), index_(index), step_(step) {}
230 ~Iterator()
override {}
235 void Advance()
override {
236 value_ =
static_cast<T
>(value_ + step_);
240 return new Iterator(*
this);
242 const T* Current()
const override {
return &value_; }
246 GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
247 <<
"The program attempted to compare iterators "
248 <<
"from different generators." << std::endl;
249 const int other_index =
250 CheckedDowncastToActualType<const Iterator>(&other)->index_;
251 return index_ == other_index;
255 Iterator(
const Iterator& other)
258 value_(other.value_),
259 index_(other.index_),
260 step_(other.step_) {}
263 void operator=(
const Iterator& other);
268 const IncrementT step_;
271 static int CalculateEndIndex(
const T& begin,
const T& end,
272 const IncrementT& step) {
274 for (T i = begin; i < end; i = static_cast<T>(i + step)) end_index++;
283 const IncrementT step_;
286 const int end_index_;
296 template <
typename ForwardIterator>
298 : container_(begin, end) {}
302 return new Iterator(
this, container_.begin());
305 return new Iterator(
this, container_.end());
309 typedef typename ::std::vector<T> ContainerType;
314 typename ContainerType::const_iterator iterator)
315 : base_(base), iterator_(iterator) {}
316 ~Iterator()
override {}
321 void Advance()
override {
326 return new Iterator(*
this);
335 const T* Current()
const override {
336 if (value_.get() ==
nullptr) value_.reset(
new T(*iterator_));
342 GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
343 <<
"The program attempted to compare iterators "
344 <<
"from different generators." << std::endl;
346 CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
350 Iterator(
const Iterator& other)
355 iterator_(other.iterator_) {}
358 typename ContainerType::const_iterator iterator_;
364 mutable std::unique_ptr<const T> value_;
370 const ContainerType container_;
508 using ParamType =
typename TestSuite::ParamType;
515 : test_suite_name_(name), code_location_(code_location) {}
518 const std::string& GetTestSuiteName()
const override {
519 return test_suite_name_;
522 TypeId GetTestSuiteTypeId()
const override {
return GetTypeId<TestSuite>(); }
529 void AddTestPattern(
const char* test_suite_name,
const char* test_base_name,
532 tests_.push_back(std::shared_ptr<TestInfo>(
new TestInfo(
533 test_suite_name, test_base_name, meta_factory, code_location)));
537 int AddTestSuiteInstantiation(
const std::string& instantiation_name,
538 GeneratorCreationFunc* func,
539 ParamNameGeneratorFunc* name_func,
540 const char* file,
int line) {
541 instantiations_.push_back(
542 InstantiationInfo(instantiation_name, func, name_func, file, line));
550 void RegisterTests()
override {
551 bool generated_instantiations =
false;
553 for (
typename TestInfoContainer::iterator test_it = tests_.begin();
554 test_it != tests_.end(); ++test_it) {
555 std::shared_ptr<TestInfo> test_info = *test_it;
556 for (
typename InstantiationContainer::iterator gen_it =
557 instantiations_.begin();
558 gen_it != instantiations_.end(); ++gen_it) {
559 const std::string& instantiation_name = gen_it->name;
561 ParamNameGeneratorFunc* name_func = gen_it->name_func;
562 const char* file = gen_it->file;
563 int line = gen_it->line;
565 std::string test_suite_name;
566 if (!instantiation_name.empty())
567 test_suite_name = instantiation_name +
"/";
568 test_suite_name += test_info->test_suite_base_name;
571 std::set<std::string> test_param_names;
574 param_it != generator.end(); ++param_it, ++i) {
575 generated_instantiations =
true;
579 std::string param_name =
582 GTEST_CHECK_(IsValidParamName(param_name))
583 <<
"Parameterized test name '" << param_name
584 <<
"' is invalid, in " << file <<
" line " << line << std::endl;
586 GTEST_CHECK_(test_param_names.count(param_name) == 0)
587 <<
"Duplicate parameterized test name '" << param_name <<
"', in "
588 << file <<
" line " << line << std::endl;
590 test_param_names.insert(param_name);
592 if (!test_info->test_base_name.empty()) {
593 test_name_stream << test_info->test_base_name <<
"/";
595 test_name_stream << param_name;
596 MakeAndRegisterTestInfo(
597 test_suite_name.c_str(), test_name_stream.GetString().c_str(),
599 PrintToString(*param_it).c_str(), test_info->code_location,
600 GetTestSuiteTypeId(),
603 test_info->test_meta_factory->CreateTestFactory(*param_it));
608 if (!generated_instantiations) {
610 InsertSyntheticTestCase(GetTestSuiteName(), code_location_,
619 TestInfo(
const char* a_test_suite_base_name,
const char* a_test_base_name,
622 : test_suite_base_name(a_test_suite_base_name),
623 test_base_name(a_test_base_name),
624 test_meta_factory(a_test_meta_factory),
625 code_location(a_code_location) {}
627 const std::string test_suite_base_name;
628 const std::string test_base_name;
629 const std::unique_ptr<TestMetaFactoryBase<ParamType>> test_meta_factory;
632 using TestInfoContainer = ::std::vector<std::shared_ptr<TestInfo>>;
636 struct InstantiationInfo {
637 InstantiationInfo(
const std::string& name_in,
638 GeneratorCreationFunc* generator_in,
639 ParamNameGeneratorFunc* name_func_in,
const char* file_in,
642 generator(generator_in),
643 name_func(name_func_in),
648 GeneratorCreationFunc* generator;
649 ParamNameGeneratorFunc* name_func;
653 typedef ::std::vector<InstantiationInfo> InstantiationContainer;
655 static bool IsValidParamName(
const std::string& name) {
657 if (name.empty())
return false;
660 for (std::string::size_type index = 0; index < name.size(); ++index) {
661 if (!IsAlNum(name[index]) && name[index] !=
'_')
return false;
667 const std::string test_suite_name_;
669 TestInfoContainer tests_;
670 InstantiationContainer instantiations_;
693 for (
auto& test_suite_info : test_suite_infos_) {
694 delete test_suite_info;
700 template <
class TestSuite>
702 const char* test_suite_name,
CodeLocation code_location) {
704 for (
auto& test_suite_info : test_suite_infos_) {
705 if (test_suite_info->GetTestSuiteName() == test_suite_name) {
706 if (test_suite_info->GetTestSuiteTypeId() != GetTypeId<TestSuite>()) {
710 ReportInvalidTestSuiteType(test_suite_name, code_location);
716 typed_test_info = CheckedDowncastToActualType<
722 if (typed_test_info ==
nullptr) {
724 test_suite_name, code_location);
725 test_suite_infos_.push_back(typed_test_info);
727 return typed_test_info;
729 void RegisterTests() {
730 for (
auto& test_suite_info : test_suite_infos_) {
731 test_suite_info->RegisterTests();
735#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
736 template <
class TestCase>
738 const char* test_case_name,
CodeLocation code_location) {
739 return GetTestSuitePatternHolder<TestCase>(test_case_name, code_location);
745 using TestSuiteInfoContainer = ::std::vector<ParameterizedTestSuiteInfoBase*>;
747 TestSuiteInfoContainer test_suite_infos_;
826 typedef ::std::tuple<T...> ParamType;
833 return new Iterator(
this, generators_,
false);
836 return new Iterator(
this, generators_,
true);
842 template <
size_t... I>
850 begin_(std::get<I>(generators).begin()...),
851 end_(std::get<I>(generators).end()...),
852 current_(is_end ? end_ : begin_) {
853 ComputeCurrentValue();
855 ~IteratorImpl()
override {}
862 void Advance()
override {
865 ++std::get<
sizeof...(T) - 1>(current_);
867 AdvanceIfEnd<
sizeof...(T) - 1>();
868 ComputeCurrentValue();
871 return new IteratorImpl(*
this);
874 const ParamType* Current()
const override {
return current_value_.get(); }
879 GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
880 <<
"The program attempted to compare iterators "
881 <<
"from different generators." << std::endl;
882 const IteratorImpl* typed_other =
883 CheckedDowncastToActualType<const IteratorImpl>(&other);
888 if (AtEnd() && typed_other->AtEnd())
return true;
892 (same = same && std::get<I>(current_) ==
893 std::get<I>(typed_other->current_))...};
899 template <
size_t ThisI>
900 void AdvanceIfEnd() {
901 if (std::get<ThisI>(current_) != std::get<ThisI>(end_))
return;
903 bool last = ThisI == 0;
909 constexpr size_t NextI = ThisI - (ThisI != 0);
910 std::get<ThisI>(current_) = std::get<ThisI>(begin_);
911 ++std::get<NextI>(current_);
912 AdvanceIfEnd<NextI>();
915 void ComputeCurrentValue() {
917 current_value_ = std::make_shared<ParamType>(*std::get<I>(current_)...);
922 (at_end = at_end || std::get<I>(current_) == std::get<I>(end_))...};
928 std::tuple<typename ParamGenerator<T>::iterator...> begin_;
929 std::tuple<typename ParamGenerator<T>::iterator...> end_;
930 std::tuple<typename ParamGenerator<T>::iterator...> current_;
931 std::shared_ptr<ParamType> current_value_;
934 using Iterator = IteratorImpl<
typename MakeIndexSequence<
sizeof...(T)>::type>;
936 std::tuple<ParamGenerator<T>...> generators_;