1 files changed, 57 insertions, 0 deletions
diff --git a/deps/v8/test/unittests/base/template-utils-unittest.cc b/deps/v8/test/unittests/base/template-utils-unittest.cc
index ea8796a123..2c1da8ec86 100644
--- a/deps/v8/test/unittests/base/template-utils-unittest.cc
+++ b/deps/v8/test/unittests/base/template-utils-unittest.cc
@@ -101,6 +101,63 @@ static_assert(has_output_operator<TestClass2>::value,
 static_assert(!has_output_operator<const TestClass2>::value,
               "const TestClass2 can not be output");
 
+//////////////////////////////
+// Test fold.
+//////////////////////////////
+
+struct FoldAllSameType {
+  constexpr uint32_t operator()(uint32_t a, uint32_t b) const { return a | b; }
+};
+static_assert(base::fold(FoldAllSameType{}, 3, 6) == 7, "check fold");
+// Test that it works if implicit conversion is needed for one of the
+// parameters.
+static_assert(base::fold(FoldAllSameType{}, uint8_t{1}, 256) == 257,
+              "check correct type inference");
+// Test a single parameter.
+static_assert(base::fold(FoldAllSameType{}, 25) == 25,
+              "check folding a single argument");
+
+TEST(TemplateUtilsTest, FoldDifferentType) {
+  auto fn = [](std::string str, char c) {
+    str.push_back(c);
+    return str;
+  };
+  CHECK_EQ(base::fold(fn, std::string("foo"), 'b', 'a', 'r'), "foobar");
+}
+
+TEST(TemplateUtilsTest, FoldMoveOnlyType) {
+  auto fn = [](std::unique_ptr<std::string> str, char c) {
+    str->push_back(c);
+    return str;
+  };
+  std::unique_ptr<std::string> str = base::make_unique<std::string>("foo");
+  std::unique_ptr<std::string> folded =
+      base::fold(fn, std::move(str), 'b', 'a', 'r');
+  CHECK_NULL(str);
+  CHECK_NOT_NULL(folded);
+  CHECK_EQ(*folded, "foobar");
+}
+
+struct TemplatizedFoldFunctor {
+  template <typename T, typename... Tup>
+  std::tuple<Tup..., typename std::decay<T>::type> operator()(
+      std::tuple<Tup...> tup, T&& val) {
+    return std::tuple_cat(std::move(tup),
+                          std::make_tuple(std::forward<T>(val)));
+  }
+};
+TEST(TemplateUtilsTest, FoldToTuple) {
+  auto input = std::make_tuple(char{'x'}, int{4}, double{3.2},
+                               std::unique_ptr<uint8_t>{}, std::string{"foo"});
+  auto result =
+      base::fold(TemplatizedFoldFunctor{}, std::make_tuple(),
+                 std::get<0>(input), std::get<1>(input), std::get<2>(input),
+                 std::unique_ptr<uint8_t>{}, std::get<4>(input));
+  static_assert(std::is_same<decltype(result), decltype(input)>::value,
+                "the resulting tuple should have the same type as the input");
+  DCHECK_EQ(input, result);
+}
+
 }  // namespace template_utils_unittest
 }  // namespace base
 }  // namespace v8