cifa_unit_test.cpp

#include "../Cifa.h"
#include <chrono>
#include <filesystem>
#include <iostream>
#include <numeric>
#include <sstream>

using namespace cifa;

static double template_square(double x)
{
    return x * x;
}

static double template_add(double a, double b)
{
    return a + b;
}

static int template_trunc(double x)
{
    return int(x);
}

static void template_set_flag(Object flag)
{
    (void)flag;
}

static double template_menu(double x, double y, Object choices, double count)
{
    return x + y + count + (choices.hasValue() ? 0.0 : 1.0);
}

bool register_function_test()
{
    Cifa c1;
    c1.register_function("sin", [](ObjectVector& d)
        {
            return sin(d[0]);
        });

    std::string script_code = R"(
    double PI = 3.141592653589793238462643383279;
    double return_val = 0;
    return_val += sin(0);
    return_val += sin(PI * 0.5);
    return_val += sin(PI);
    return return_val;
    )";

    auto o = c1.run_script(script_code);
    if (o.hasValue() && o.isNumber() && o.isType<double>())
    {
        return (std::fabs(o.ref<double>() - 1.0) <= std::numeric_limits<double>::epsilon());
    }
    else
    {
        return false;
    }
}

bool register_function_template_test()
{
    Cifa c;
    c.register_function("square", template_square);
    c.register_function("add", template_add);
    c.register_function("trunc", template_trunc);
    c.register_function("set_flag", template_set_flag);

    auto o = c.run_script(R"(
        set_flag(1);
        return square(3) + add(2, 4) + trunc(1.8);
    )");
    return o.isNumber() && o.toDouble() == 16.0;
}

bool registration_name_validation_test()
{
    Cifa c;
    c.set_output_error(false);
    int context = 0;
    if (!c.register_function("valid_function", template_square)
        || !c.register_parameter("valid_parameter", 1)
        || !c.register_vector("valid_vector", std::vector<int>{ 1, 2 })
        || !c.register_user_data("valid_context", &context))
    {
        return false;
    }

    Cifa invalid;
    invalid.set_output_error(false);
    const bool template_registration_failed = !invalid.register_function("1bad", template_square)
        && invalid.has_runtime_error()
        && invalid.get_runtime_error().find("invalid registration name '1bad'") != std::string::npos;

    Cifa default_output;
    const bool standard_registration_failed = !default_output.register_parameter("bad-key", 1)
        && default_output.has_runtime_error()
        && default_output.get_runtime_error().find("invalid registration name 'bad-key'") != std::string::npos;

    return Cifa::is_valid_key("valid_key")
        && Cifa::is_valid_key("_value2")
        && !Cifa::is_valid_key("1bad")
        && !Cifa::is_valid_key("bad-key")
        && !Cifa::is_valid_key("return")
        && Cifa::revise_key("1bad-key") == "_bad_key"
        && Cifa::revise_key("return") == "return_"
        && Cifa::revise_key("") == "_"
        && template_registration_failed
        && standard_registration_failed;
}

bool exit_function_test()
{
    {
        Cifa c;
        c.run_script("value = 1; exit(); value = 2;");
        auto result = c.run_script("return value;");
        if (!result.isNumber() || result.toDouble() != 1.0)
        {
            return false;
        }
    }
    {
        Cifa c;
        c.run_script("count = 0; running = 1; while (running) { count++; exit(); count++; }");
        auto result = c.run_script("return count;");
        if (!result.isNumber() || result.toDouble() != 1.0)
        {
            return false;
        }
    }
    return true;
}

bool typed_function_argument_error_test()
{
    Cifa c;
    c.set_output_error(false);
    c.register_function("menu", template_menu);
    auto o = c.run_script("strs = {1, 2}; menu(85, 100, strs, strs);");
    return o.getSpecialType() == "Error"
        && c.get_runtime_error().find("variable 'strs'") != std::string::npos
        && c.get_runtime_error().find("to double") != std::string::npos;
}

bool object_vector_argument_error_test()
{
    const auto expect_conversion_error = [](const Cifa::func_type& menu, const std::string& target_type)
        {
            Cifa c;
            c.set_output_error(false);
            c.register_function("menu", menu);
            auto result = c.run_script("strs = {1, 2}; menu(85, 100, strs, strs);");
            return result.getSpecialType() == "Error"
                && c.get_runtime_error().find("variable 'strs'") != std::string::npos
                && c.get_runtime_error().find(target_type) != std::string::npos;
        };
    const auto expect_ref_error = []()
        {
            Cifa c;
            c.set_output_error(false);
            c.register_function("menu", [](ObjectVector& args) -> Object
                {
                    return Object(args[3].ref<ObjectMap>().size());
                });
            try
            {
                c.run_script("strs = {1, 2}; menu(85, 100, strs, strs);");
            }
            catch (const std::bad_any_cast&)
            {
                return c.get_runtime_error().find("variable 'strs'") != std::string::npos
                    && c.get_runtime_error().find(typeid(ObjectMap).name()) != std::string::npos;
            }
            return false;
        };

    return expect_conversion_error([](ObjectVector& args) -> Object
        {
            return Object(args[3].toDouble());
        }, "to double")
        && expect_conversion_error([](ObjectVector& args) -> Object
        {
            Object value = args[3];
            return Object(value.toDouble());
        }, "to double")
        && expect_conversion_error([](ObjectVector& args) -> Object
        {
            return Object(args[3].toString());
        }, "to string")
        && expect_ref_error();
}

bool builtin_math_function_test()
{
    Cifa c;
    auto o = c.run_script(R"(
        double total = 0;
        total += cbrt(27);
        total += log2(8);
        total += atan2(0, -1) > 3;
        total += hypot(3, 4);
        total += fmod(7, 4);
        total += remainder(7, 4);
        total += trunc(1.8);
        total += copysign(2, -1);
        total += fdim(5, 3);
        total += fmax(2, 5);
        total += fmin(2, 5);
        return total;
    )");
    return o.isNumber() && std::fabs(o.toDouble() - 22.0) < 1e-9;
}

bool builtin_type_function_test()
{
    Cifa c;
    auto o = c.run_script(R"(
        int empty_value;
        arr = {1, 2};
        m["x"] = 1;
        return type(empty_value) == "empty"
            && type(1) == "number"
            && type("abc") == "string"
            && type(arr) == "array"
            && type(m) == "map";
    )");
    return o.isNumber() && o.toDouble() == 1.0;
}

bool loop_math_test()
{
    Cifa c1;
    std::string script_code = R"(
    int i;
    double sum = 0.0, product = 1.0, division = 100.0, difference = 50.0;
    double total_result = 0.0;
    for (i = 1; i <= 5; i++) {
        sum += i;
    }
    while (i <= 6) {
        product *= i;
        i++;
    }
    do {
        difference -= i;
        i++;
    } while (difference > 0);
    division /= 5;
    total_result = sum + product + division + difference;
    return total_result;
    )";

    auto o = c1.run_script(script_code);
    if (o.hasValue() && o.isNumber() && o.isType<double>())
    {
        return (std::fabs(o.ref<double>() - 34) <= std::numeric_limits<double>::epsilon());
    }
    else
    {
        return false;
    }
}

bool loop_control_test()
{
    Cifa c;
    std::string script = R"(
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0) continue; // 跳过偶数
            if (i > 7) break;         // 遇到 9 跳出
            sum += i;
        }
        return sum; // 1 + 3 + 5 + 7 = 16
    )";
    auto o = c.run_script(script);
    return o.toInt() == 16;
}

bool ternary_operator_test()
{    // 测试嵌套三目运算
    Cifa c;
    std::string script = R"(
        int a = 1, b = 0;
        return a > b ? (b > a ? 10 : 20) : 30;
    )";
    auto o = c.run_script(script);
    return o.hasValue() && o.toInt() == 20;
}

bool logical_short_circuit_test()
{
    Cifa c;
    auto o = c.run_script(R"(
        int a = 0, b = 0, c = 0, d = 0;
        int first = (0 && a++) || (1 && (b++ == 0)) || c++;
        int second = (1 || d++) && (0 || (++d == 1));
        return a + b * 10 + c * 100 + d * 1000 + first * 10000 + second * 100000;
    )");
    return o.isNumber() && o.toInt() == 111010;
}

bool numeric_literal_radix_test()
{
    Cifa c;
    auto o = c.run_script(R"(
        return 42 + 1.5e2 + 0xFF + 0X10 + 0b1010 + 0B11 + 077;
    )");
    return o.isNumber() && o.toInt() == 539;
}

bool switch_case_test()
{    // Switch-Case 完备性测试
    Cifa c;
    std::string script = R"(
        int x = 2;
        int res = 0;
        switch(x) {
            case 1: res = 10; break;
            case 2: res = 20; // 故意不写break看看？
            case 3: res = 30; break;
            default: res = 40;
        }
        return res;
    )";
    auto o = c.run_script(script);
    return o.hasValue() && o.toInt() == 30;
}

bool recursion_test()
{    // 递归函数测试
    Cifa c;
    std::string script = R"(
        double factorial(double n) {
            if (n <= 1) return 1;
            return n * factorial(n - 1);
        }
        return factorial(5);
    )";
    auto o = c.run_script(script);
    return o.hasValue() && std::fabs(o.toDouble() - 120.0) < 1e-9;
}

