Add `CombineTo<R>()` generator function

`CombineTo<R>()` allows to construct the required type directly from combined arguments. As it would be a composition of `ConvertGenerator()` and `Combine()`, but without `std::tuple` in between.

googletest/include/gtest/gtest-param-test.h

@@ -359,6 +359,47 @@ internal::ParamGenerator<std::common_type_t<Ts...>> Values(Ts... vs) {
 //
 inline internal::ParamGenerator<bool> Bool() { return Values(false, true); }
 
+// CombineTo() allows the user to combine two or more sequences to produce
+// values of a Cartesian product of those sequences' elements converted to
+// the required type.
+//
+// Synopsis:
+// CombineTo<MyClass>(gen1, gen2, ..., genN)
+//   - returns a generator producing sequences with elements coming from
+//     the Cartesian product of elements from the sequences generated by
+//     gen1, gen2, ..., genN. The sequence elements will have a type of
+//     Myclass where elements from sequences produced by gen1, gen2, ..., genN
+//     was provided to the MyClass constructor parameters.
+//
+// Example:
+//
+// This will instantiate tests in test suite AnimalTest each one with
+// the parameter values Animal("cat", BLACK), Animal("cat", WHITE),
+// Animal("dog", BLACK), and Animal("dog", WHITE):
+// enum Color { BLACK, GRAY, WHITE };
+//
+// struct Animal {
+//   std::string name;
+//   Color color;
+// };
+//
+// class AnimalTest
+//     : public testing::TestWithParam<Animal> {...};
+//
+// TEST_P(AnimalTest, AnimalLooksNice) {...}
+//
+// INSTANTIATE_TEST_SUITE_P(AnimalVariations, AnimalTest,
+//                          CombineTo<Animal>(Values("cat", "dog"),
+//                                  Values(BLACK, WHITE)));
+//
+template <typename R, typename... T>
+internal::ParamGenerator<R> CombineTo(
+    internal::ParamGenerator<T>&&... generators) {
+  return internal::ParamGenerator<R>(
+      new internal::CartesianProductGenerator<R, T...>(
+          std::forward<decltype(generators)>(generators)...));
+}
+
 // Combine() allows the user to combine two or more sequences to produce
 // values of a Cartesian product of those sequences' elements.
 //

googletest/include/gtest/internal/gtest-param-util.h

@@ -900,7 +900,8 @@ class CartesianProductGenerator : public ParamGeneratorInterface<R> {
 
     void ComputeCurrentValue() {
       if (!AtEnd())
-        current_value_ = std::make_shared<ParamType>(*std::get<I>(current_)...);
+        current_value_ =
+            std::make_shared<ParamType>(ParamType{*std::get<I>(current_)...});
     }
     bool AtEnd() const {
       bool at_end = false;

googletest/test/googletest-param-test-test.cc

@@ -583,6 +583,70 @@ TEST(ConvertTest, NonDefaultConstructAssign) {
   EXPECT_TRUE(it == gen.end());
 }
 
+TEST(CombineToTest, DefaultConstructible) {
+  struct DefaultConstructible {
+    int x;
+    std::string s;
+
+    bool operator==(const DefaultConstructible& other) const {
+      return x == other.x && s == other.s;
+    }
+  };
+
+  static_assert(std::is_default_constructible_v<DefaultConstructible>);
+  ParamGenerator<DefaultConstructible> gen =
+      testing::CombineTo<DefaultConstructible>(Values(0, 1), Values("A", "B"));
+
+  DefaultConstructible expected_values[] = {
+      {0, "A"}, {0, "B"}, {1, "A"}, {1, "B"}};
+  VerifyGenerator(gen, expected_values);
+}
+
+TEST(CombineToTest, NonDefaultConstructible) {
+  class NonDefaultConstructible {
+   public:
+    NonDefaultConstructible(const int xArg, std::string sArg)
+        : x(xArg), s(std::move(sArg)) {}
+
+    bool operator==(const NonDefaultConstructible& other) const {
+      return x == other.x && s == other.s;
+    }
+
+   private:
+    int x;
+    std::string s;
+  };
+
+  static_assert(not std::is_default_constructible_v<NonDefaultConstructible>);
+  ParamGenerator<NonDefaultConstructible> gen =
+      testing::CombineTo<NonDefaultConstructible>(Values(0, 1),
+                                                  Values("A", "B"));
+
+  NonDefaultConstructible expected_values[] = {
+      {0, "A"}, {0, "B"}, {1, "A"}, {1, "B"}};
+  VerifyGenerator(gen, expected_values);
+}
+
+TEST(CombineToTest, CopyConstructible) {
+  struct CopyConstructible {
+    CopyConstructible(const CopyConstructible& other) = default;
+
+    bool operator==(const CopyConstructible& other) const {
+      return x == other.x && s == other.s;
+    }
+
+    int x;
+    std::string s;
+  };
+
+  static_assert(std::is_copy_constructible_v<CopyConstructible>);
+  ParamGenerator<CopyConstructible> gen = testing::CombineTo<CopyConstructible>(
+      Values(CopyConstructible{0, "A"}, CopyConstructible{1, "B"}));
+  CopyConstructible expected_values[] = {CopyConstructible{0, "A"},
+                                         CopyConstructible{1, "B"}};
+  VerifyGenerator(gen, expected_values);
+}
+
 // Tests that an generator produces correct sequence after being
 // assigned from another generator.
 TEST(ParamGeneratorTest, AssignmentWorks) {