fix AggregateOfImpl for domains with std::pair custom corpus PiperOrigin-RevId: 762052686

diff --git a/domain_tests/BUILD b/domain_tests/BUILD
index d71a93b..2756234 100644
--- a/domain_tests/BUILD
+++ b/domain_tests/BUILD

@@ -25,10 +25,14 @@
         ":domain_testing",
         "@abseil-cpp//absl/container:flat_hash_set",
         "@abseil-cpp//absl/random",
+        "@abseil-cpp//absl/random:bit_gen_ref",
+        "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/types:optional",
         "@abseil-cpp//absl/types:span",
         "@abseil-cpp//absl/types:variant",
         "@com_google_fuzztest//fuzztest:domain_core",
+        "@com_google_fuzztest//fuzztest:serialization",
+        "@com_google_fuzztest//fuzztest:type_support",
         "@googletest//:gtest_main",
     ],
 )

diff --git a/domain_tests/CMakeLists.txt b/domain_tests/CMakeLists.txt
index 703ee49..b7875eb 100644
--- a/domain_tests/CMakeLists.txt
+++ b/domain_tests/CMakeLists.txt

@@ -11,11 +11,15 @@
   DEPS
     fuzztest::domain_testing
     absl::flat_hash_set
+    absl::random_bit_gen_ref
     absl::random_random
     absl::optional
     absl::span
+    absl::status
     absl::variant
     fuzztest::domain_core
+    fuzztest::serialization
+    fuzztest::type_support
     GTest::gmock_main
 )
 

diff --git a/domain_tests/aggregate_combinators_test.cc b/domain_tests/aggregate_combinators_test.cc
index 4e4c175..dd69894 100644
--- a/domain_tests/aggregate_combinators_test.cc
+++ b/domain_tests/aggregate_combinators_test.cc

@@ -17,6 +17,7 @@
 #include <cstdint>
 #include <optional>
 #include <string>
+#include <tuple>
 #include <utility>
 #include <variant>
 #include <vector>
@@ -24,12 +25,16 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "absl/container/flat_hash_set.h"
+#include "absl/random/bit_gen_ref.h"
 #include "absl/random/random.h"
+#include "absl/status/status.h"
 #include "absl/types/optional.h"
 #include "absl/types/span.h"
 #include "absl/types/variant.h"
 #include "./fuzztest/domain_core.h"
 #include "./domain_tests/domain_testing.h"
+#include "./fuzztest/internal/serialization.h"
+#include "./fuzztest/internal/type_support.h"
 
 namespace fuzztest {
 namespace {
@@ -446,5 +451,48 @@
           R"(Invalid value in aggregate >> The value .+ is not InRange\(.+\))")));
 }
 
+TEST(TupleOf, DomainWithCustomPairCorpusType) {
+  class DomainWithCustomPairCorpusType
+      : public fuzztest::domain_implementor::DomainBase<
+            DomainWithCustomPairCorpusType, std::pair<uint8_t, uint8_t>,
+            std::pair<uint64_t, uint64_t>> {
+   public:
+    using corpus_type = DomainWithCustomPairCorpusType::DomainBase::corpus_type;
+    using value_type = DomainWithCustomPairCorpusType::DomainBase::value_type;
+
+    corpus_type Init(absl::BitGenRef prng) { return {0, 0}; }
+
+    void Mutate(corpus_type& val, absl::BitGenRef prng,
+                const domain_implementor::MutationMetadata& metadata,
+                bool only_shrink) {}
+
+    absl::Status ValidateCorpusValue(const corpus_type& value) const {
+      return absl::OkStatus();
+    }
+
+    auto GetPrinter() const { return internal::UnknownPrinter(); }
+
+    value_type GetValue(const corpus_type& v) const { return value_type(v); }
+
+    std::optional<corpus_type> FromValue(const value_type& v) const {
+      return corpus_type(v);
+    }
+
+    std::optional<corpus_type> ParseCorpus(
+        const internal::IRObject& obj) const {
+      return corpus_type{};
+    }
+
+    internal::IRObject SerializeCorpus(const corpus_type& v) const {
+      return internal::IRObject{};
+    }
+  };
+
+  auto domain = TupleOf(DomainWithCustomPairCorpusType{});
+  std::tuple<std::pair<uint8_t, uint8_t>> value{{1, 2}};
+  auto optional_corpus_tuple = domain.FromValue(value);
+  EXPECT_TRUE(optional_corpus_tuple.has_value());
+}
+
 }  // namespace
 }  // namespace fuzztest

diff --git a/fuzztest/internal/domains/aggregate_of_impl.h b/fuzztest/internal/domains/aggregate_of_impl.h
index 4b62083..cd70ca1 100644
--- a/fuzztest/internal/domains/aggregate_of_impl.h
+++ b/fuzztest/internal/domains/aggregate_of_impl.h

@@ -140,7 +140,7 @@
             value, std::integral_constant<int, sizeof...(Inner)>{});
         return [](auto... optional_values) -> std::optional<corpus_type> {
           if ((optional_values.has_value() && ...)) {
-            return std::tuple(*std::move(optional_values)...);
+            return corpus_type(*std::move(optional_values)...);
           } else {
             return std::nullopt;
           }