bool script_function_argument_count_test()
{
    const auto expect_runtime_error = [](const char* label, const std::string& script, const std::string& expected)
        {
            Cifa c;
            c.set_output_error(false);
            const auto result = c.run_script(script);
            const std::string error = c.get_runtime_error();
            if (result.getSpecialType() != "Error" || error.find(expected) == std::string::npos)
            {
                std::cerr << "  " << label << " failed: expected runtime error: " << expected << "\n";
                std::cerr << "    actual: " << error << "\n";
                return false;
            }
            std::cerr << "  " << label << ": " << error << "\n";
            return true;
        };
    {
        Cifa c;
        auto result = c.run_script(
            "describe() { return 0; } "
            "describe(value) { return value; } "
            "describe(left, right) { return left + right; } "
            "return describe() + describe(2) + describe(3, 4);");
        if (!result.isNumber() || result.toDouble() != 9.0)
        {
            return false;
        }
    }
    {
        Cifa c;
        auto result = c.run_script("same(value) { return value; } same(other) { return other + 10; } return same(1);");
        if (!result.isNumber() || result.toDouble() != 11.0 || c.has_error())
        {
            return false;
        }
        result = c.run_script("same(number) { return number + 100; } return same(1);");
        if (!result.isNumber() || result.toDouble() != 101.0 || c.has_error())
        {
            return false;
        }
    }
    return expect_runtime_error("missing overload", "add(a, b) { return a + b; } return add(2);",
        "no overload for 1 arguments; available: 2")
        && expect_runtime_error("extra argument overload", "add(a, b) { return a + b; } return add(2, 3, 4);",
            "no overload for 3 arguments; available: 2")
        && [&]()
        {
            Cifa c;
            c.set_output_error(false);
            c.run_script("sqrt(value) { return value; }");
            const std::string errors = c.get_errors_str();
            return c.has_error() && errors.find("script function 'sqrt' conflicts with a host function") != std::string::npos
                && errors.find("^") != std::string::npos;
        }();
}

bool script_function_global_scope_test()
{
    Cifa c;
    c.set_output_error(false);
    int captured_value = 0;
    c.register_function("capture", [&captured_value](ObjectVector& args) -> Object
        {
            captured_value = args.empty() ? 0 : args[0].toInt();
            return Object();
        });
    auto program = c.compile_script(R"(
        b = 304;
        update_b() {
            capture(b);
            b = b + 1;
            return b;
        }
        result = update_b();
        return b * 1000 + result;
    )");
    if (!program)
    {
        return false;
    }
    auto global_result = c.run(program);
    if (!global_result.isNumber() || global_result.toInt() != 305305 || captured_value != 304)
    {
        return false;
    }

    auto next_script_result = c.run_script("return 7;");
    if (!next_script_result.isNumber() || next_script_result.toInt() != 7 || c.has_error())
    {
        return false;
    }

    auto persisted_function_result = c.run_script("b = 40; return update_b();");
    if (!persisted_function_result.isNumber() || persisted_function_result.toInt() != 41 || c.has_error())
    {
        return false;
    }

    auto broken = c.compile_script("broken() { return missing_function(); }");
    if (broken || !c.has_error())
    {
        return false;
    }
    auto after_failed_definition = c.run_script("return 8;");
    if (!after_failed_definition.isNumber() || after_failed_definition.toInt() != 8 || c.has_error())
    {
        return false;
    }

    auto shadow_result = c.run_script(R"(
        b = 10;
        add_one(b) {
            b = b + 1;
            return b;
        }
        result = add_one(20);
        return b * 100 + result;
    )");
    return shadow_result.isNumber() && shadow_result.toInt() == 1021;
}

bool string_operation_test()
{    // 字符串操作与拼接测试
    Cifa c;
    std::string script = R"(
        string s1 = "Hello ";
        string s2 = "World";
        return s1 + s2;
    )";
    auto o = c.run_script(script);
    return o.hasValue() && o.isType<std::string>() && o.toString() == "Hello World";
}

bool string_compare_test()
{    // 字符串比较与跨行逻辑运算测试
    Cifa c;
    std::string script = R"(
        return "abc" == "abc"
            && "abc" != "def";
    )";
    auto o = c.run_script(script);
    return o.isNumber() && o.toDouble() == 1.0;
}

bool bitwise_operator_test()
{    // 位运算测试
    Cifa c;
    std::string script = R"(
        int a = 5;      // 0101
        int b = 3;      // 0011
        int res1 = a & b;  // 0001 (1)
        int res2 = a | b;  // 0111 (7)
        int res3 = a ^ b;  // 0110 (6)
        int res4 = a << 1; // 1010 (10)
        return res1 + res2 + res3 + res4; // 1 + 7 + 6 + 10 = 24
    )";
    auto o = c.run_script(script);
    return o.toInt() == 24;
}

bool scope_shadowing_test()
{    // 变量作用域遮蔽测试
    Cifa c;
    std::string script = R"(
        int x = 10;
        {
            int x = 20;
            if (x == 20) {
                int x = 30;
            }
        }
        return x;
    )";
    auto o = c.run_script(script);
    return o.toInt() == 10;    // 外部作用域不应受内部干扰
}

bool complex_math_priority_test()
{    // 复杂算术优先级测试
    Cifa c;
    std::string script = R"(
        return 2 + 3 * 4 / (1 + 1) - 5 % 2; // 2 + 12 / 2 - 1 = 2 + 6 - 1 = 7
    )";
    auto o = c.run_script(script);
    return o.toInt() == 7;
}

bool same_precedence_left_assoc_test()
{    // 同优先级运算符应按 C++ 规则左结合，即 a/b*c == (a/b)*c，而非 a/(b*c)
    Cifa c;
    bool ok = true;
    // 除后乘：100/10*2 == 20
    ok = ok && c.run_script("return 100/10*2;").toInt() == 20;
    // 乘后除：100*10/2 == 500
    ok = ok && c.run_script("return 100*10/2;").toInt() == 500;
    // 除后模：100/10%3 == 1
    ok = ok && c.run_script("return 100/10%3;").toInt() == 1;
    // 模后除：10%4/2 == 1
    ok = ok && c.run_script("return 10%4/2;").toInt() == 1;
    // 减后加：10-3+1 == 8
    ok = ok && c.run_script("return 10-3+1;").toInt() == 8;
    // lW/2*lH/2 应等于 (lW/2*lH)/2，即 8/2*6/2==12
    ok = ok && c.run_script("double lW=8; double lH=6; return lW/2*lH/2;").toInt() == 12;
    return ok;
}

bool unary_minus_test()
{
    Cifa c;
    bool ok = true;
    ok = ok && c.run_script("return -5;").toDouble() == -5;           // 前置负号 + 常量
    ok = ok && c.run_script("return -(2+3);").toDouble() == -5;       // 前置负号 + 括号表达式
    ok = ok && c.run_script("return -(-3);").toDouble() == 3;         // 双重前置负号
    ok = ok && c.run_script("return 1 - -2;").toDouble() == 3;        // 二元减 + 前置负号
    ok = ok && c.run_script("return 10 - 3 - 2;").toDouble() == 5;    // 二元减左结合
    ok = ok && c.run_script("return -3 + 5;").toDouble() == 2;        // 前置负号 + 加法
    ok = ok && c.run_script("return 2 * -3;").toDouble() == -6;       // 乘以前置负号
    ok = ok && c.run_script("x = 7; return x * -1;").toDouble() == -7; // 变量乘以前置负号
    ok = ok && c.run_script("x = 7; x = x * -1; return x;").toDouble() == -7; // 赋值语境中的前置负号
    ok = ok && c.run_script("x = 7; return x * -1 + x * -2;").toDouble() == -21; // 连续乘法项
    ok = ok && c.run_script("return -(2*3);").toDouble() == -6;       // 前置负号 + 乘法括号
    ok = ok && c.run_script("return -2 + -3;").toDouble() == -5;      // 两个前置负号相加
    ok = ok && c.run_script("return +5;").toDouble() == 5;            // 前置正号 + 常量
    ok = ok && c.run_script("return +(2+3);").toDouble() == 5;        // 前置正号 + 括号表达式
    ok = ok && c.run_script("return 2 * +3;").toDouble() == 6;        // 乘以前置正号
    ok = ok && c.run_script("return 1 + +2;").toDouble() == 3;        // 二元加 + 前置正号
    return ok;
}

bool array_access_test()
{    // 数组/集合模拟测试 (假设Cifa支持类似[]的操作)
    Cifa c;
    std::string script = R"(
        //int arr[3];
        arr[0] = 10;
        {arr[1] = 20;}
        arr[2] = arr[0] + arr[1];
        return arr[2];
    )";
    auto o = c.run_script(script);
    return o.hasValue() && o.toInt() == 30;
}

bool array_literal_assignment_test()
{    // 数组字面量赋值测试
    Cifa c;
    std::string script = R"(
        array = {1,2,3,4,5};
        return array[0] + array[4];
    )";
    auto o = c.run_script(script);
    return o.hasValue() && o.toInt() == 6;
}

bool size_of_array_test()
{    // 数组大小测试
    Cifa c;
    std::string script = R"(
        array = {1,2,3,4,5};
        return size(array);
    )";
    auto o = c.run_script(script);
    return o.hasValue() && o.toInt() == 5;
}

bool register_vector_test()
{
    std::vector<double> v = { 1.2, 1.45, 77.3 };
    Cifa c;
    c.register_vector("v", v);
    std::string script = R"(
        return v[0] + v[1] + v[2];
    )";
    auto o = c.run_script(script);
    return o.hasValue() && o.toDouble() == std::accumulate(v.begin(), v.end(), 0.0);
}

