♻️ 使用module重构所有代码

2025-12-07 23:07:03 +08:00
parent 549f1d1b0a
commit f7d5a74615
369 changed files with 2272844 additions and 2202476 deletions
@@ -0,0 +1,220 @@
+module;
+
+export module lsp.test.lsp_any.common;
+
+import std;
+import lsp.test.framework;
+import lsp.protocol.common.basic_types;
+import lsp.codec.common;
+
+export namespace lsp::test
+{
+    namespace transform = lsp::codec;
+
+    class CommonTests
+    {
+    public:
+        static void registerTests(TestRunner& runner);
+
+    private:
+        static TestResult testIsLSPBasicInteger();
+        static TestResult testIsLSPBasicUInteger();
+        static TestResult testIsLSPBasicBoolean();
+        static TestResult testIsLSPBasicString();
+        static TestResult testIsLSPBasicDecimal();
+        static TestResult testIsLSPBasicNullptr();
+        static TestResult testIsLSPBasicNegativeCases();
+
+        static TestResult testIsLSPContainerObject();
+        static TestResult testIsLSPContainerArray();
+        static TestResult testIsLSPContainerAny();
+        static TestResult testIsLSPContainerNegativeCases();
+
+        static TestResult testIsUserStructPositive();
+        static TestResult testIsUserStructExcludeArithmetic();
+        static TestResult testIsUserStructExcludeString();
+        static TestResult testIsUserStructExcludeLSPTypes();
+        static TestResult testIsUserStructExcludeVector();
+        static TestResult testIsUserStructExcludeMap();
+        static TestResult testIsUserStructExcludeOptional();
+        static TestResult testIsUserStructExcludeVariant();
+        static TestResult testIsUserStructExcludePointers();
+    };
+}
+
+namespace lsp::test
+{
+    struct UserStruct
+    {
+        int value;
+        std::string name;
+    };
+
+    void CommonTests::registerTests(TestRunner& runner)
+    {
+        runner.addTest("Common - is_lsp_basic_type (integer)", testIsLSPBasicInteger);
+        runner.addTest("Common - is_lsp_basic_type (uinteger)", testIsLSPBasicUInteger);
+        runner.addTest("Common - is_lsp_basic_type (boolean)", testIsLSPBasicBoolean);
+        runner.addTest("Common - is_lsp_basic_type (string)", testIsLSPBasicString);
+        runner.addTest("Common - is_lsp_basic_type (decimal)", testIsLSPBasicDecimal);
+        runner.addTest("Common - is_lsp_basic_type (nullptr_t)", testIsLSPBasicNullptr);
+        runner.addTest("Common - is_lsp_basic_type (负面案例)", testIsLSPBasicNegativeCases);
+
+        runner.addTest("Common - is_lsp_container_type (LSPObject)", testIsLSPContainerObject);
+        runner.addTest("Common - is_lsp_container_type (LSPArray)", testIsLSPContainerArray);
+        runner.addTest("Common - is_lsp_container_type (LSPAny)", testIsLSPContainerAny);
+        runner.addTest("Common - is_lsp_container_type (负面案例)", testIsLSPContainerNegativeCases);
+
+        runner.addTest("Common - is_user_struct (用户结构体)", testIsUserStructPositive);
+        runner.addTest("Common - is_user_struct (排除算术类型)", testIsUserStructExcludeArithmetic);
+        runner.addTest("Common - is_user_struct (排除字符串)", testIsUserStructExcludeString);
+        runner.addTest("Common - is_user_struct (排除LSP类型)", testIsUserStructExcludeLSPTypes);
+        runner.addTest("Common - is_user_struct (排除vector)", testIsUserStructExcludeVector);
+        runner.addTest("Common - is_user_struct (排除map)", testIsUserStructExcludeMap);
+        runner.addTest("Common - is_user_struct (排除optional)", testIsUserStructExcludeOptional);
+        runner.addTest("Common - is_user_struct (排除variant)", testIsUserStructExcludeVariant);
+        runner.addTest("Common - is_user_struct (排除指针)", testIsUserStructExcludePointers);
+    }
+
+    TestResult CommonTests::testIsLSPBasicInteger()
+    {
+        TestResult result{ "", true, "成功" };
+        assertTrue(transform::is_lsp_basic_type_v<protocol::integer>, "integer应该是LSP基本类型");
+        return result;
+    }
+
+    TestResult CommonTests::testIsLSPBasicUInteger()
+    {
+        TestResult result{ "", true, "成功" };
+        assertTrue(transform::is_lsp_basic_type_v<protocol::uinteger>, "uinteger应该是LSP基本类型");
+        return result;
+    }
+
+    TestResult CommonTests::testIsLSPBasicBoolean()
+    {
+        TestResult result{ "", true, "成功" };
+        assertTrue(transform::is_lsp_basic_type_v<protocol::boolean>, "boolean应该是LSP基本类型");
+        return result;
+    }
+
+    TestResult CommonTests::testIsLSPBasicString()
+    {
+        TestResult result{ "", true, "成功" };
+        assertTrue(transform::is_lsp_basic_type_v<protocol::string>, "string应该是LSP基本类型");
+        return result;
+    }
+
+    TestResult CommonTests::testIsLSPBasicDecimal()
+    {
+        TestResult result{ "", true, "成功" };
+        assertTrue(transform::is_lsp_basic_type_v<protocol::decimal>, "decimal应该是LSP基本类型");
+        return result;
+    }
+
+    TestResult CommonTests::testIsLSPBasicNullptr()
+    {
+        TestResult result{ "", true, "成功" };
+        assertTrue(transform::is_lsp_basic_type_v<std::nullptr_t>, "nullptr应该是LSP基本类型");
+        return result;
+    }
+
+    TestResult CommonTests::testIsLSPBasicNegativeCases()
+    {
+        TestResult result{ "", true, "成功" };
+        assertFalse(transform::is_lsp_basic_type_v<std::vector<int>>, "vector<int>不应是基本类型");
+        assertFalse(transform::is_lsp_basic_type_v<UserStruct>, "用户结构体不应是基本类型");
+        return result;
+    }
+
+    TestResult CommonTests::testIsLSPContainerObject()
+    {
+        TestResult result{ "", true, "成功" };
+        assertTrue(transform::is_lsp_container_type_v<protocol::LSPObject>, "LSPObject应该是容器类型");
+        return result;
+    }
+
+    TestResult CommonTests::testIsLSPContainerArray()
+    {
+        TestResult result{ "", true, "成功" };
+        assertTrue(transform::is_lsp_container_type_v<protocol::LSPArray>, "LSPArray应该是容器类型");
+        return result;
+    }
+
+    TestResult CommonTests::testIsLSPContainerAny()
+    {
+        TestResult result{ "", true, "成功" };
+        assertTrue(transform::is_lsp_container_type_v<protocol::LSPAny>, "LSPAny应该是容器类型");
+        return result;
+    }
+
+    TestResult CommonTests::testIsLSPContainerNegativeCases()
+    {
+        TestResult result{ "", true, "成功" };
+        assertFalse(transform::is_lsp_container_type_v<int>, "int不是容器类型");
+        assertFalse(transform::is_lsp_container_type_v<std::vector<int>>, "vector<int>不是容器类型");
+        return result;
+    }
+
+    TestResult CommonTests::testIsUserStructPositive()
+    {
+        TestResult result{ "", true, "成功" };
+        assertTrue(transform::is_user_struct_v<UserStruct>, "UserStruct应该被识别为用户结构体");
+        return result;
+    }
+
+    TestResult CommonTests::testIsUserStructExcludeArithmetic()
+    {
+        TestResult result{ "", true, "成功" };
+        assertFalse(transform::is_user_struct_v<int>, "int不应被视为用户结构体");
+        return result;
+    }
+
+    TestResult CommonTests::testIsUserStructExcludeString()
+    {
+        TestResult result{ "", true, "成功" };
+        assertFalse(transform::is_user_struct_v<std::string>, "string不应被视为用户结构体");
+        return result;
+    }
+
+    TestResult CommonTests::testIsUserStructExcludeLSPTypes()
+    {
+        TestResult result{ "", true, "成功" };
+        assertFalse(transform::is_user_struct_v<protocol::LSPAny>, "LSPAny不应被视为用户结构体");
+        return result;
+    }
+
+    TestResult CommonTests::testIsUserStructExcludeVector()
+    {
+        TestResult result{ "", true, "成功" };
+        assertFalse(transform::is_user_struct_v<std::vector<int>>, "vector不应被视为用户结构体");
+        return result;
+    }
+
+    TestResult CommonTests::testIsUserStructExcludeMap()
+    {
+        TestResult result{ "", true, "成功" };
+        assertFalse(transform::is_user_struct_v<std::map<std::string, int>>, "map不应被视为用户结构体");
+        return result;
+    }
+
+    TestResult CommonTests::testIsUserStructExcludeOptional()
+    {
+        TestResult result{ "", true, "成功" };
+        assertFalse(transform::is_user_struct_v<std::optional<int>>, "optional不应被视为用户结构体");
+        return result;
+    }
+
+    TestResult CommonTests::testIsUserStructExcludeVariant()
+    {
+        TestResult result{ "", true, "成功" };
+        assertFalse(transform::is_user_struct_v<std::variant<int, double>>, "variant不应被视为用户结构体");
+        return result;
+    }
+
+    TestResult CommonTests::testIsUserStructExcludePointers()
+    {
+        TestResult result{ "", true, "成功" };
+        assertFalse(transform::is_user_struct_v<int*>, "指针不应被视为用户结构体");
+        return result;
+    }
+}