TEST

Author: HelloAIXIAOJI

examples/complex_function_pointer_test.cn

@@ -0,0 +1,121 @@
+using lib <io>;
+using ns std;
+
+// 复杂函数指针调用测试
+
+// 复杂的函数，包含多种语句类型
+fn complexCalculation(a : int, b : int) : int {
+    temp : int = a * 2;
+    if (temp > b) {
+        result : int = temp + b;
+        return result;
+    } else {
+        return a + b;
+    };
+};
+
+// 递归函数
+fn factorial(n : int) : int {
+    if (n <= 1) {
+        return 1;
+    } else {
+        return n * factorial(n - 1);
+    };
+};
+
+// 带局部变量的函数
+fn processNumbers(x : int, y : int) : int {
+    sum : int = x + y;
+    product : int = x * y;
+    
+    if (sum > product) {
+        return sum;
+    } else {
+        return product;
+    };
+};
+
+fn main() : int {
+    std::println("=== 复杂函数指针调用测试 ===");
+    std::println("");
+    
+    // 测试1：复杂函数的函数指针调用
+    testComplexFunctionPointer();
+    
+    // 测试2：递归函数指针调用
+    testRecursiveFunctionPointer();
+    
+    // 测试3：带局部变量的函数指针调用
+    testLocalVariableFunctionPointer();
+    
+    // 测试4：复杂Lambda函数
+    testComplexLambda();
+    
+    std::println("");
+    std::println("=== 复杂函数指针调用测试完成 ===");
+    return 0;
+};
+
+fn testComplexFunctionPointer() : void {
+    std::println("1. 复杂函数指针调用测试");
+    std::println("=======================");
+    
+    // 将复杂函数赋值给函数指针
+    complexFunc : *fn(int, int) : int = complexCalculation;
+    
+    result1 : int = complexFunc(5, 3);
+    std::println("complexFunc(5, 3) = " + result1);
+    
+    result2 : int = complexFunc(2, 10);
+    std::println("complexFunc(2, 10) = " + result2);
+    
+    std::println("");
+};
+
+fn testRecursiveFunctionPointer() : void {
+    std::println("2. 递归函数指针调用测试");
+    std::println("=======================");
+    
+    // 递归函数的函数指针
+    factFunc : *fn(int) : int = factorial;
+    
+    result1 : int = factFunc(5);
+    std::println("factFunc(5) = " + result1);
+    
+    result2 : int = factFunc(6);
+    std::println("factFunc(6) = " + result2);
+    
+    std::println("");
+};
+
+fn testLocalVariableFunctionPointer() : void {
+    std::println("3. 带局部变量的函数指针调用测试");
+    std::println("===============================");
+    
+    // 带局部变量的函数指针
+    processFunc : *fn(int, int) : int = processNumbers;
+    
+    result1 : int = processFunc(4, 6);
+    std::println("processFunc(4, 6) = " + result1);
+    
+    result2 : int = processFunc(8, 3);
+    std::println("processFunc(8, 3) = " + result2);
+    
+    std::println("");
+};
+
+fn testComplexLambda() : void {
+    std::println("4. 复杂Lambda函数测试");
+    std::println("=====================");
+    
+    // 复杂的Lambda表达式
+    complexLambda : *fn(int, int) : int = ((a, b) => a * a + b * b);
+    
+    result1 : int = complexLambda(3, 4);
+    std::println("complexLambda(3, 4) = " + result1);
+    
+    result2 : int = complexLambda(5, 12);
+    std::println("complexLambda(5, 12) = " + result2);
+    
+    std::println("");
+};

examples/debug_complex_step_test.cn