bool register_map_test()
{
    Cifa c;
    c.register_parameter("cfg", std::map<std::string, double>{ { "width", 640 }, { "height", 480 } });
    // m["key"] syntax
    {
        auto o = c.run_script(R"( return cfg["width"] * cfg["height"]; )");
        if (!o.hasValue() || o.toDouble() != 640 * 480)
        {
            return false;
        }
    }
    // m::key syntax
    {
        auto o = c.run_script(R"( return cfg::width + cfg::height; )");
        if (!o.hasValue() || o.toDouble() != 640 + 480)
        {
            return false;
        }
    }
    return true;
}

bool type_promotion_test()
{
    //不区分整数和浮点数，此测试不增加特别处理不可能通过
    Cifa c;
    std::string script = R"(
        int a = 5;
        int b = 2;
        double res = floor(a / b);       // 整数除法，结果可能是 2.0
        double res2 = a / 2.0;    // 提升为浮点，结果应该是 2.5
        return res + res2;        // 4.5
    )";
    auto o = c.run_script(script);
    return std::fabs(o.toDouble() - 4.5) < 1e-9;
}

bool empty_statement_test()
{
    Cifa c;
    std::string script = R"(
        int x = 10;;;  // 多重分号
        if (x > 5) {}
        else ;
        while(false){;}
        for(;false;);
        return x;
    )";
    auto o = c.run_script(script);
    return o.toInt() == 10;
}

bool else_if_chain_test()
{
    Cifa c;
    const auto run_branch = [&c](int value)
        {
            return c.run_script(std::format(R"(
                int value = {};
                if (value == 3) {{ return 30; }}
                else if (value == 2) {{ return 20; }}
                else if (value == 1) {{ return 10; }}
                else {{ return 0; }}
            )", value));
        };

    return run_branch(3).toInt() == 30
        && run_branch(2).toInt() == 20
        && run_branch(1).toInt() == 10
        && run_branch(0).toInt() == 0;
}

bool multi_dimensional_array_test()
{
    Cifa c;
    std::string script = R"(
        grid = {{1, 2}, {3, 4}};
        grid[2][1] = 5;
        return grid[1][0] + grid[2][1];
    )";
    auto o = c.run_script(script);
    return o.toInt() == 8;
}

bool compound_assignment_test()
{
    Cifa c;
    std::string script = R"(
        int x = 10;
        x *= 2 + 3; // 应该是 10 * (2 + 3) = 50，而不是 10 * 2 + 3 = 23
        x %= 7;     // 50 % 7 = 1
        return x;
    )";
    auto o = c.run_script(script);
    return o.toInt() == 1;
}

bool c_string_library_test()
{
    Cifa c1;

    // 1. 注册 strlen: 返回字符串长度
    c1.register_function("strlen", [](ObjectVector& d) -> Object
        {
            if (d.empty() || !d[0].isType<std::string>())
            {
                return 0;
            }
            return (double)d[0].toString().length();
        });

    // 2. 注册 strcmp: 比较字符串
    c1.register_function("strcmp", [](ObjectVector& d) -> Object
        {
            if (d.size() < 2)
            {
                return 0;
            }
            int res = d[0].toString().compare(d[1].toString());
            // 标准化为 C 风格的 -1, 0, 1
            return (double)((res > 0) - (res < 0));
        });

    // 3. 注册 strcat: 拼接字符串
    c1.register_function("strcat", [](ObjectVector& d) -> Object
        {
            if (d.size() < 2)
            {
                return "";
            }
            return d[0].toString() + d[1].toString();
        });

    // 4. 注册 strcpy: 模拟赋值
    c1.register_function("strcpy", [](ObjectVector& d) -> Object
        {
            if (d.size() < 2)
            {
                return "";
            }
            return d[1];    // 将第二个参数赋值给第一个
        });

    std::string script_code = R"(
        string s1 = "Cifa";
        string s2 = "Language";
        // 测试 strlen
        int len = strlen(s1); // 4
        // 测试 strcmp
        int cmp_res = strcmp(s1, "Cifa"); // 0
        // 测试 strcat
        string combined = strcat(s1, s2); // "CifaLanguage"
        // 测试 strcpy 逻辑
        string target = "old";
        target = strcpy(target, "new");
        // 期望: 4 + 0 + 12 (combined长度) + 3 (new长度) = 19
        return len + cmp_res + strlen(combined) + strlen(target);
    )";

    auto o = c1.run_script(script_code);

    if (o.hasValue() && o.isNumber())
    {
        // 预期 4 + 0 + 12 + 3 = 19
        return o.toInt() == 19;
    }

    return false;
}

bool runtime_error_stack_test()
{    // 多层脚本函数调用中的运行时错误应传播到顶层。
    Cifa c;
    c.set_output_error(false);
    std::string script = R"(
        string bad = "abc";
        inner(value) { return sqrt(value); }
        middle(value) { return inner(value); }
        outer(value) { return middle(value); }
        return outer(bad);
    )";
    auto o = c.run_script(script);
    const std::string error = c.get_runtime_error();
    return o.getSpecialType() == "Error"
        && error.find("type conversion failed") != std::string::npos
        && error.find("Call Stack (most recent call last):") != std::string::npos
        && error.find("func inner()") != std::string::npos
        && error.find("func middle()") != std::string::npos
        && error.find("func outer()") != std::string::npos;
}

bool uninitialized_variable_runtime_test()
{
    Cifa c;
    auto o = c.run_script("double x; return x * 2;");
    return o.getSpecialType() == "Error"
        && c.get_runtime_error().find("variable 'x' has not been initialized") != std::string::npos;
}

bool nested_execution_state_test()
{
    Cifa c;
    c.set_output_error(false);
    auto success = c.run_script("shared = 10; run_string(\"shared += 1; return shared;\"); run_file(\"unit_test/test_data/nested_increment.cifa\"); return shared;");
    if (!success.isNumber() || success.toInt() != 21 || c.has_error())
    {
        return false;
    }

    c.run_script("run_string(\"return missing_nested_value;\"); return 1;");
    if (!c.has_error() || c.get_errors_str().find("missing_nested_value") == std::string::npos)
    {
        return false;
    }

    c.run_script("run_file(\"unit_test/test_data/not_present_nested.cifa\"); double outer_value; return outer_value;");
    return c.has_error()
        && c.get_errors_str().find("cannot open file") != std::string::npos
        && !c.get_runtime_error().empty()
        && c.get_runtime_error().find("double outer_value; return outer_value;") != std::string::npos;
}

bool nested_error_preservation_test()
{
    Cifa c;
    c.set_output_error(false);
    c.register_function("run_first", [&c](ObjectVector&) -> Object
        {
            return c.run_script("first_missing_function();");
        });
    c.register_function("run_second", [&c](ObjectVector&) -> Object
        {
            return c.run_script("second_missing_function();");
        });
    c.run_script("run_first(); run_second();");
    const std::string errors = c.get_errors_str();
    return c.get_errors().size() == 2
        && errors.find("first_missing_function") != std::string::npos
        && errors.find("second_missing_function") != std::string::npos;
}

    bool nested_static_error_source_test()
    {
        Cifa c;
        c.set_output_error(false);
        c.run_script("run_string(\"missing_nested_function();\");");
        const auto errors = c.get_errors();
        return errors.size() == 1
        && errors.front().message == "function 'missing_nested_function' is not defined"
        && errors.front().source_text == "missing_nested_function();"
        && c.get_errors_str().find("missing_nested_function();") != std::string::npos;
    }

bool mixed_array_literal_test()
{    // 混合类型数组字面量：数字、字符串混存
    Cifa c;
    std::string script = R"(
        arr = {1, "hello", 3.14, "world"};
        int i = 2;
        double n = arr[0];
        string s = arr[1];
        double f = arr[i];
        string s2 = arr[3];
        println(s + " " + s2, " ", to_string(f)); // 输出 "hello world 3.14"
        return n + f;  // 1 + 3.14 = 4.14
    )";
    auto o = c.run_script(script);
    return o.hasValue() && std::fabs(o.toDouble() - 4.14) < 1e-9;
}

// ---- 共用测试辅助函数 ----

// 断言脚本产生语法错误，且错误信息包含 keyword；同时验证输出带行号和 ^ 箭头
static bool expect_syntax_error(const std::string& label, const std::string& script, const std::string& keyword)
{
    Cifa c;
    c.set_output_error(false);
    c.run_script(script);
    std::string err = c.get_errors_str();
    std::cerr << "  [" << label << "]:\n";
    if (err.find("Syntax Error:") == std::string::npos || err.find(keyword) == std::string::npos)
    {
        std::cerr << "    FAIL: expected keyword \"" << keyword << "\" in error output\n";
        if (!err.empty()) { std::cerr << "    Got:\n"
                                      << err; }
        else { std::cerr << "    (no error produced)\n"; }
        return false;
    }
    if (err.find("^") == std::string::npos)
    {
        std::cerr << "    FAIL: missing caret (^) in error output\n";
        return false;
    }
    std::cerr << err;
    return true;
}

// 断言脚本不产生任何语法错误
static bool expect_no_syntax_error(const std::string& label, const std::string& script)
{
    Cifa c;
    c.set_output_error(false);
    c.run_script(script);
    std::string err = c.get_errors_str();
    std::cerr << "  [" << label << "]: ";
    if (!err.empty())
    {
        std::cerr << "FAIL unexpected error:\n"
                  << err;
        return false;
    }
    std::cerr << "OK\n";
    return true;
}

