Refactor tests.

tests/Source/TemplateResolver/alias-argument.cpp

@@ -0,0 +1,19 @@
+template <typename... Ts>
+struct type_list {};
+
+template <typename T1>
+struct A {
+    using type = T1;
+};
+
+template <typename T2>
+struct B {
+    using base = A<T2>;
+    using type = type_list<typename base::type>;
+};
+
+template <typename X>
+struct test {
+    using result = typename B<X>::type;
+    using expect = type_list<X>;
+};

tests/Source/TemplateResolver/alias-dependent.cpp

@@ -0,0 +1,20 @@
+template <typename... Ts>
+struct type_list {};
+
+template <typename T1>
+struct A {
+    using type = type_list<T1>;
+};
+
+template <typename T2>
+struct B {
+    using base = A<T2>;
+    using type = typename base::type;
+};
+
+template <typename X>
+struct test {
+    using result = typename B<X>::type;
+    using expect = type_list<X>;
+};
+

tests/Source/TemplateResolver/alias-template.cpp

@@ -0,0 +1,19 @@
+template <typename... Ts>
+struct type_list {};
+
+template <typename T1, typename U1>
+struct A {
+    using type = type_list<T1, U1>;
+};
+
+template <typename T2>
+struct B {
+    template <typename U2>
+    using type = typename A<T2, U2>::type;
+};
+
+template <typename X, typename Y>
+struct test {
+    using result = typename B<X>::template type<Y>;
+    using expect = type_list<X, Y>;
+};

tests/Source/TemplateResolver/base-dependent.cpp

@@ -0,0 +1,16 @@
+template <typename... Ts>
+struct type_list {};
+
+template <typename T1>
+struct A {
+    using type = type_list<T1>;
+};
+
+template <typename U2>
+struct B : A<U2> {};
+
+template <typename X>
+struct test {
+    using result = typename B<X>::type;
+    using expect = type_list<X>;
+};

tests/Source/TemplateResolver/multi-level.cpp

@@ -0,0 +1,23 @@
+template <typename... Ts>
+struct type_list {};
+
+template <typename T1>
+struct A {
+    using type = type_list<T1>;
+};
+
+template <typename T2>
+struct B {
+    using type = typename A<T2>::type;
+};
+
+template <typename T3>
+struct C {
+    using type = typename B<T3>::type;
+};
+
+template <typename X>
+struct test {
+    using result = typename C<X>::type;
+    using expect = type_list<X>;
+};

tests/Source/TemplateResolver/multi-nested.cpp

@@ -0,0 +1,14 @@
+template <typename... Ts>
+struct type_list {};
+
+template <typename T1>
+struct A {
+    using self = A<T1>;
+    using type = type_list<T1>;
+};
+
+template <typename X>
+struct test {
+    using result = typename A<X>::self::self::self::self::self::type;
+    using expect = type_list<X>;
+};

tests/Source/TemplateResolver/nested-template.cpp

@@ -0,0 +1,19 @@
+template <typename... Ts>
+struct type_list {};
+
+template <typename T1>
+struct A {
+    template <typename T2>
+    struct B {
+        template <typename T3>
+        struct C {
+            using type = type_list<T1, T2, T3>;
+        };
+    };
+};
+
+template <typename X, typename Y, typename Z>
+struct test {
+    using result = typename A<X>::template B<Y>::template C<Z>::type;
+    using expect = type_list<X, Y, Z>;
+};

tests/Source/TemplateResolver/partial-dependent.cpp

@@ -0,0 +1,19 @@
+template <typename... Ts>
+struct type_list {};
+
+template <typename T1>
+struct A {};
+
+template <typename U2>
+struct B {};
+
+template <typename U2, template <typename...> typename HKT>
+struct B<HKT<U2>> {
+    using type = type_list<U2>;
+};
+
+template <typename X>
+struct test {
+    using result = typename B<A<X>>::type;
+    using expect = type_list<X>;
+};

tests/Source/TemplateResolver/single-level.cpp

@@ -0,0 +1,13 @@
+template <typename... Ts>
+struct type_list {};
+
+template <typename T>
+struct A {
+    using type = type_list<T>;
+};
+
+template <typename X>
+struct test {
+    using result = typename A<X>::type;
+    using expect = type_list<X>;
+};

tests/Source/TemplateResolver/vector.cpp

@@ -0,0 +1,7 @@
+#include <vector>
+
+template <typename T>
+struct test {
+    using result = typename std::vector<T>::reference;
+    using expect = T&;
+};