@@ -0,0 +1,42 @@
+using lib <io>;
+using ns std;
+
+// 逐步调试复杂函数
+
+// 第一步：带局部变量的函数
+fn stepOne(a : int, b : int) : int {
+    temp : int = a * 2;
+    return temp;
+};
+
+// 第二步：带局部变量和简单if的函数
+fn stepTwo(a : int, b : int) : int {
+    temp : int = a * 2;
+    if (temp >= 10) {
+        return temp;
+    } else {
+        return b;
+    };
+};
+
+fn main() : int {
+    std::println("=== 逐步调试复杂函数 ===");
+    
+    // 测试第一步
+    std::println("测试第一步：带局部变量");
+    step1Ptr : *fn(int, int) : int = stepOne;
+    result1 : int = step1Ptr(5, 3);
+    std::println("step1Ptr(5, 3) = " + result1);
+    
+    // 测试第二步
+    std::println("测试第二步：带局部变量和if");
+    step2Ptr : *fn(int, int) : int = stepTwo;
+    result2 : int = step2Ptr(5, 3);
+    std::println("step2Ptr(5, 3) = " + result2);
+    
+    result3 : int = step2Ptr(2, 3);
+    std::println("step2Ptr(2, 3) = " + result3);
+    
+    std::println("=== 测试完成 ===");
+    return 0;
+};

examples/debug_function_pointer_test.cn

@@ -0,0 +1,26 @@
+using lib <io>;
+using ns std;
+
+// 调试函数指针测试
+
+// 简单的复杂函数
+fn simpleComplex(a : int, b : int) : int {
+    temp : int = a + b;
+    return temp;
+};
+
+fn main() : int {
+    std::println("=== 调试函数指针测试 ===");
+    
+    // 直接调用函数
+    direct_result : int = simpleComplex(5, 3);
+    std::println("直接调用: simpleComplex(5, 3) = " + direct_result);
+    
+    // 通过函数指针调用
+    funcPtr : *fn(int, int) : int = simpleComplex;
+    ptr_result : int = funcPtr(5, 3);
+    std::println("函数指针调用: funcPtr(5, 3) = " + ptr_result);
+    
+    std::println("=== 测试完成 ===");
+    return 0;
+};

examples/debug_if_function_test.cn

@@ -0,0 +1,35 @@
+using lib <io>;
+using ns std;
+
+// 调试if语句函数指针测试
+
+// 带if语句的函数
+fn ifFunction(a : int, b : int) : int {
+    if (a > b) {
+        return a;
+    } else {
+        return b;
+    };
+};
+
+fn main() : int {
+    std::println("=== 调试if语句函数指针测试 ===");
+    
+    // 直接调用函数
+    direct_result1 : int = ifFunction(5, 3);
+    std::println("直接调用: ifFunction(5, 3) = " + direct_result1);
+    
+    direct_result2 : int = ifFunction(2, 7);
+    std::println("直接调用: ifFunction(2, 7) = " + direct_result2);
+    
+    // 通过函数指针调用
+    funcPtr : *fn(int, int) : int = ifFunction;
+    ptr_result1 : int = funcPtr(5, 3);
+    std::println("函数指针调用: funcPtr(5, 3) = " + ptr_result1);
+    
+    ptr_result2 : int = funcPtr(2, 7);
+    std::println("函数指针调用: funcPtr(2, 7) = " + ptr_result2);
+    
+    std::println("=== 测试完成 ===");
+    return 0;
+};

examples/debug_nested_var_test.cn

@@ -0,0 +1,37 @@
+using lib <io>;
+using ns std;
+
+// 调试嵌套变量声明
+
+// 带嵌套变量声明的函数
+fn nestedVarFunction(a : int, b : int) : int {
+    temp : int = a * 2;
+    if (temp > b) {
+        result : int = temp + b;
+        return result;
+    } else {
+        return a + b;
+    };
+};
+
+fn main() : int {
+    std::println("=== 调试嵌套变量声明 ===");
+    
+    // 直接调用
+    direct1 : int = nestedVarFunction(5, 3);
+    std::println("直接调用: nestedVarFunction(5, 3) = " + direct1);
+    
+    direct2 : int = nestedVarFunction(2, 10);
+    std::println("直接调用: nestedVarFunction(2, 10) = " + direct2);
+    
+    // 函数指针调用
+    funcPtr : *fn(int, int) : int = nestedVarFunction;
+    ptr1 : int = funcPtr(5, 3);
+    std::println("函数指针: funcPtr(5, 3) = " + ptr1);
+    
+    ptr2 : int = funcPtr(2, 10);
+    std::println("函数指针: funcPtr(2, 10) = " + ptr2);
+    
+    std::println("=== 测试完成 ===");
+    return 0;
+};

