diff --git a/CMakeLists.txt b/CMakeLists.txt
index c6b41677..70d0a5af 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -87,5 +87,5 @@ if(CLICE_ENABLE_TEST)
         "${CMAKE_SOURCE_DIR}/src/Support/*.cpp"
     )
     file(GLOB_RECURSE TEST_SRC_FILES "${CMAKE_SOURCE_DIR}/tests/*/*.cpp")
-    target_sources(clice_test PRIVATE ${AST_SRC_FILES} ${TEST_SRC_FILES})
+    target_sources(clice_test PRIVATE ${AST_SRC_FILES} ${TEST_SRC_FILES} ${CMAKE_SOURCE_DIR}/tests/main.cpp)
 endif()
diff --git a/tests/AST/Resolver.cpp b/tests/AST/Resolver.cpp
index 41f83ded..22f9f1b8 100644
--- a/tests/AST/Resolver.cpp
+++ b/tests/AST/Resolver.cpp
@@ -1,4 +1,4 @@
-#include <gtest/gtest.h>
+#include "../Test.h"
 #include <Compiler/Resolver.h>
 
 namespace {
@@ -15,30 +15,28 @@ std::vector<const char*> compileArgs = {
 
 struct Visitor : public clang::RecursiveASTVisitor<Visitor> {
     clang::QualType result;
+    clang::QualType expect;
     std::unique_ptr<ParsedAST> parsedAST;
 
-    Visitor(const char* code) : parsedAST(ParsedAST::build("main.cpp", code, compileArgs)) {}
+    Visitor(llvm::StringRef content) : parsedAST(ParsedAST::build("main.cpp", content, compileArgs)) {}
 
     bool VisitTypeAliasDecl(clang::TypeAliasDecl* decl) {
         if(decl->getName() == "result") {
-            auto type = decl->getUnderlyingType();
-            {
-                clang::Sema::CodeSynthesisContext context;
-                context.Kind = clang::Sema::CodeSynthesisContext::TemplateInstantiation;
-                context.Entity = decl;
-                context.TemplateArgs = nullptr;
-                parsedAST->sema.pushCodeSynthesisContext(context);
-            }
-            auto resolver = TemplateResolver(parsedAST->sema);
-            result = resolver.resolve(type);
+            TemplateResolver resolver(parsedAST->sema);
+            result = resolver.resolve(decl->getUnderlyingType());
         }
+
+        if(decl->getName() == "expect") {
+            expect = decl->getUnderlyingType();
+        }
+
         return true;
     }
 
-    clang::QualType test() {
+    void test() {
         auto decl = parsedAST->context.getTranslationUnitDecl();
         TraverseDecl(decl);
-        return result;
+        EXPECT_EQ(result.getCanonicalType(), expect.getCanonicalType());
     }
 };
 
@@ -59,315 +57,24 @@ void match(clang::QualType type, std::string name, std::initializer_list<std::st
     }
 }
 
-TEST(DependentNameResolver, single_level_dependent_name) {
-    const char* code = R"(
-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;
-};
-
-)";
-    Visitor visitor(code);
-    auto result = visitor.test();
-    match(result, "type_list", {"X"});
-}
-
-TEST(DependentNameResolver, multi_level_dependent_name) {
-    const char* code = R"(
-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;
-};
-)";
-    Visitor visitor(code);
-    clang::QualType result = visitor.test();
-
-    match(result, "type_list", {"X"});
-}
-
-TEST(DependentNameResolver, dependent_dependent_dependent_name) {
-    const char* code = R"(
- 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;
- };
-)";
-    Visitor visitor(code);
-    clang::QualType result = visitor.test();
-
-    match(result, "type_list", {"X"});
-}
-
-TEST(DependentNameResolver, alias_dependent_name) {
-    const char* code = R"(
- 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;
- };
-)";
-    Visitor visitor(code);
-    clang::QualType result = visitor.test();
-    match(result, "type_list", {"X"});
-}
-
-TEST(DependentNameResolver, alias_template_dependent_name) {
-    const char* code = R"(
- 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;
- };
-)";
-    Visitor visitor(code);
-    clang::QualType result = visitor.test();
-    match(result, "type_list", {"X"});
-}
-
-TEST(DependentNameResolver, template_alias_dependent_name) {
-    const char* code = R"(
- template <typename ...Ts>
- struct type_list {};
-
- template <typename T1>
- struct A {
-     using type = type_list<T1>;
- };
-
- template <typename T2>
- using B = A<T2>;
-
- template <typename X>
- struct test {
-     using result = typename B<X>::type;
- };
-)";
-    Visitor visitor(code);
-    clang::QualType result = visitor.test();
-    match(result, "type_list", {"X"});
-}
-
-TEST(DependentNameResolver, dependent_member_template) {
-    const char* code = R"(
- 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>;
- };
-)";
-    Visitor visitor(code);
-    clang::QualType result = visitor.test();
-    match(result, "type_list", {"X", "Y"});
-}
-
-TEST(DependentNameResolver, dependent_member_class_template) {
-    const char* code = R"(
- template <typename... Ts>
- struct type_list {};
-
- template <typename T1>
- struct A {
-     template <typename U1>
-     struct B {
-         using type = type_list<T1, U1>;
-     };
- };
-
- template <typename X, typename Y>
- struct test {
-     using result = typename A<X>::template B<Y>::type;
- };
-)";
-
-    Visitor visitor(code);
-    clang::QualType result = visitor.test();
-    match(result, "type_list", {"X", "Y"});
-}
-
-TEST(DependentNameResolver, dependent_partial_name) {
-    const char* code = R"(
- 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;
- };
-)";
-
-    Visitor visitor(code);
-    clang::QualType result = visitor.test();
-    result.dump();
-}
-
-TEST(DependentNameResolver, dependent_base_name) {
-    const char* code = R"(
- 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;
- };
-)";
-
-    Visitor visitor(code);
-    auto result = visitor.test();
-
-    match(result, "type_list", {"X"});
-}
-
-TEST(DependentNameResolver, dependent_base_name_2) {
-    const char* code = R"(
- template <typename... Ts>
- struct type_list {};
-
- template <typename T1>
- struct A {
-     using type = type_list<T1>;
- };
-
- template <typename X>
- struct test {
-    using base = typename A<X>::type;
-    using result = base;
- };
-)";
-
-    Visitor visitor(code);
-    auto result = visitor.test();
-    llvm::outs() << "------------------------------------------\n";
-    result.dump();
-    match(result, "type_list", {"X"});
-}
-
-TEST(DependentNameResolver, std_vector) {
-    const char* code = R"(
-   #include <vector>
-
-   template <typename T>
-   struct A {};
-
-   template <typename X>
-   struct test {
-       using result = typename std::vector<X>::reference;
-   };
-)";
-
-    Visitor visitor(code);
-    clang::QualType result = visitor.test();
-    llvm::outs() << "result is: { " << result.getAsString() << " }\n";
-}
-
-TEST(DependentNameResolver, std_list) {
-    const char* code = R"(
-  #include <list>
-
-  template <typename T>
-  struct A {};
-
-  template <typename X>
-  struct test {
-      using result = typename std::list<A<X>>::reference;
-  };
-)";
-
-    Visitor visitor(code);
-    clang::QualType result = visitor.test();
-    llvm::outs() << "result is: { " << result.getAsString() << " }\n";
+TEST(clice, TemplateResolver) {
+    // FIXME: more flexible
+    auto path = test_dir() + "/TemplateResolver";
+    std::error_code error;
+    fs::directory_iterator iter(path, error);
+    fs::directory_iterator end;
+    while(!error && iter != end) {
+        auto file = iter->path();
+        llvm::outs() << "test: " << file << " " << error.message() << "\n";
+        auto buffer = llvm::MemoryBuffer::getFile(file);
+        if(!buffer) {
+            llvm::outs() << "failed to open file: " << buffer.getError().message() << file << "\n";
+        }
+        auto content = buffer.get()->getBuffer();
+        Visitor visitor(content);
+        visitor.test();
+        iter.increment(error);
+    }
 }
 
 }  // namespace