bool static_syntax_error_test()
{
    // 委托到文件级辅助函数
    auto expect_error = [](const std::string& label, const std::string& script, const std::string& keyword) -> bool
    {
        return expect_syntax_error(label, script, keyword);
    };
    auto expect_no_error = [](const std::string& label, const std::string& script) -> bool
    {
        return expect_no_syntax_error(label, script);
    };

    bool ok = true;

    // ==== 应触发静态错误的场景 ====

    // 1. 赋值右侧使用未初始化变量
    ok &= expect_error("uninitialized var in assign",
        R"(int y = undef;)",
        "not been initialized");

    // 2. 赋值右侧使用未初始化变量（多行，验证行号定位）
    ok &= expect_error("uninitialized var multiline",
        "int x = 10;\nint y = undef;\n",
        "not been initialized");

    // 3. 调用未定义的函数
    ok &= expect_error("undefined function",
        R"(return foo(1, 2);)",
        "not defined");

    // 4. 括号不匹配（右括号多余）
    ok &= expect_error("unpaired right paren",
        R"(int x = (1 + 2));)",
        "unpaired");

    // 5. 括号不匹配（左括号多余）
    ok &= expect_error("unpaired left paren",
        R"(int x = ((1 + 2);)",
        "unpaired");

    // 6. 赋值给常量
    ok &= expect_error("assign to constant",
        R"(123 = 5;)",
        "cannot be assigned");

    // 7. 赋值给字符串字面量
    ok &= expect_error("assign to string literal",
        "\"hello\" = 5;",
        "cannot be assigned");

    // 8. 独立的 else（没有对应的 if）
    ok &= expect_error("else without if",
        R"(else { int x = 1; })",
        "else has no if");

    // 9. 三元运算符缺少 :
    ok &= expect_error("ternary missing colon",
        R"(int x = 1; int y = x ? 10;)",
        "no :");

    // 10. 非法字符不能被静默忽略，避免 #strs 被解释为 strs
    {
        Cifa c;
        c.set_output_error(false);
        c.run_script("return menu(85, 100, strs, #strs);");
        std::string err = c.get_errors_str();
        if (err.find("unexpected character '#'") == std::string::npos
            || err.find("col 29") == std::string::npos)
        {
            std::cerr << "  FAIL [unexpected character]: expected '#' at column 29\n";
            std::cerr << "    Got:\n"
                      << err;
            ok = false;
        }
    }

    // 11. 错误定位验证：错误输出应包含 "<script>:2" 和 "undef"
    {
        Cifa c;
        c.set_output_error(false);
        c.run_script("int x = 10;\nint y = undef;\n");
        std::string err = c.get_errors_str();
        if (err.find("<script>:2") == std::string::npos || err.find("undef") == std::string::npos)
        {
            std::cerr << "  FAIL [error line number]: expected '<script>:2' and 'undef' in error output\n";
            std::cerr << "    Got:\n"
                      << err;
            ok = false;
        }
    }

    // ==== 不应触发静态错误的场景 ====

    // 11. 正常脚本
    ok &= expect_no_error("valid script",
        R"(int x = 10; int y = x + 5; return y;)");

    // 12. 正常 for 循环
    ok &= expect_no_error("valid for loop",
        R"(int s = 0; for (int i = 0; i < 5; i++) { s += i; } return s;)");

    // 13. 正常函数调用
    ok &= expect_no_error("valid function call",
        R"(return abs(-5);)");

    // 14. 正常数组操作
    ok &= expect_no_error("valid array",
        R"(arr = {1,2,3}; return arr[0] + arr[2];)");

    // 15. 正常字符串 Map
    ok &= expect_no_error("valid map",
        R"(dict["k"] = 42; return dict["k"];)");

    // 16. 正常三元运算符
    ok &= expect_no_error("valid ternary",
        R"(int x = 1; return x ? 10 : 20;)");

    // 17. 正常自定义函数
    ok &= expect_no_error("valid user function",
        "myfun(i) { return i * i; }\nreturn myfun(5);");

    // 18. 正常嵌套块
    ok &= expect_no_error("valid nested block",
        R"(int x = 1; { int y = x + 1; x = y; } return x;)");

    // ==== 深层未初始化变量检测 ====

    // 19. 表达式中嵌套使用未初始化变量（加法右侧）
    ok &= expect_error("uninitialized var in expr",
        R"(int x = 1; int y = x + undef;)",
        "not been initialized");

    // 20. 函数调用参数中使用未初始化变量
    ok &= expect_error("uninitialized var in func arg",
        R"(return abs(undef);)",
        "not been initialized");

    // 21. return 语句中使用未初始化变量
    ok &= expect_error("uninitialized var in return",
        R"(return undef;)",
        "not been initialized");

    // 22. 条件表达式中使用未初始化变量
    ok &= expect_error("uninitialized var in condition",
        R"(if (undef) { int x = 1; })",
        "not been initialized");

    // 23. 复合表达式中使用未初始化变量
    ok &= expect_error("uninitialized var in complex expr",
        R"(int x = 1; int y = (x * 2) + undef;)",
        "not been initialized");

    // 24. 正常：已初始化变量在表达式中使用不应报错
    ok &= expect_no_error("valid var in expr",
        R"(int x = 1; int y = 2; int z = x + y; return z;)");

    // 25. 正常：数组下标中使用已初始化变量不应报错
    ok &= expect_no_error("valid var in subscript",
        R"(arr = {10, 20, 30}; int i = 1; return arr[i];)");

    // ==== 空条件与死循环检测 ====

    // 26. if 空条件
    ok &= expect_error("if empty condition",
        R"(if () { int x = 1; })",
        "empty condition");

    // 27. while 空条件
    ok &= expect_error("while empty condition",
        R"(while () { int x = 1; })",
        "empty condition");

    // 28. while(1) 死循环
    ok &= expect_error("while(1) infinite loop",
        R"(while (1) { int x = 1; })",
        "infinite loop");

    // 29. while(true) 死循环
    ok &= expect_error("while(true) infinite loop",
        R"(while (true) { int x = 1; })",
        "infinite loop");

    // 30. for(;;) 死循环
    ok &= expect_error("for(;;) infinite loop",
        R"(for (;;) { int x = 1; })",
        "infinite loop");

    // 31. for(;1;) 死循环
    ok &= expect_error("for(;1;) infinite loop",
        R"(int i = 0; for (; 1; i++) { int x = 1; })",
        "infinite loop");

    // 32. 正常 while 不应报死循环
    ok &= expect_no_error("valid while loop",
        R"(int i = 0; while (i < 5) { i++; } return i;)");

    // 33. 正常 for 不应报死循环
    ok &= expect_no_error("valid for loop no warning",
        R"(int s = 0; for (int i = 0; i < 10; i++) { s += i; } return s;)");

    return ok;
}

bool string_key_map_test()
{    // 字符串下标（map 语义）测试
    Cifa c;
    std::string script = R"(
        dict["name"] = "Alice";
        dict["age"] = 30;
        dict["score"] = 95.5;
        string name = "name";
        string n = dict[name];
        string age = "age";
        double a = dict[age];
        string score = "score";
        double s = dict[score];
        println("Name: ", n, ", Age: ", a, ", Score: ", s);
        return a + s;  // 30 + 95.5 = 125.5
    )";
    auto o = c.run_script(script);
    if (!o.hasValue() || std::fabs(o.toDouble() - 125.5) > 1e-9)
    {
        return false;
    }

    // 访问不存在的 key 后尝试输出，应触发 runtime error
    Cifa c2;
    std::string script2 = R"(
        dict["name"] = "Alice";
        n1 = dict["name1"];
        println("Non-existent key: ", n1);
        return 0;
    )";
    auto o2 = c2.run_script(script2);
    return o2.getSpecialType() == "Error";
}

bool infinite_loop_protection_test()
{
    // while loop with variable condition (checker can't detect as infinite)
    {
        Cifa c1;
        c1.set_output_error(false);
        c1.max_loop_iterations = 100;
        auto o = c1.run_script("int x = 0; int go = 1; while(go) { x++; } return x;");
        if (o.getSpecialType() != "Error")
        {
            return false;
        }
    }
    // for loop with variable condition
    {
        Cifa c1;
        c1.set_output_error(false);
        c1.max_loop_iterations = 100;
        auto o = c1.run_script("int x = 0; int go = 1; for(; go;) { x++; } return x;");
        if (o.getSpecialType() != "Error")
        {
            return false;
        }
    }
    // do-while loop with variable condition
    {
        Cifa c1;
        c1.set_output_error(false);
        c1.max_loop_iterations = 100;
        auto o = c1.run_script("int x = 0; int go = 1; do { x++; } while(go); return x;");
        if (o.getSpecialType() != "Error")
        {
            return false;
        }
    }
    // infinite recursion should be stopped
    {
        Cifa c1;
        c1.max_call_depth = 10;
        auto o = c1.run_script("f(n) { return f(n); } return f(1);");
        if (o.getSpecialType() != "Error")
        {
            return false;
        }
    }
    // normal loops within limit should work fine
    {
        Cifa c1;
        c1.max_loop_iterations = 1000;
        auto o = c1.run_script("int s = 0; for(int i = 0; i < 500; i++) { s += i; } return s;");
        if (!o.hasValue() || o.toInt() != 124750)
        {
            return false;
        }
    }
    return true;
}

