diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.pass.cpp
--- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/ranges.copy.pass.cpp
@@ -24,6 +24,7 @@
 
 #include "almost_satisfies_types.h"
 #include "test_iterators.h"
+#include "type_algorithms.h"
 
 template <class In, class Out = In, class Sent = sentinel_wrapper<In>>
 concept HasCopyIt = requires(In in, Sent sent, Out out) { std::ranges::copy(in, sent, out); };
@@ -101,36 +102,23 @@
   test_iterators<In, Out, sentinel_wrapper<In>>();
 }
 
-template <class Out>
-constexpr void test_in_iterators() {
-  test_iterators<cpp20_input_iterator<int*>, Out, sentinel_wrapper<cpp20_input_iterator<int*>>>();
-  test_sentinels<forward_iterator<int*>, Out>();
-  test_sentinels<bidirectional_iterator<int*>, Out>();
-  test_sentinels<random_access_iterator<int*>, Out>();
-  test_sentinels<contiguous_iterator<int*>, Out>();
-}
-
-template <class Out>
-constexpr void test_proxy_in_iterators() {
-  test_iterators<ProxyIterator<cpp20_input_iterator<int*>>, Out, sentinel_wrapper<ProxyIterator<cpp20_input_iterator<int*>>>>();
-  test_iterators<ProxyIterator<forward_iterator<int*>>, Out>();
-  test_iterators<ProxyIterator<bidirectional_iterator<int*>>, Out>();
-  test_iterators<ProxyIterator<random_access_iterator<int*>>, Out>();
-  test_iterators<ProxyIterator<contiguous_iterator<int*>>, Out>();
-}
-
 constexpr bool test() {
-  test_in_iterators<cpp20_input_iterator<int*>>();
-  test_in_iterators<forward_iterator<int*>>();
-  test_in_iterators<bidirectional_iterator<int*>>();
-  test_in_iterators<random_access_iterator<int*>>();
-  test_in_iterators<contiguous_iterator<int*>>();
-
-  test_proxy_in_iterators<ProxyIterator<cpp20_input_iterator<int*>>>();
-  test_proxy_in_iterators<ProxyIterator<forward_iterator<int*>>>();
-  test_proxy_in_iterators<ProxyIterator<bidirectional_iterator<int*>>>();
-  test_proxy_in_iterators<ProxyIterator<random_access_iterator<int*>>>();
-  test_proxy_in_iterators<ProxyIterator<contiguous_iterator<int*>>>();
+  meta::apply_all(
+      meta::concatenate_t<
+          meta::cartesian_product_t<meta::forward_iterator_list<int*>, meta::cpp20_input_iterator_list<int*>>,
+          meta::cartesian_product_t<meta::proxy_forward_iterator_list<int*>,
+                                    meta::proxy_cpp20_input_iterator_list<int*>>>{},
+      []<class In, class Out>() { test_sentinels<In, Out>(); });
+
+  meta::apply_all(meta::cpp20_input_iterator_list<int*>{}, []<class Out> {
+    test_iterators<cpp20_input_iterator<int*>, Out, sentinel_wrapper<cpp20_input_iterator<int*>>>();
+  });
+
+  meta::apply_all(meta::proxy_cpp20_input_iterator_list<int*>{}, []<class Out> {
+    test_iterators<ProxyIterator<cpp20_input_iterator<int*>>,
+                   Out,
+                   sentinel_wrapper<ProxyIterator<cpp20_input_iterator<int*>>>>();
+  });
 
   { // check that ranges::dangling is returned
     std::array<int, 4> out;
diff --git a/libcxx/test/std/language.support/support.limits/limits/is_specialized.pass.cpp b/libcxx/test/std/language.support/support.limits/limits/is_specialized.pass.cpp
--- a/libcxx/test/std/language.support/support.limits/limits/is_specialized.pass.cpp
+++ b/libcxx/test/std/language.support/support.limits/limits/is_specialized.pass.cpp
@@ -26,11 +26,11 @@
 #include <limits>
 #include <complex>
 
-#include "test_macros.h"
+#include "type_algorithms.h"
 
-template <class T>
-void test()
-{
+struct Test {
+  template <class T>
+  void operator()() {
     static_assert(std::numeric_limits<T>::is_specialized,
                  "std::numeric_limits<T>::is_specialized");
     static_assert(std::numeric_limits<const T>::is_specialized,
@@ -39,37 +39,15 @@
                  "std::numeric_limits<volatile T>::is_specialized");
     static_assert(std::numeric_limits<const volatile T>::is_specialized,
                  "std::numeric_limits<const volatile T>::is_specialized");
-}
+  }
+};
 
 int main(int, char**)
 {
-    test<bool>();
-    test<char>();
-    test<wchar_t>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
-    test<char8_t>();
-#endif
-    test<char16_t>();
-    test<char32_t>();
-    test<signed char>();
-    test<unsigned char>();
-    test<signed short>();
-    test<unsigned short>();
-    test<signed int>();
-    test<unsigned int>();
-    test<signed long>();
-    test<unsigned long>();
-    test<signed long long>();
-    test<unsigned long long>();
-#ifndef TEST_HAS_NO_INT128
-    test<__int128_t>();
-    test<__uint128_t>();
-#endif
-    test<float>();
-    test<double>();
-    test<long double>();
-    static_assert(!std::numeric_limits<std::complex<double> >::is_specialized,
-                 "!std::numeric_limits<std::complex<double> >::is_specialized");
+  meta::apply_all(meta::arithmetic_types(), Test());
+
+  static_assert(!std::numeric_limits<std::complex<double> >::is_specialized,
+                "!std::numeric_limits<std::complex<double> >::is_specialized");
 
   return 0;
 }
diff --git a/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp b/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp
--- a/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.access/at.pass.cpp
@@ -17,7 +17,9 @@
 
 #include "min_allocator.h"
 
+#include "make_string.h"
 #include "test_macros.h"
+#include "type_algorithms.h"
 
 template <class S>
 TEST_CONSTEXPR_CXX20 void
@@ -57,17 +59,24 @@
 template <class S>
 TEST_CONSTEXPR_CXX20 void test_string() {
   test(S(), 0);
-  test(S("123"), 0);
-  test(S("123"), 1);
-  test(S("123"), 2);
-  test(S("123"), 3);
+  test(S(MAKE_CSTRING(typename S::value_type, "123")), 0);
+  test(S(MAKE_CSTRING(typename S::value_type, "123")), 1);
+  test(S(MAKE_CSTRING(typename S::value_type, "123")), 2);
+  test(S(MAKE_CSTRING(typename S::value_type, "123")), 3);
 }
 
-TEST_CONSTEXPR_CXX20 bool test() {
-  test_string<std::string>();
+struct TestCaller {
+  template <class T>
+  TEST_CONSTEXPR_CXX20 void operator()() {
+        test_string<std::basic_string<T> >();
 #if TEST_STD_VER >= 11
-  test_string<std::basic_string<char, std::char_traits<char>, min_allocator<char>>>();
+        test_string<std::basic_string<T, std::char_traits<T>, min_allocator<T> > >();
 #endif
+  }
+};
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  meta::apply_all(meta::character_types(), TestCaller());
 
   return true;
 }
diff --git a/libcxx/test/support/test.support/type_algorithms.pass.cpp b/libcxx/test/support/test.support/type_algorithms.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/support/test.support/type_algorithms.pass.cpp
@@ -0,0 +1,129 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <algorithm>
+#include <cassert>
+#include <type_traits>
+
+#include "test_macros.h"
+#include "type_algorithms.h"
+
+// concatenate
+static_assert(std::is_same<meta::concatenate_t<int>, meta::type_list<int> >::value, "");
+static_assert(std::is_same<meta::concatenate_t<int, long>, meta::type_list<int, long> >::value, "");
+static_assert(std::is_same<meta::concatenate_t<meta::type_list<> >, meta::type_list<> >::value, "");
+static_assert(std::is_same<meta::concatenate_t<meta::type_list<int> >, meta::type_list<int> >::value, "");
+static_assert(std::is_same<meta::concatenate_t<meta::type_list<int>, long>, meta::type_list<int, long> >::value, "");
+static_assert(
+    std::is_same<meta::concatenate_t<meta::type_list<int>, meta::type_list<long> >, meta::type_list<int, long> >::value,
+    "");
+static_assert(std::is_same<meta::concatenate_t<meta::type_list<int>, meta::type_list<long>, long long>,
+                           meta::type_list<int, long, long long> >::value,
+              "");
+static_assert(
+    std::is_same<meta::concatenate_t<meta::type_list<int>, meta::type_list<long>, meta::type_list<long long> >,
+                 meta::type_list<int, long, long long> >::value,
+    "");
+
+// wrap_list
+template <class T>
+struct Wrapper {};
+
+template <class T>
+using Wrap = Wrapper<T>;
+
+static_assert(std::is_same<meta::wrap_list_t<Wrap, meta::type_list<int, long> >,
+                           meta::type_list< Wrapper<int>, Wrapper<long> > >::value,
+              "");
+
+// cartesian_product
+static_assert(std::is_same<meta::cartesian_product_t<meta::type_list<int>, meta::type_list<long> >,
+                           meta::type_list<meta::type_list<int, long> > >::value,
+              "");
+static_assert(std::is_same<meta::cartesian_product_t<meta::type_list<int, long>, meta::type_list<long long> >,
+                           meta::type_list<meta::type_list<int, long long>, meta::type_list<long, long long> > >::value,
+              "");
+static_assert(
+    std::is_same<meta::cartesian_product_t<meta::type_list<int, long>, meta::type_list<Wrapper<int>, Wrapper<long> > >,
+                 meta::type_list<meta::type_list<int, Wrapper<int> >,
+                                 meta::type_list<long, Wrapper<int> >,
+                                 meta::type_list<int, Wrapper<long> >,
+                                 meta::type_list<long, Wrapper<long> > > >::value,
+    "");
+
+struct CheckApply {
+  template <class T, class U>
+  TEST_CONSTEXPR_CXX14 void operator()() {
+    static_assert(std::is_same<T, int>::value && std::is_same<U, long>::value, "");
+  }
+};
+
+// apply
+TEST_CONSTEXPR_CXX20 void test_apply() { meta::apply(meta::type_list<int, long>(), CheckApply()); }
+
+// apply_all
+template <int N>
+class NumT {};
+
+struct ApplyAllTest {
+  bool* is_called_array_;
+
+  TEST_CONSTEXPR ApplyAllTest(bool* is_called_array) : is_called_array_(is_called_array) {}
+
+  template <int N>
+  TEST_CONSTEXPR_CXX20 void check_num(NumT<N>) {
+    assert(!is_called_array_[N]);
+    is_called_array_[N] = true;
+  }
+
+  template <int N, int M>
+  TEST_CONSTEXPR_CXX20 void check_num(NumT<N>, NumT<M>) {
+    assert(!is_called_array_[N + M]);
+    is_called_array_[N + M] = true;
+  }
+
+  template <class... Types>
+  TEST_CONSTEXPR_CXX20 void operator()() {
+    check_num(Types()...);
+  }
+};
+
+struct Identity {
+  TEST_CONSTEXPR bool operator()(bool b) const { return b; }
+};
+
+TEST_CONSTEXPR_CXX20 void test_apply_all() {
+  {
+    bool is_called_array[3] = {};
+    meta::apply_all(meta::type_list<NumT<0>, NumT<1>, NumT<2> >(), ApplyAllTest(is_called_array));
+    assert(std::all_of(is_called_array, is_called_array + 3, Identity()));
+  }
+
+  {
+    bool is_called_array[9] = {};
+    meta::apply_all(meta::cartesian_product_t<meta::type_list<NumT<0>, NumT<1>, NumT<2> >,
+                                              meta::type_list<NumT<0>, NumT<3>, NumT<6> > >(),
+                    ApplyAllTest(is_called_array));
+    assert(std::all_of(is_called_array, is_called_array + 9, Identity()));
+  }
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_apply();
+  test_apply_all();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 20
+  static_assert(test());
+#endif
+
+  return 0;
+}
diff --git a/libcxx/test/support/test_iterators.h b/libcxx/test/support/test_iterators.h
--- a/libcxx/test/support/test_iterators.h
+++ b/libcxx/test/support/test_iterators.h
@@ -18,6 +18,7 @@
 #include <utility>
 
 #include "test_macros.h"
+#include "type_algorithms.h"
 
 
 // This iterator meets C++20's Cpp17OutputIterator requirements, as described
@@ -1297,6 +1298,34 @@
   requires std::ranges::viewable_range<R&&>
 ProxyRange(R&&) -> ProxyRange<std::views::all_t<R&&>>;
 
+namespace meta {
+template <class T>
+using random_access_iterator_list = type_list<T, contiguous_iterator<T>, random_access_iterator<T>>;
+
+template <class T>
+using proxy_random_access_iterator_list = wrap_list_t<ProxyIterator, random_access_iterator_list<T>>;
+
+template <class T>
+using bidirectional_iterator_list = concatenate_t<random_access_iterator_list<T>, bidirectional_iterator<T>>;
+
+template <class T>
+using proxy_bidirectional_iterator_list = wrap_list_t<ProxyIterator, bidirectional_iterator_list<T>>;
+
+template <class T>
+using forward_iterator_list = concatenate_t<bidirectional_iterator_list<T>, forward_iterator<T>>;
+
+template <class T>
+using proxy_forward_iterator_list = wrap_list_t<ProxyIterator, forward_iterator_list<T>>;
+
+template <class T>
+using cpp20_input_iterator_list =
+    concatenate_t<forward_iterator_list<T>, type_list<cpp20_input_iterator<T>, cpp17_input_iterator<T>>>;
+
+template <class T>
+using proxy_cpp20_input_iterator_list = wrap_list_t<ProxyIterator, cpp20_input_iterator_list<T>>;
+
+} // namespace meta
+
 #endif // TEST_STD_VER > 17
 
 #endif // SUPPORT_TEST_ITERATORS_H
diff --git a/libcxx/test/support/type_algorithms.h b/libcxx/test/support/type_algorithms.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/support/type_algorithms.h
@@ -0,0 +1,162 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_SUPPORT_TYPE_ALGORITHMS_H
+#define TEST_SUPPORT_TYPE_ALGORITHMS_H
+
+#include <type_traits>
+
+#include "test_macros.h"
+
+namespace meta {
+template <class... Types>
+struct type_list {};
+
+// concatenates
+// - T                   -> type_list<T>
+// - T, U                -> type_list<T, U>
+// - type_list<Ts...>    -> type_list<Ts...>
+// - type_list<Ts...>, T -> type_list<Ts..., T>
+// - N type_lists to one
+template <class...>
+struct concatenate;
+
+template <class... Types>
+using concatenate_t = typename concatenate<Types...>::type;
+
+// wrap_list wraps a template type (or alias) around every type of a type_list
+// i.e. Wrapper, type_list<int, long> -> type_list<Wrapper<int>, Wrapper<long>>
+template <template <class> class Wrapper, class...>
+struct wrap_list;
+
+template <template <class> class Wrapper, class TypeList>
+using wrap_list_t = typename wrap_list<Wrapper, TypeList>::type;
+
+// cartesian_product generates the cartesian product of two type_lists
+// TODO: Do we need the caresian product of N type_lists?
+template <class...>
+struct cartesian_product;
+
+template <class... Types>
+using cartesian_product_t = typename cartesian_product<Types...>::type;
+
+// apply calls f with the template arguments Types...
+template <class... Types, class Functor>
+TEST_CONSTEXPR_CXX14 void apply(type_list<Types...>, Functor f);
+
+// apply_all takes a type_list of type_lists and applies all the type_lists to f
+// If only a single type is required, the second type_list can be dropped.
+// i.e. type_list<int> and type_list<type_list<int>> are equivalent
+template <class... TypeLists, class Functor>
+TEST_CONSTEXPR_CXX14 void apply_all(type_list<TypeLists...>, Functor f);
+
+// impl
+template <class Type>
+struct concatenate<Type> {
+  using type = type_list<Type>;
+};
+
+template <class Type1, class Type2>
+struct concatenate<Type1, Type2> {
+  using type = type_list<Type1, Type2>;
+};
+
+template <class... Types>
+struct concatenate<type_list<Types...> > {
+  using type = type_list<Types...>;
+};
+
+template <class... Types, class Type>
+struct concatenate<type_list<Types...>, Type> {
+  using type = type_list<Types..., Type>;
+};
+
+template <class... Types1, class... Types2>
+struct concatenate<type_list<Types1...>, type_list<Types2...> > {
+  using type = type_list<Types1..., Types2...>;
+};
+
+template <class... Types1, class... Types2, class... Rest>
+struct concatenate<type_list<Types1...>, type_list<Types2...>, Rest...> {
+  using type = concatenate_t<type_list<Types1..., Types2...>, Rest...>;
+};
+
+template <template <class> class Wrapper, class... Types>
+struct wrap_list<Wrapper, type_list<Types...> > {
+  using type = type_list<Wrapper<Types>...>;
+};
+
+template <class...>
+struct cartesian_product_helper;
+
+template <class... TypeLists, class ConcatType>
+struct cartesian_product_helper<type_list<TypeLists...>, ConcatType> {
+  using type = type_list<concatenate_t<TypeLists, ConcatType>...>;
+};
+
+template <class... Types1, class... Types2>
+struct cartesian_product<type_list<Types1...>, type_list<Types2...> > {
+  using type = concatenate_t<typename cartesian_product_helper<type_list<Types1...>, Types2>::type...>;
+};
+
+template <class... Types, class Functor>
+TEST_CONSTEXPR_CXX14 void apply(type_list<Types...>, Functor f) {
+  (void)f.template operator()<Types...>();
+}
+
+template <class... Types>
+TEST_CONSTEXPR_CXX14 void swallow(Types...) {}
+
+template <class... TypeLists, class Functor>
+TEST_CONSTEXPR_CXX14 void apply_all(type_list<TypeLists...>, Functor f) {
+  swallow((meta::apply(concatenate_t<TypeLists>(), f), 0)...);
+}
+
+// type categories defined in [basic.fundamental] plus extensions
+
+using character_types =
+    type_list<char,
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+              wchar_t,
+#endif
+#ifndef TEST_HAS_NO_CHAR8_T
+              char8_t,
+#endif
+              char16_t,
+              char32_t>;
+
+using signed_integer_types =
+    type_list<short,
+              int,
+              long,
+              long long
+#ifndef TEST_HAS_NO_INT128
+              ,
+              __int128_t
+#endif
+              >;
+
+#if TEST_STD_VER < 14
+template <class T>
+using make_unsigned_t = typename std::make_unsigned<T>::type;
+#else
+using std::make_unsigned_t;
+#endif
+
+using unsigned_integer_types = wrap_list_t<make_unsigned_t, signed_integer_types>;
+
+using integer_types = concatenate_t<signed_integer_types, unsigned_integer_types>;
+
+using integral_types = concatenate_t<character_types, integer_types, bool>;
+
+using floating_point_types = type_list<float, double, long double>;
+
+using arithmetic_types = concatenate_t<integral_types, floating_point_types>;
+} // namespace meta
+
+#endif // TEST_SUPPORT_TYPE_ALGORITHMS_H