diff --git a/tests/AST/TreeTransform.cpp b/tests/AST/TreeTransform.cpp
deleted file mode 100644
index c5601e48..00000000
--- a/tests/AST/TreeTransform.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#include <gtest/gtest.h>
-#include <Compiler/Resolver.h>
-#include <clang/Sema/TreeTransform.h>
-
-namespace {
-
-using namespace clice;
-
-std::vector<const char*> compileArgs = {
-    "clang++",
-    "-std=c++20",
-    "main.cpp",
-    "-resource-dir",
-    "/home/ykiko/C++/clice2/build/lib/clang/20",
-};
-
-struct Visitor : public clang::RecursiveASTVisitor<Visitor> {
-    clang::QualType result;
-    std::unique_ptr<ParsedAST> parsedAST;
-
-    Visitor(const char* code) : parsedAST(ParsedAST::build("main.cpp", code, compileArgs)) {}
-
-    bool VisitTypeAliasDecl(clang::TypeAliasDecl* decl) {
-        if(decl->getName() == "result") {
-            TemplateResolver resolver(parsedAST->sema);
-            result = resolver.resolve(decl->getUnderlyingType());
-            result.dump();
-        }
-        return true;
-    }
-
-    clang::QualType test() {
-        clang::TypeLocBuilder builder;
-        auto decl = parsedAST->context.getTranslationUnitDecl();
-        TraverseDecl(decl);
-        return result;
-    }
-};
-
-TEST(Transform, test) {
-
-    const char* code = R"(
-template <typename ...Ts>
-struct type_list {};
-
-template <typename X, typename Y, typename Z = void>
-struct A {
-    using type = type_list<X, Y, Z>;
-};
-
-template <typename X, typename Y = type_list<X>>
-struct test {
-    using base = A<X, Y>;
-    using result = typename base::type;
-};
-
-)";
-
-    Visitor visitor(code);
-    auto result = visitor.test();
-}
-
-}  // namespace
-
diff --git a/tests/Source/TemplateResolver/alias-argument.cpp b/tests/Source/TemplateResolver/alias-argument.cpp
new file mode 100644
index 00000000..56a9d6d5
--- /dev/null
+++ b/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>;
+};
diff --git a/tests/Source/TemplateResolver/alias-dependent.cpp b/tests/Source/TemplateResolver/alias-dependent.cpp
new file mode 100644
index 00000000..d99dccfb
--- /dev/null
+++ b/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>;
+};
+
diff --git a/tests/Source/TemplateResolver/alias-template.cpp b/tests/Source/TemplateResolver/alias-template.cpp
new file mode 100644
index 00000000..122f8ca6
--- /dev/null
+++ b/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>;
+};
diff --git a/tests/Source/TemplateResolver/base-dependent.cpp b/tests/Source/TemplateResolver/base-dependent.cpp
new file mode 100644
index 00000000..b10128a6
--- /dev/null
+++ b/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>;
+};
diff --git a/tests/Source/TemplateResolver/multi-level.cpp b/tests/Source/TemplateResolver/multi-level.cpp
new file mode 100644
index 00000000..d5b31a4c
--- /dev/null
+++ b/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>;
+};
diff --git a/tests/Source/TemplateResolver/multi-nested.cpp b/tests/Source/TemplateResolver/multi-nested.cpp
new file mode 100644
index 00000000..6c33e6da
--- /dev/null
+++ b/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>;
+};
diff --git a/tests/Source/TemplateResolver/nested-template.cpp b/tests/Source/TemplateResolver/nested-template.cpp
new file mode 100644
index 00000000..ac72c563
--- /dev/null
+++ b/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>;
+};
diff --git a/tests/Source/TemplateResolver/partial-dependent.cpp b/tests/Source/TemplateResolver/partial-dependent.cpp
new file mode 100644
index 00000000..08061855
--- /dev/null
+++ b/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>;
+};
diff --git a/tests/Source/TemplateResolver/single-level.cpp b/tests/Source/TemplateResolver/single-level.cpp
new file mode 100644
index 00000000..7c7ec5ca
--- /dev/null
+++ b/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>;
+};
diff --git a/tests/Source/TemplateResolver/vector.cpp b/tests/Source/TemplateResolver/vector.cpp
new file mode 100644
index 00000000..56adbc6a
--- /dev/null
+++ b/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&;
+};
diff --git a/tests/Test.h b/tests/Test.h
new file mode 100644
index 00000000..cbed29d4
--- /dev/null
+++ b/tests/Test.h
@@ -0,0 +1,5 @@
+#include <gtest/gtest.h>
+
+#include <Support/FileSystem.h>
+
+std::string test_dir();
diff --git a/tests/main.cpp b/tests/main.cpp
new file mode 100644
index 00000000..ee85a7a0
--- /dev/null
+++ b/tests/main.cpp
@@ -0,0 +1,18 @@
+#include <gtest/gtest.h>
+#include <llvm/Support/CommandLine.h>
+
+llvm::cl::opt<std::string> test_dir_path("test-dir",
+                                         llvm::cl::desc("specify the test source directory path"),
+                                         llvm::cl::value_desc("path"),
+                                         llvm::cl::Required);
+
+std::string test_dir() {
+    return test_dir_path;
+}
+
+int main(int argc, char** argv) {
+    testing::InitGoogleTest(&argc, argv);
+    llvm::cl::ParseCommandLineOptions(argc, argv, "clice test\n");
+    return RUN_ALL_TESTS();
+}
+