bool array_methods_test()
{
    // empty array via {}
    {
        Cifa c1;
        auto o = c1.run_script(R"(
            a = {};
            a.push_back(10);
            a.push_back(20);
            a.push_back(30);
            return size(a);
        )");
        if (!o.hasValue() || o.toInt() != 3)
        {
            return false;
        }
    }
    // empty array via int a[]
    {
        Cifa c1;
        auto o = c1.run_script(R"(
            int a[];
            a.push_back(1);
            a.push_back(2);
            return size(a);
        )");
        if (!o.hasValue() || o.toInt() != 2)
        {
            return false;
        }
    }
    // pop_back
    {
        Cifa c1;
        auto o = c1.run_script(R"(
            a = {1, 2, 3, 4, 5};
            a.pop_back();
            a.pop_back();
            return size(a);
        )");
        if (!o.hasValue() || o.toInt() != 3)
        {
            return false;
        }
    }
    // insert
    {
        Cifa c1;
        auto o = c1.run_script(R"(
            a = {1, 3, 4};
            a.insert(1, 2);
            return a[0] * 1000 + a[1] * 100 + a[2] * 10 + a[3];
        )");
        if (!o.hasValue() || o.toInt() != 1234)
        {
            return false;
        }
    }
    // erase
    {
        Cifa c1;
        auto o = c1.run_script(R"(
            a = {10, 20, 30, 40};
            a.erase(1);
            return a[0] * 100 + a[1] * 10 + a[2];
        )");
        if (!o.hasValue() || o.toInt() != 1340)
        {
            return false;
        }
    }
    // resize
    {
        Cifa c1;
        auto o = c1.run_script(R"(
            a = {1, 2, 3};
            a.resize(5);
            return size(a);
        )");
        if (!o.hasValue() || o.toInt() != 5)
        {
            return false;
        }
    }
    // clear
    {
        Cifa c1;
        auto o = c1.run_script(R"(
            a = {1, 2, 3};
            a.clear();
            return size(a);
        )");
        if (!o.hasValue() || o.toInt() != 0)
        {
            return false;
        }
    }
    // contains
    {
        Cifa c1;
        auto o = c1.run_script(R"(
            a = {10, 20, 30};
            int r1 = a.contains(20);
            int r2 = a.contains(99);
            return r1 * 10 + r2;
        )");
        if (!o.hasValue() || o.toInt() != 10)
        {
            return false;
        }
    }
    return true;
}

bool range_for_test()
{
    // 循环变量为值副本；修改不会回写数组元素。
    {
        Cifa c;
        auto o = c.run_script(R"(
            values = {1, 2, 3, 4};
            int sum = 0;
            for (int value : values) {
                value *= 10;
                if (value == 20) continue;
                if (value == 40) break;
                sum += value;
            }
            return sum + values[0] + values[1] + values[2] + values[3];
        )");
        if (!o.isNumber() || o.toDouble() != 50)
        {
            return false;
        }
    }
    // auto 形式与传统范围循环作用域。
    {
        Cifa c;
        auto o = c.run_script(R"(
            values = {2, 3, 5};
            int product = 1;
            for (auto value : values) { product *= value; }
            return product;
        )");
        if (!o.isNumber() || o.toDouble() != 30)
        {
            return false;
        }
    }
    return true;
}

bool goto_test()
{
    {
        Cifa c;
        auto result = c.run_script(R"(
            int value = 0;
        again:
            value += 1;
            if (value < 3) goto again;
            return value;
        )");
        if (!result.isNumber() || result.toDouble() != 3.0)
        {
            return false;
        }
    }
    {
        Cifa c;
        auto result = c.run_script(R"(
            int value = 0;
            if (value == 0) {
                value = 1;
            }
        label_after_if:
            value += 1;
            if (value < 3) { goto label_after_if; }
            return value;
        )");
        if (!result.isNumber() || result.toDouble() != 3.0)
        {
            return false;
        }
    }
    {
        Cifa c;
        auto result = c.run_script(R"(
            int value = 0;
            {
                value = 1;
                goto done;
            }
            value = 2;
        done:
            return value;
        )");
        if (!result.isNumber() || result.toDouble() != 1.0)
        {
            return false;
        }
    }
    {
        Cifa c;
        auto result = c.run_script(R"(
            count_to(limit) {
                int value = 0;
            again:
                value += 1;
                if (value < limit) goto again;
                return value;
            }
            return count_to(4);
        )");
        if (!result.isNumber() || result.toDouble() != 4.0)
        {
            return false;
        }
    }

    const auto expect_static_error = [](const std::string& script, const std::string& expected)
        {
            Cifa c;
            c.set_output_error(false);
            c.run_script(script);
            return c.has_error() && c.get_errors_str().find(expected) != std::string::npos;
        };
    return expect_static_error("goto missing;", "goto target 'missing' is not defined")
        && expect_static_error("first: first:", "duplicate label 'first'")
        && expect_static_error("goto inside; { inside: return 1; }", "goto 'inside' jumps into a nested or sibling block")
        && expect_static_error("{ left: goto right; } { right: return 1; }", "goto 'right' jumps into a nested or sibling block");
}

bool map_methods_test()
{
    // contains
    {
        Cifa c1;
        auto o = c1.run_script(R"(
            m["a"] = 1;
            m["b"] = 2;
            int r1 = m.contains("a");
            int r2 = m.contains("z");
            return r1 * 10 + r2;
        )");
        if (!o.hasValue() || o.toInt() != 10)
        {
            return false;
        }
    }
    // erase
    {
        Cifa c1;
        auto o = c1.run_script(R"(
            m["x"] = 10;
            m["y"] = 20;
            m["z"] = 30;
            m.erase("y");
            return size(m) * 100 + m.contains("x") * 10 + m.contains("y");
        )");
        if (!o.hasValue() || o.toInt() != 210)
        {
            return false;
        }
    }
    // clear
    {
        Cifa c1;
        auto o = c1.run_script(R"(
            m["a"] = 1;
            m["b"] = 2;
            m.clear();
            return size(m);
        )");
        if (!o.hasValue() || o.toInt() != 0)
        {
            return false;
        }
    }
    // keys
    {
        Cifa c1;
        auto o = c1.run_script(R"(
            m["alpha"] = 1;
            m["beta"] = 2;
            k = m.keys();
            return size(k);
        )");
        if (!o.hasValue() || o.toInt() != 2)
        {
            return false;
        }
    }
    return true;
}

bool non_block_branch_declaration_test()
{
    // 委托到文件级辅助函数，硬编码搜索关键词 "non-block"
    auto expect_error = [](const std::string& label, const std::string& script) -> bool
    {
        return expect_syntax_error(label, script, "non-block");
    };
    auto expect_no_error = [](const std::string& label, const std::string& script) -> bool
    {
        return expect_no_syntax_error(label, script);
    };

    bool ok = true;

    // ==== 应报错：非封闭体内定义变量（显式类型前缀）====

    // if 体内声明并初始化
    ok &= expect_error("if non-block init decl",
        R"(int a = 1; if (a) int x = 0;)");

    // if 体内仅声明（无初始化）
    ok &= expect_error("if non-block bare decl",
        R"(int a = 1; if (a) int x;)");

    // else 体内声明
    ok &= expect_error("else non-block decl",
        R"(int a = 1; if (a) a = 0; else int x = 1;)");

    // while 体内声明
    ok &= expect_error("while non-block decl",
        R"(int i = 5; while (i > 0) int x = i;)");

    // for 体内声明
    ok &= expect_error("for non-block decl",
        R"(for (int i = 0; i < 5; i++) int x = i;)");

    // ==== 应报错：非封闭体内引入新变量（无类型前缀，变量不在表中）====

    // if 体内引入全新变量（无 int 前缀，赋值形式）
    ok &= expect_error("if non-block new var no type",
        R"(int a = 1; if (a) newvar = 0;)");

    // if 体内裸引用未声明变量（x; 形式）
    ok &= expect_error("if non-block bare ref undeclared",
        R"(int a = 1; if (a) newvar;)");

    // while 体内引入全新变量
    ok &= expect_error("while non-block new var no type",
        R"(int i = 5; while (i > 0) newvar = i;)");

    // while 体内裸引用未声明变量
    ok &= expect_error("while non-block bare ref undeclared",
        R"(int i = 5; while (i > 0) newvar;)");

    // for 体内引入全新变量
    ok &= expect_error("for non-block new var no type",
        R"(int s = 0; for (int i = 0; i < 5; i++) newvar = i;)");

    // for 体内裸引用未声明变量
    ok &= expect_error("for non-block bare ref undeclared",
        R"(for (int i = 0; i < 5; i++) newvar;)");

    // ==== 应报错：switch case 体内引入新变量 ====

    ok &= expect_error("switch case non-block new var",
        R"(int x = 1; switch(x) { case 1: newvar = 10; break; })");

    ok &= expect_error("switch case non-block typed decl",
        R"(int x = 1; switch(x) { case 1: int y = 10; break; })");

    // ==== 不应报错：花括号体内定义变量合法 ====

    // if 加花括号
    ok &= expect_no_error("if block decl ok",
        R"(int a = 1; if (a) { int x = 0; })");

    // else 加花括号
    ok &= expect_no_error("else block decl ok",
        R"(int a = 1; if (a) { a = 0; } else { int x = 1; })");

    // while 加花括号
    ok &= expect_no_error("while block decl ok",
        R"(int i = 0; while (i < 3) { int x = i; i++; })");

    // for 加花括号
    ok &= expect_no_error("for block decl ok",
        R"(int s = 0; for (int i = 0; i < 5; i++) { int x = i; s += x; } return s;)");

    // switch case 内用 {} 包裹合法
    ok &= expect_no_error("switch case block decl ok",
        R"(int x = 1; switch(x) { case 1: { int y = 10; } break; })");

    // ==== 不应报错：非封闭体内赋值/引用已有变量合法 ====

    ok &= expect_no_error("if non-block assign ok",
        R"(int x = 0; int a = 1; if (a) x = 1; return x;)");

    // if 体内裸引用已声明变量：合法
    ok &= expect_no_error("if non-block bare ref declared ok",
        R"(int x = 0; int a = 1; if (a) x; return x;)");

    ok &= expect_no_error("else non-block assign ok",
        R"(int x = 0; int a = 0; if (a) x = 1; else x = 2; return x;)");

    ok &= expect_no_error("while non-block assign ok",
        R"(int i = 0; while (i < 3) i++; return i;)");

    ok &= expect_no_error("for non-block assign ok",
        R"(int s = 0; for (int i = 0; i < 5; i++) s += i; return s;)");

    // switch case 内赋值已有变量合法
    ok &= expect_no_error("switch case assign existing ok",
        R"(int x = 1; int r = 0; switch(x) { case 1: r = 10; break; default: r = 20; } return r;)");

    // else if 链（仅2层，无悬空 else）不应误报非封闭声明错误
    ok &= expect_no_error("else if chain ok",
        R"(int a = 2; int r = 0; if (a == 1) r = 10; else if (a == 2) r = 20; return r;)");

    return ok;
}