examples/debug_simple_twice_test.cn

@@ -0,0 +1,26 @@
+using lib <io>;
+using ns std;
+
+// 调试简单的两次调用测试
+
+fn simpleAdd(a : int, b : int) : int {
+    return a + b;
+};
+
+fn main() : int {
+    std::println("=== 调试简单的两次调用测试 ===");
+    
+    // 通过函数指针调用两次
+    funcPtr : *fn(int, int) : int = simpleAdd;
+    
+    std::println("第一次调用:");
+    result1 : int = funcPtr(5, 3);
+    std::println("funcPtr(5, 3) = " + result1);
+    
+    std::println("第二次调用:");
+    result2 : int = funcPtr(2, 7);
+    std::println("funcPtr(2, 7) = " + result2);
+    
+    std::println("=== 测试完成 ===");
+    return 0;
+};

examples/function_pointer_array_test.cn

@@ -0,0 +1,105 @@
+using lib <io>;
+using ns std;
+
+// 函数指针数组测试
+
+fn add(a : int, b : int) : int {
+    return a + b;
+};
+
+fn subtract(a : int, b : int) : int {
+    return a - b;
+};
+
+fn multiply(a : int, b : int) : int {
+    return a * b;
+};
+
+fn divide(a : int, b : int) : int {
+    if (b != 0) {
+        return a / b;
+    } else {
+        return 0;
+    };
+};
+
+fn main() : int {
+    std::println("=== 函数指针数组测试 ===");
+    std::println("");
+    
+    // 测试1：函数指针数组声明和初始化
+    testFunctionPointerArrayDeclaration();
+    
+    // 测试2：函数指针数组访问和调用
+    testFunctionPointerArrayAccess();
+    
+    // 测试3：Lambda函数指针数组
+    testLambdaFunctionPointerArray();
+    
+    std::println("");
+    std::println("=== 函数指针数组测试完成 ===");
+    return 0;
+};
+
+fn testFunctionPointerArrayDeclaration() : void {
+    std::println("1. 函数指针数组声明和初始化测试");
+    std::println("===============================");
+    
+    // 声明函数指针数组类型
+    operations : []*fn(int, int) : int = [add, subtract, multiply, divide];
+    
+    std::println("✓ 函数指针数组声明成功");
+    std::println("  数组包含4个数学运算函数指针");
+    std::println("");
+};
+
+fn testFunctionPointerArrayAccess() : void {
+    std::println("2. 函数指针数组访问和调用测试");
+    std::println("=============================");
+    
+    // 创建函数指针数组
+    operations : []*fn(int, int) : int = [add, subtract, multiply, divide];
+    
+    // 通过数组索引访问和调用函数指针
+    result1 : int = operations[0](10, 5);  // add
+    std::println("operations[0](10, 5) = " + result1);
+    
+    result2 : int = operations[1](10, 5);  // subtract
+    std::println("operations[1](10, 5) = " + result2);
+    
+    result3 : int = operations[2](10, 5);  // multiply
+    std::println("operations[2](10, 5) = " + result3);
+    
+    result4 : int = operations[3](10, 5);  // divide
+    std::println("operations[3](10, 5) = " + result4);
+    
+    std::println("");
+};
+
+fn testLambdaFunctionPointerArray() : void {
+    std::println("3. Lambda函数指针数组测试");
+    std::println("=========================");
+    
+    // 创建Lambda函数指针数组
+    lambdas : []*fn(int, int) : int = [
+        ((a, b) => a + b),
+        ((a, b) => a - b),
+        ((a, b) => a * b),
+        ((a, b) => a * a + b * b)
+    ];
+    
+    // 调用Lambda函数指针
+    result1 : int = lambdas[0](3, 4);
+    std::println("lambdas[0](3, 4) = " + result1);
+    
+    result2 : int = lambdas[1](3, 4);
+    std::println("lambdas[1](3, 4) = " + result2);
+    
+    result3 : int = lambdas[2](3, 4);
+    std::println("lambdas[2](3, 4) = " + result3);
+    
+    result4 : int = lambdas[3](3, 4);
+    std::println("lambdas[3](3, 4) = " + result4);
+    
+    std::println("");
+};