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,107 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 <cassert>
+#include <type_traits>
+
+#include "type_algorithms.h"
+
+// concatenate
+static_assert(std::is_same_v<meta::concatenate_t<int>, meta::type_list<int>>);
+static_assert(std::is_same_v<meta::concatenate_t<int, long>, meta::type_list<int, long>>);
+static_assert(std::is_same_v<meta::concatenate_t<meta::type_list<>>, meta::type_list<>>);
+static_assert(std::is_same_v<meta::concatenate_t<meta::type_list<int>>, meta::type_list<int>>);
+static_assert(std::is_same_v<meta::concatenate_t<meta::type_list<int>, long>, meta::type_list<int, long>>);
+static_assert(
+    std::is_same_v<meta::concatenate_t<meta::type_list<int>, meta::type_list<long>>, meta::type_list<int, long>>);
+static_assert(std::is_same_v<meta::concatenate_t<meta::type_list<int>, meta::type_list<long>, long long>,
+                             meta::type_list<int, long, long long>>);
+static_assert(
+    std::is_same_v<meta::concatenate_t<meta::type_list<int>, meta::type_list<long>, meta::type_list<long long>>,
+                   meta::type_list<int, long, long long>>);
+
+// wrap_list
+template <class T>
+struct Wrapper {};
+
+template <class T>
+using Wrap = Wrapper<T>;
+
+static_assert(
+    std::is_same_v<meta::wrap_list_t<Wrap, meta::type_list<int, long>>, meta::type_list< Wrapper<int>, Wrapper<long>>>);
+
+// cartesian_product
+static_assert(std::is_same_v<meta::cartesian_product_t<meta::type_list<int>, meta::type_list<long>>,
+                             meta::type_list<meta::type_list<int, long>>>);
+static_assert(std::is_same_v<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>>>);
+static_assert(
+    std::is_same_v<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>>>>);
+
+// apply
+constexpr void test_apply() {
+  meta::apply(meta::type_list<int, long>{}, []<class T, class U> {
+    static_assert(std::is_same_v<T, int> && std::is_same_v<U, long>);
+  });
+}
+
+// apply_all
+template <int N>
+class NumT {};
+
+struct ApplyAllTest {
+  int* last_call;
+
+  template <int N>
+  constexpr void check_num(NumT<N>) {
+    assert(++*last_call == N);
+  }
+
+  template <int N, int M>
+  constexpr void check_num(NumT<N>, NumT<M>) {
+    assert(++*last_call == N + M);
+  }
+
+  template <class... Types>
+  constexpr void operator()() {
+    check_num(Types{}...);
+  }
+};
+
+constexpr void test_apply_all() {
+  {
+    int last_call = -1;
+    meta::apply_all(meta::type_list<NumT<0>, NumT<1>, NumT<2>>{}, ApplyAllTest{&last_call});
+    assert(last_call == 2);
+  }
+
+  {
+    int last_call = -1;
+    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{&last_call});
+    assert(last_call == 8);
+  }
+}
+
+constexpr bool test() {
+  test_apply();
+  test_apply_all();
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  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