bool struct_test()
{
    // 基本字段读写
    {
        Cifa c;
        auto o = c.run_script(R"(
            struct Point { int x; int y; };
            Point p;
            p.x = 10;
            p.y = 20;
            return p.x + p.y;
        )");
        if (!o.isNumber() || o.toDouble() != 30)
        {
            return false;
        }
    }
    // struct 多字段
    {
        Cifa c;
        auto o = c.run_script(R"(
            struct Vec { int x; int y; int z; };
            Vec v;
            v.x = 1; v.y = 2; v.z = 3;
            return v.x * 100 + v.y * 10 + v.z;
        )");
        if (!o.isNumber() || o.toDouble() != 123)
        {
            return false;
        }
    }
    // struct 字段复合赋值
    {
        Cifa c;
        auto o = c.run_script(R"(
            struct Counter { int n; };
            Counter cnt;
            cnt.n = 5;
            cnt.n += 3;
            return cnt.n;
        )");
        if (!o.isNumber() || o.toDouble() != 8)
        {
            return false;
        }
    }
    // 函数中使用 struct
    {
        Cifa c;
        auto o = c.run_script(R"(
            struct Rect { int w; int h; };
            area(r) { return r.w * r.h; }
            Rect r;
            r.w = 4; r.h = 5;
            return area(r);
        )");
        if (!o.isNumber() || o.toDouble() != 20)
        {
            return false;
        }
    }
    // 全局 struct 定义在执行后注册到 Cifa，可供后续脚本使用
    {
        Cifa c;
        c.run_script("struct Point { int x; int y; };");
        auto o = c.run_script("Point p; p.x = 3; p.y = 7; return p.x + p.y;");
        if (!o.isNumber() || o.toDouble() != 10)
        {
            return false;
        }
    }
    return true;
}

bool sprintf_format_test()
{
    // --- sprintf ---
    // %s 字符串
    {
        Cifa c;
        auto o = c.run_script(R"(return sprintf("Hello %s!", "World");)");
        if (!o.isType<std::string>() || o.toString() != "Hello World!")
        {
            return false;
        }
    }
    // %d 整数和 %.2f 浮点
    {
        Cifa c;
        auto o = c.run_script(R"(return sprintf("%d + %.2f = %.2f", 3, 1.5, 4.5);)");
        if (!o.isType<std::string>() || o.toString() != "3 + 1.50 = 4.50")
        {
            return false;
        }
    }
    // 连续说明符和 %% 混用：%% 不消耗参数，其他说明符按顺序各消耗一个参数
    {
        Cifa c;
        auto o = c.run_script(R"(return sprintf("%s%d%.1f%%-%x", "A", 2, 3.5, 255);)");
        if (!o.isType<std::string>() || o.toString() != "A23.5%-ff")
        {
            return false;
        }
    }
    // %% 转义
    {
        Cifa c;
        auto o = c.run_script(R"(return sprintf("100%%");)");
        if (!o.isType<std::string>() || o.toString() != "100%")
        {
            return false;
        }
    }
    // 奇数个 %：前 12 个组成 6 个 %% ，末尾不完整的 % 被忽略；与 MSVC/UCRT 当前行为一致
    {
        Cifa c;
        auto o = c.run_script(R"(return sprintf("100%%%%%%%%%%%%%");)");
        if (!o.isType<std::string>() || o.toString() != "100%%%%%%")
        {
            return false;
        }
    }
    // %x 十六进制
    {
        Cifa c;
        auto o = c.run_script(R"(return sprintf("%x", 255);)");
        if (!o.isType<std::string>() || o.toString() != "ff")
        {
            return false;
        }
    }
    // %llu 多字母长度修饰符（用户显式写 ll，应正常工作）
    {
        Cifa c;
        auto o = c.run_script(R"(return sprintf("%llu", 12345);)");
        if (!o.isType<std::string>() || o.toString() != "12345")
        {
            return false;
        }
    }
    // %05.1f 宽度+精度（浮点，无长度修饰符）
    {
        Cifa c;
        auto o = c.run_script(R"(return sprintf("%08.2f", 3.14);)");
        if (!o.isType<std::string>() || o.toString() != "00003.14")
        {
            return false;
        }
    }
    // --- format ---
    // 自动 {}
    {
        Cifa c;
        auto o = c.run_script(R"(return format("Hello {}!", "World");)");
        if (!o.isType<std::string>() || o.toString() != "Hello World!")
        {
            return false;
        }
    }
    // 显式索引 {N}
    {
        Cifa c;
        auto o = c.run_script(R"(return format("{1} and {0}", "B", "A");)");
        if (!o.isType<std::string>() || o.toString() != "A and B")
        {
            return false;
        }
    }
    // 整数数字不带小数点
    {
        Cifa c;
        auto o = c.run_script(R"(return format("x = {}", 42);)");
        if (!o.isType<std::string>() || o.toString() != "x = 42")
        {
            return false;
        }
    }
    // 浮点数字
    {
        Cifa c;
        auto o = c.run_script(R"(return format("pi = {}", 3.14);)");
        if (!o.isType<std::string>() || o.toString() != "pi = 3.14")
        {
            return false;
        }
    }
    // {{ }} 转义
    {
        Cifa c;
        auto o = c.run_script(R"(return format("{{{}}}", "ok");)");
        if (!o.isType<std::string>() || o.toString() != "{ok}")
        {
            return false;
        }
    }
    // {:格式说明符} 自动索引
    {
        Cifa c;
        auto o = c.run_script(R"(return format("{:.2f}", 3.14159);)");
        if (!o.isType<std::string>() || o.toString() != "3.14")
        {
            return false;
        }
    }
    // {N:格式说明符} 显式索引
    {
        Cifa c;
        auto o = c.run_script(R"(return format("{0:d} / {1:.1f}", 7, 3.0);)");
        if (!o.isType<std::string>() || o.toString() != "7 / 3.0")
        {
            return false;
        }
    }
    // {:s} 字符串格式
    {
        Cifa c;
        auto o = c.run_script(R"(return format("{:s}", "hi");)");
        if (!o.isType<std::string>() || o.toString() != "hi")
        {
            return false;
        }
    }
    // {:.2} 无类型尾缀 — 数字按 %g 保留2位有效数字
    {
        Cifa c;
        auto o = c.run_script(R"(return format("{:.2}", 3.14159);)");
        if (!o.isType<std::string>() || o.toString() != "3.1")
        {
            return false;
        }
    }
    // {:>8} 无类型尾缀 — 字符串按 %s 右对齐（snprintf %s 不支持对齐，直接透传）
    {
        Cifa c;
        auto o = c.run_script(R"(return format("{:5}", 42);)");
        // 宽度5，数字补 g → "   42" 或 "42" 均可，只要不崩溃且包含 "42"
        if (!o.isType<std::string>() || o.toString().find("42") == std::string::npos)
        {
            return false;
        }
    }
    return true;
}

bool include_basic_test()
{
    Cifa c;
    auto o = c.run_file("unit_test/test_data/include_simple.cifa");
    return o.isNumber() && o.toDouble() == 15.0;
}

bool include_multi_file_test()
{
    Cifa c;
    auto o = c.run_file("unit_test/test_data/include_multi.cifa");
    return o.isNumber() && o.toDouble() == 17.0;
}

bool include_transitive_test()
{
    Cifa c;
    auto o = c.run_file("unit_test/test_data/c.cifa");
    return o.isNumber() && o.toDouble() == 201.0;
}

bool include_self_circular_test()
{
    Cifa c;
    c.set_output_error(false);
    auto o = c.run_file("unit_test/test_data/self.cifa");
    return o.isNumber() && o.toDouble() == 1.0;
}

