210 : begin_(begin), end_(end),
211 step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
215 return new Iterator(
this, begin_, 0, step_);
218 return new Iterator(
this, end_, end_index_, step_);
226 : base_(base), value_(value), index_(index), step_(step) {}
227 ~Iterator()
override {}
232 void Advance()
override {
233 value_ =
static_cast<T
>(value_ + step_);
237 return new Iterator(*
this);
239 const T* Current()
const override {
return &value_; }
243 GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
244 <<
"The program attempted to compare iterators "
245 <<
"from different generators." << std::endl;
246 const int other_index =
247 CheckedDowncastToActualType<const Iterator>(&other)->index_;
248 return index_ == other_index;
252 Iterator(
const Iterator& other)
254 base_(other.base_), value_(other.value_), index_(other.index_),
255 step_(other.step_) {}
258 void operator=(
const Iterator& other);
263 const IncrementT step_;
266 static int CalculateEndIndex(
const T& begin,
268 const IncrementT& step) {
270 for (T i = begin; i < end; i = static_cast<T>(i + step))
280 const IncrementT step_;
283 const int end_index_;
501 using ParamType =
typename TestSuite::ParamType;
508 : test_suite_name_(name), code_location_(code_location) {}
511 const std::string& GetTestSuiteName()
const override {
512 return test_suite_name_;
515 TypeId GetTestSuiteTypeId()
const override {
return GetTypeId<TestSuite>(); }
522 void AddTestPattern(
const char* test_suite_name,
const char* test_base_name,
525 tests_.push_back(std::shared_ptr<TestInfo>(
new TestInfo(
526 test_suite_name, test_base_name, meta_factory, code_location)));
530 int AddTestSuiteInstantiation(
const std::string& instantiation_name,
531 GeneratorCreationFunc* func,
532 ParamNameGeneratorFunc* name_func,
533 const char* file,
int line) {
534 instantiations_.push_back(
535 InstantiationInfo(instantiation_name, func, name_func, file, line));
543 void RegisterTests()
override {
544 bool generated_instantiations =
false;
546 for (
typename TestInfoContainer::iterator test_it = tests_.begin();
547 test_it != tests_.end(); ++test_it) {
548 std::shared_ptr<TestInfo> test_info = *test_it;
549 for (
typename InstantiationContainer::iterator gen_it =
550 instantiations_.begin(); gen_it != instantiations_.end();
552 const std::string& instantiation_name = gen_it->name;
554 ParamNameGeneratorFunc* name_func = gen_it->name_func;
555 const char* file = gen_it->file;
556 int line = gen_it->line;
558 std::string test_suite_name;
559 if ( !instantiation_name.empty() )
560 test_suite_name = instantiation_name +
"/";
561 test_suite_name += test_info->test_suite_base_name;
564 std::set<std::string> test_param_names;
567 param_it != generator.end(); ++param_it, ++i) {
568 generated_instantiations =
true;
572 std::string param_name = name_func(
575 GTEST_CHECK_(IsValidParamName(param_name))
576 <<
"Parameterized test name '" << param_name
577 <<
"' is invalid, in " << file
578 <<
" line " << line << std::endl;
580 GTEST_CHECK_(test_param_names.count(param_name) == 0)
581 <<
"Duplicate parameterized test name '" << param_name
582 <<
"', in " << file <<
" line " << line << std::endl;
584 test_param_names.insert(param_name);
586 if (!test_info->test_base_name.empty()) {
587 test_name_stream << test_info->test_base_name <<
"/";
589 test_name_stream << param_name;
590 MakeAndRegisterTestInfo(
591 test_suite_name.c_str(), test_name_stream.GetString().c_str(),
593 PrintToString(*param_it).c_str(), test_info->code_location,
594 GetTestSuiteTypeId(),
597 test_info->test_meta_factory->CreateTestFactory(*param_it));
602 if (!generated_instantiations) {
604 InsertSyntheticTestCase(GetTestSuiteName(), code_location_,
613 TestInfo(
const char* a_test_suite_base_name,
const char* a_test_base_name,
616 : test_suite_base_name(a_test_suite_base_name),
617 test_base_name(a_test_base_name),
618 test_meta_factory(a_test_meta_factory),
619 code_location(a_code_location) {}
621 const std::string test_suite_base_name;
622 const std::string test_base_name;
623 const std::unique_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
626 using TestInfoContainer = ::std::vector<std::shared_ptr<TestInfo> >;
630 struct InstantiationInfo {
631 InstantiationInfo(
const std::string &name_in,
632 GeneratorCreationFunc* generator_in,
633 ParamNameGeneratorFunc* name_func_in,
637 generator(generator_in),
638 name_func(name_func_in),
643 GeneratorCreationFunc* generator;
644 ParamNameGeneratorFunc* name_func;
648 typedef ::std::vector<InstantiationInfo> InstantiationContainer;
650 static bool IsValidParamName(
const std::string& name) {
656 for (std::string::size_type index = 0; index < name.size(); ++index) {
657 if (!isalnum(name[index]) && name[index] !=
'_')
664 const std::string test_suite_name_;
666 TestInfoContainer tests_;
667 InstantiationContainer instantiations_;
688 for (
auto& test_suite_info : test_suite_infos_) {
689 delete test_suite_info;
695 template <
class TestSuite>
697 const char* test_suite_name,
CodeLocation code_location) {
699 for (
auto& test_suite_info : test_suite_infos_) {
700 if (test_suite_info->GetTestSuiteName() == test_suite_name) {
701 if (test_suite_info->GetTestSuiteTypeId() != GetTypeId<TestSuite>()) {
705 ReportInvalidTestSuiteType(test_suite_name, code_location);
711 typed_test_info = CheckedDowncastToActualType<
717 if (typed_test_info ==
nullptr) {
719 test_suite_name, code_location);
720 test_suite_infos_.push_back(typed_test_info);
722 return typed_test_info;
724 void RegisterTests() {
725 for (
auto& test_suite_info : test_suite_infos_) {
726 test_suite_info->RegisterTests();
730#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
731 template <
class TestCase>
733 const char* test_case_name,
CodeLocation code_location) {
734 return GetTestSuitePatternHolder<TestCase>(test_case_name, code_location);
740 using TestSuiteInfoContainer = ::std::vector<ParameterizedTestSuiteInfoBase*>;
742 TestSuiteInfoContainer test_suite_infos_;
818 typedef ::std::tuple<T...> ParamType;
825 return new Iterator(
this, generators_,
false);
828 return new Iterator(
this, generators_,
true);
834 template <
size_t... I>
841 begin_(std::get<I>(generators).begin()...),
842 end_(std::get<I>(generators).end()...),
843 current_(is_end ? end_ : begin_) {
844 ComputeCurrentValue();
846 ~IteratorImpl()
override {}
853 void Advance()
override {
856 ++std::get<
sizeof...(T) - 1>(current_);
858 AdvanceIfEnd<
sizeof...(T) - 1>();
859 ComputeCurrentValue();
862 return new IteratorImpl(*
this);
865 const ParamType* Current()
const override {
return current_value_.get(); }
870 GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
871 <<
"The program attempted to compare iterators "
872 <<
"from different generators." << std::endl;
873 const IteratorImpl* typed_other =
874 CheckedDowncastToActualType<const IteratorImpl>(&other);
879 if (AtEnd() && typed_other->AtEnd())
return true;
883 (same = same && std::get<I>(current_) ==
884 std::get<I>(typed_other->current_))...};
890 template <
size_t ThisI>
891 void AdvanceIfEnd() {
892 if (std::get<ThisI>(current_) != std::get<ThisI>(end_))
return;
894 bool last = ThisI == 0;
900 constexpr size_t NextI = ThisI - (ThisI != 0);
901 std::get<ThisI>(current_) = std::get<ThisI>(begin_);
902 ++std::get<NextI>(current_);
903 AdvanceIfEnd<NextI>();
906 void ComputeCurrentValue() {
908 current_value_ = std::make_shared<ParamType>(*std::get<I>(current_)...);
913 (at_end = at_end || std::get<I>(current_) == std::get<I>(end_))...};
919 std::tuple<typename ParamGenerator<T>::iterator...> begin_;
920 std::tuple<typename ParamGenerator<T>::iterator...> end_;
921 std::tuple<typename ParamGenerator<T>::iterator...> current_;
922 std::shared_ptr<ParamType> current_value_;
925 using Iterator = IteratorImpl<
typename MakeIndexSequence<
sizeof...(T)>::type>;
927 std::tuple<ParamGenerator<T>...> generators_;