bool include_mutual_circular_test()
{
    Cifa c;
    c.set_output_error(false);
    auto o = c.run_file("unit_test/test_data/cycle_a.cifa");
    return o.isNumber() && o.toDouble() == 1.0;
}

bool include_missing_file_test()
{
    Cifa c;
    c.set_output_error(false);
    auto o = c.run_file("unit_test/test_data/missing.cifa");
    return c.has_error();
}

bool include_subdir_test()
{
    Cifa c;
    auto o = c.run_file("unit_test/test_data/include_subdir.cifa");
    return o.isNumber() && o.toDouble() == 42.0;
}

bool include_angle_bracket_test()
{
    Cifa c;
    auto o = c.run_file("unit_test/test_data/angle_bracket.cifa");
    return o.isNumber() && o.toDouble() == 10.0;
}

bool include_function_from_file_test()
{
    Cifa c;
    auto o = c.run_file("unit_test/test_data/include_in_function.cifa");
    return o.isNumber() && o.toDouble() == 25.0;
}

bool include_backward_compat_test()
{
    Cifa c;
    auto o = c.run_script("return 1 + 2;");
    return o.isNumber() && o.toDouble() == 3.0;
}

bool include_with_parameters_test()
{
    Cifa c;
    c.register_parameter("base", Object(100.0));
    auto o = c.run_file("unit_test/test_data/with_params.cifa");
    return o.isNumber() && o.toDouble() == 110.0;
}

bool include_run_script_include_dir_test()
{
    Cifa c;
    c.set_include_dirs({ "unit_test/test_data" });
    std::string script = "#include \"simple.cifa\"\nint y = x + 5;\nreturn y;\n";
    auto o = c.run_script(script);
    return o.isNumber() && o.toDouble() == 15.0;
}

bool include_run_script_default_dir_test()
{
    Cifa c;
    std::string script = "#include \"unit_test/test_data/simple.cifa\"\nreturn x + 5;\n";
    auto o = c.run_script(script);
    return o.isNumber() && o.toDouble() == 15.0;
}

bool include_run_script_include_dir_multi_test()
{
    Cifa c;
    c.set_include_dirs({ "unit_test/test_data" });
    std::string script = "#include \"lib_math.cifa\"\nreturn square(3) + cube(2);\n";
    auto o = c.run_script(script);
    return o.isNumber() && o.toDouble() == 17.0;
}

bool include_run_script_include_dir_with_params_test()
{
    Cifa c;
    c.set_include_dirs({ "unit_test/test_data" });
    c.register_parameter("base", Object(100.0));
    std::string script = "return base + 10;\n";
    auto o = c.run_script(script);
    return o.isNumber() && o.toDouble() == 110.0;
}

bool include_multi_search_dirs_test()
{
    Cifa c;
    c.set_include_dirs({ "unit_test/test_data/missing_dir", "unit_test/test_data" });
    std::string script = "#include \"simple.cifa\"\nreturn x + 7;\n";
    auto o = c.run_script(script);
    return o.isNumber() && o.toDouble() == 17.0;
}

bool include_absolute_path_test()
{
    Cifa c;
    c.set_include_dirs({ "unit_test/test_data/missing_dir" });
    std::filesystem::path path = std::filesystem::absolute("unit_test/test_data/simple.cifa");
    std::string path_str = path.generic_string();
    std::string script = "#include \"" + path_str + "\"\nreturn x + 8;\n";
    auto o = c.run_script(script);
    return o.isNumber() && o.toDouble() == 18.0;
}

bool include_error_location_in_included_file_test()
{
    Cifa c;
    c.set_output_error(false);
    c.run_file("unit_test/test_data/include_bad_syntax.cifa");
    std::string errors = c.get_errors_str();
    auto error_list = c.get_errors();
    return errors.find("unit_test/test_data/bad_syntax_include.cifa:2") != std::string::npos
        && errors.find("int y = undef_from_include;") != std::string::npos
        && error_list.size() == 1
        && error_list[0].filename == "unit_test/test_data/bad_syntax_include.cifa"
        && error_list[0].line == 2;
}

bool include_error_location_after_include_test()
{
    Cifa c;
    c.set_output_error(false);
    c.run_file("unit_test/test_data/include_then_bad_main.cifa");
    std::string errors = c.get_errors_str();
    auto error_list = c.get_errors();
    return errors.find("unit_test/test_data/include_then_bad_main.cifa:3") != std::string::npos
        && errors.find("int b = undef_after_include;") != std::string::npos
        && error_list.size() == 1
        && error_list[0].filename == "unit_test/test_data/include_then_bad_main.cifa"
        && error_list[0].line == 3;
}

bool include_test()
{
    struct IncludeCase
    {
        const char* name;
        bool (*test)();
    };
    const IncludeCase cases[] = {
        { "basic", include_basic_test },
        { "multi file", include_multi_file_test },
        { "transitive", include_transitive_test },
        { "self circular", include_self_circular_test },
        { "mutual circular", include_mutual_circular_test },
        { "missing file", include_missing_file_test },
        { "subdirectory", include_subdir_test },
        { "angle bracket", include_angle_bracket_test },
        { "function from file", include_function_from_file_test },
        { "backward compatibility", include_backward_compat_test },
        { "with parameters", include_with_parameters_test },
        { "run_script include dir", include_run_script_include_dir_test },
        { "run_script default dir", include_run_script_default_dir_test },
        { "run_script include dir multi", include_run_script_include_dir_multi_test },
        { "run_script include dir with parameters", include_run_script_include_dir_with_params_test },
        { "multiple search directories", include_multi_search_dirs_test },
        { "absolute path", include_absolute_path_test },
        { "error location in included file", include_error_location_in_included_file_test },
        { "error location after include", include_error_location_after_include_test },
    };

    bool ok = true;
    for (const auto& include_case : cases)
    {
        if (!include_case.test())
        {
            std::cerr << "  include case failed: " << include_case.name << std::endl;
            ok = false;
        }
    }
    return ok;
}

double generated_perf_function_value(int function_index, int a, int b)
{
    double sum = 0;
    for (int j = 0; j < 3; ++j)
    {
        if ((a + j) % 2 != 0)
        {
            sum += a + b + function_index;
        }
        else
        {
            sum += a - b + function_index;
        }
    }
    return sum;
}

bool large_script_performance_test()
{
    constexpr int function_count = 1000;
    constexpr int calls = 300;
    std::ostringstream script;
    double expected = 0;

    for (int function_index = 0; function_index < function_count; ++function_index)
    {
        script << "perf_func_" << function_index << "(a, b) {\n";
        script << "    double sum = 0;\n";
        script << "    for (int j = 0; j < 3; j++) {\n";
        script << "        if ((a + j) % 2) {\n";
        script << "            sum += a + b + " << function_index << ";\n";
        script << "        } else {\n";
        script << "            sum += a - b + " << function_index << ";\n";
        script << "        }\n";
        script << "    }\n";
        script << "    return sum;\n";
        script << "}\n";
    }

    script << "double total = 0;\n";
    for (int call_index = 0; call_index < calls; ++call_index)
    {
        const int first_function = call_index % function_count;
        const int second_function = (call_index * 7 + 3) % function_count;
        const int argument_b = call_index % 19 + 1;
        if (call_index % 5 == 0)
        {
            script << "if (" << call_index << " % 5 == 0) { total += perf_func_" << first_function << "(" << call_index << ", " << argument_b << "); } else { total += perf_func_" << second_function << "(" << call_index << ", " << argument_b << "); }\n";
            expected += generated_perf_function_value(first_function, call_index, argument_b);
        }
        else
        {
            script << "if (" << call_index << " % 5 == 0) { total += perf_func_" << first_function << "(" << call_index << ", " << argument_b << "); } else { total += perf_func_" << second_function << "(" << call_index << ", " << argument_b << "); }\n";
            expected += generated_perf_function_value(second_function, call_index, argument_b);
        }
    }
    script << "return total;\n";

    Cifa c;
    c.set_output_error(false);
    const auto started = std::chrono::steady_clock::now();
    auto result = c.run_script(script.str());
    const auto elapsed = std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - started).count();

    std::cout << "large_script_performance_test: " << function_count << " script functions, " << calls << " call blocks, "
        << script.str().size() << " bytes in " << elapsed << " ms" << std::endl;
    if (result.getSpecialType() == "Error")
    {
        std::cerr << c.get_errors_str() << c.get_runtime_error() << std::endl;
        return false;
    }
    return result.isNumber() && std::fabs(result.toDouble() - expected) < 1e-9;
}

bool ast_execution_test()
{
    Cifa c;
    c.set_output_error(false);
    int total = 0;
    c.register_function("record", [&total](ObjectVector& arguments) -> Object
        {
            if (arguments.size() != 1 || !arguments[0].isNumber())
            {
                return Object();
            }
            total += arguments[0].toInt();
            return Object();
        });

    auto program = c.compile_script("entry_first: record(1); exit();\nentry_second: record(2); exit();\n");
    if (!program)
    {
        return false;
    }

    Ast moved_program = std::move(program);
    if (!moved_program)
    {
        return false;
    }
    program = std::move(moved_program);
    if (!program)
    {
        return false;
    }

    c.run(program, "entry_second");
    if (c.has_runtime_error() || total != 2)
    {
        return false;
    }

    c.run(program, "entry_first");
    if (c.has_runtime_error() || total != 3)
    {
        return false;
    }

    c.run(program);
    if (c.has_runtime_error() || total != 4)
    {
        return false;
    }

    c.run(program, "missing_entry");
    if (!c.has_runtime_error() || c.get_runtime_error().find("missing_entry") == std::string::npos)
    {
        return false;
    }

    auto file_program = c.compile_file("unit_test/test_data/include_simple.cifa");
    if (!file_program)
    {
        return false;
    }
    auto file_result = c.run(file_program);
    return program.valid() && file_result.isNumber() && file_result.toInt() == 15;
}

bool nested_ast_context_test()
{
    Cifa c;
    c.set_output_error(false);
    int total = 0;
    c.register_function("record", [&total](ObjectVector& arguments) -> Object
        {
            total += arguments[0].toInt();
            return Object();
        });
    Ast replacement;
    c.register_function("compile_replacement", [&c, &replacement](ObjectVector&) -> Object
        {
            replacement = c.compile_script("replacement: record(100); exit();");
            return Object(replacement.valid());
        });

    auto outer = c.compile_script("record(1); compile_replacement(); record(2); exit();");
    if (!outer)
    {
        return false;
    }
    c.run(outer);
    if (c.has_runtime_error() || total != 3)
    {
        return false;
    }

    c.run(replacement, "replacement");
    if (c.has_runtime_error() || total != 103)
    {
        return false;
    }

    c.run_script("record(10);");
    c.run(replacement, "replacement");
    return !c.has_runtime_error() && total == 213;
}

bool compiled_source_map_test()
{
    Cifa c;
    c.set_output_error(false);
    auto program = c.compile_script("double cached_value; return cached_value * 2;");
    if (!program)
    {
        return false;
    }
    c.run_script("return 1;");
    c.run(program);
    const std::string error = c.get_runtime_error();
    return error.find("variable 'cached_value' has not been initialized") != std::string::npos
        && error.find("double cached_value; return cached_value * 2;") != std::string::npos;
}

bool nested_ast_function_lookup_test()
{
    Cifa c;
    c.set_output_error(false);
    c.register_function("run_child", [&c](ObjectVector&) -> Object
        {
            return c.run_script("return value(5);");
        });
    auto result = c.run_script("value(n) { return n + 1; } return run_child();");
    return result.isNumber() && result.toInt() == 6 && !c.has_runtime_error();
}

bool global_definition_scope_test()
{
    Cifa c;
    c.set_output_error(false);

    auto nested_function = c.compile_script("if (1) { nested() { return 1; } }");
    if (nested_function
        || c.get_errors_str().find("script function 'nested' is only allowed in global scope") == std::string::npos)
    {
        return false;
    }

    auto nested_struct = c.compile_script("if (1) { struct Local { int value; }; }");
    if (nested_struct
        || c.get_errors_str().find("struct 'Local' is only allowed in global scope") == std::string::npos)
    {
        return false;
    }

    auto program = c.compile_script("global_fn(value) { return value + 1; } struct Global { int value; }; return 0;");
    if (!program)
    {
        return false;
    }
    c.run(program);
    auto global_definitions = c.run_script("Global item; item.value = 5; return global_fn(item.value);");
    if (!global_definitions.isNumber() || global_definitions.toInt() != 6)
    {
        return false;
    }

    c.run_script("global_value = 1; { local_value = 2; global_value = 3; }");
    auto global_value = c.run_script("return global_value;");
    if (!global_value.isNumber() || global_value.toInt() != 3)
    {
        return false;
    }
    c.run_script("return local_value;");
    return c.has_error() && c.get_errors_str().find("local_value") != std::string::npos;
}

bool nested_script_global_scope_test()
{
    Cifa c;
    c.set_output_error(false);
    c.register_function("run_child", [&c](ObjectVector&) -> Object
        {
            return c.run_script("child_global = 5; child_function() { return child_global + 1; } exit(); child_global = 99;");
        });

    auto outer_result = c.run_script("outer_global = 10; run_child(); outer_global += 1; return outer_global;");
    if (!outer_result.isNumber() || outer_result.toInt() != 11)
    {
        return false;
    }
    auto persisted_child = c.run_script("return child_global * 100 + child_function();");
    if (!persisted_child.isNumber() || persisted_child.toInt() != 506)
    {
        return false;
    }

    c.register_function("read_outer_local", [&c](ObjectVector&) -> Object
        {
            return c.run_script("return outer_local;");
        });
    c.run_script("{ outer_local = 7; read_outer_local(); }");
    return c.has_error() && c.get_errors_str().find("outer_local") != std::string::npos;
}

bool nested_runtime_reporter_test()
{
    Cifa outer;
    Cifa inner;
    outer.set_output_error(false);
    inner.set_output_error(false);
    outer.register_function("run_inner", [&inner](ObjectVector&) -> Object
        {
            inner.run_script("double inner_value; return inner_value * 2;");
            return Object();
        });

    outer.run_script("run_inner(); double outer_value; return outer_value * 2;");
    const std::string outer_error = outer.get_runtime_error();
    const std::string inner_error = inner.get_runtime_error();
    return outer_error.find("variable 'outer_value'") != std::string::npos
        && inner_error.find("variable 'inner_value'") != std::string::npos;
}

int main(int argc, char** argv)
{
    if (argc > 1 && (std::string(argv[1]) == "--perf" || std::string(argv[1]) == "--perf-large"))
    {
        return large_script_performance_test() ? 0 : 1;
    }

    int total = 0, ok = 0;
    auto run_test = [&total, &ok](std::string name, bool (*func)())
    {
        total++;
        if (func())
        {
            ok++;
            std::cout << "\xe2\x9c\x85 " << total << ". " << name << " success" << std::endl;
        }
        else
        {
            std::cout << "\xe2\x9d\x8c " << total << ". " << name << " failed" << std::endl;
        }
    };

    run_test("register_function_test", register_function_test);
    run_test("register_function_template_test", register_function_template_test);
    run_test("registration_name_validation_test", registration_name_validation_test);
    run_test("exit_function_test", exit_function_test);
    run_test("ast_execution_test", ast_execution_test);
    run_test("nested_ast_context_test", nested_ast_context_test);
    run_test("compiled_source_map_test", compiled_source_map_test);
    run_test("nested_ast_function_lookup_test", nested_ast_function_lookup_test);
    run_test("global_definition_scope_test", global_definition_scope_test);
    run_test("nested_script_global_scope_test", nested_script_global_scope_test);
    run_test("nested_runtime_reporter_test", nested_runtime_reporter_test);
    run_test("typed_function_argument_error_test", typed_function_argument_error_test);
    run_test("object_vector_argument_error_test", object_vector_argument_error_test);
    run_test("builtin_math_function_test", builtin_math_function_test);
    run_test("builtin_type_function_test", builtin_type_function_test);
    run_test("range_for_test", range_for_test);
    run_test("goto_test", goto_test);
    run_test("loop_math_test", loop_math_test);
    run_test("loop_control_test", loop_control_test);
    run_test("ternary_operator_test", ternary_operator_test);
    run_test("logical_short_circuit_test", logical_short_circuit_test);
    run_test("numeric_literal_radix_test", numeric_literal_radix_test);
    run_test("switch_case_test", switch_case_test);
    run_test("recursion_test", recursion_test);
    run_test("script_function_argument_count_test", script_function_argument_count_test);
    run_test("script_function_global_scope_test", script_function_global_scope_test);
    run_test("string_operation_test", string_operation_test);
    run_test("string_compare_test", string_compare_test);
    run_test("bitwise_operator_test", bitwise_operator_test);
    run_test("scope_shadowing_test", scope_shadowing_test);
    run_test("complex_math_priority_test", complex_math_priority_test);
    run_test("same_precedence_left_assoc_test", same_precedence_left_assoc_test);
    run_test("unary_minus_test", unary_minus_test);
    run_test("array_access_test", array_access_test);
    run_test("array_literal_assignment_test", array_literal_assignment_test);
    run_test("size_of_array_test", size_of_array_test);
    run_test("register_vector_test", register_vector_test);
    run_test("register_map_test", register_map_test);
    run_test("type_promotion_test", type_promotion_test);
    run_test("empty_statement_test", empty_statement_test);
    run_test("else_if_chain_test", else_if_chain_test);
    run_test("multi_dimensional_array_test", multi_dimensional_array_test);
    run_test("compound_assignment_test", compound_assignment_test);
    run_test("c_string_library_test", c_string_library_test);
    run_test("runtime_error_stack_test", runtime_error_stack_test);
    run_test("uninitialized_variable_runtime_test", uninitialized_variable_runtime_test);
    run_test("nested_execution_state_test", nested_execution_state_test);
    run_test("nested_error_preservation_test", nested_error_preservation_test);
    run_test("nested_static_error_source_test", nested_static_error_source_test);
    run_test("mixed_array_literal_test", mixed_array_literal_test);
    run_test("string_key_map_test", string_key_map_test);
    run_test("static_syntax_error_test", static_syntax_error_test);
    run_test("infinite_loop_protection_test", infinite_loop_protection_test);
    run_test("array_methods_test", array_methods_test);
    run_test("map_methods_test", map_methods_test);
    run_test("non_block_branch_declaration_test", non_block_branch_declaration_test);
    run_test("sprintf_format_test", sprintf_format_test);
    run_test("struct_test", struct_test);
    run_test("include_test", include_test);

    std::cout << "Passed " << ok << " out of " << total << " tests." << std::endl;
    return 0;
}