test.lua

-- test.lua — Cross-implementation compatibility tests for Lua 5.5
-- Run: swift run LuaREPL test.lua
--
-- POLICY: Only add tests that pass when run with the official Lua 5.5 reference
-- implementation (lua5.5 / lua). Do not add interpreter-specific extensions,
-- typed-syntax features, or other behaviour not in standard Lua 5.5 — use Swift
-- tests instead (e.g. Tests/LuaInterpreterTests/).

--------------------------------------------------------------------------------
-- Test harness
--------------------------------------------------------------------------------
local pass_count = 0
local fail_count = 0
local current_section = ""

local function section(name)
    current_section = name
    print("--- " .. name .. " ---")
end

local function test(description, condition)
    if condition then
        pass_count = pass_count + 1
    else
        fail_count = fail_count + 1
        print("  FAIL: " .. description)
    end
end

local function test_error(description, fn)
    local ok, err = pcall(fn)
    if not ok then
        pass_count = pass_count + 1
    else
        fail_count = fail_count + 1
        print("  FAIL (expected error): " .. description)
    end
end

;(function()
--------------------------------------------------------------------------------
-- 1. Literals and Types
--------------------------------------------------------------------------------
section("Literals and Types")

test("nil literal", type(nil) == "nil")
test("true literal", true == true)
test("false literal", false == false)
test("integer literal", 42 == 42)
test("negative integer", -1 == -1)
test("hex integer", 0xFF == 255)
test("float literal", 3.14 > 3.13 and 3.14 < 3.15)
test("float with exponent", 1e2 == 100.0)
test("hex float", 0x1p4 == 16.0)
test("double-quoted string", "hello" == "hello")
test("single-quoted string", 'world' == "world")
test("long string", [[long]] == "long")
test("long string level 1", [=[bracket]=] == "bracket")
test("empty string", "" == "")
test("string escape newline", "\n" ~= "n")
test("string escape tab", "\t" ~= "t")
test("string escape backslash", "\\" ~= "")

test("type of nil", type(nil) == "nil")
test("type of boolean", type(true) == "boolean")
test("type of integer", type(42) == "number")
test("type of float", type(3.14) == "number")
test("type of string", type("hi") == "string")
test("type of table", type({}) == "table")
test("type of function", type(print) == "function")

end)()

;(function()
--------------------------------------------------------------------------------
-- 2. Arithmetic Operators
--------------------------------------------------------------------------------
section("Arithmetic Operators")

-- Integer arithmetic
test("addition", 2 + 3 == 5)
test("subtraction", 10 - 4 == 6)
test("multiplication", 3 * 7 == 21)
test("floor division", 7 // 2 == 3)
test("modulo", 7 % 3 == 1)
test("power", 2 ^ 10 == 1024.0)
test("unary minus", -(5) == -5)

-- Float arithmetic
test("float addition", 1.5 + 2.5 == 4.0)
test("float division always float", type(10 / 3) == "number")
test("division result", 10 / 4 == 2.5)
test("float floor division", 7.0 // 2 == 3.0)
test("float modulo", 7.5 % 2.0 == 1.5)

-- Mixed int/float
test("int + float promotes", 1 + 1.0 == 2.0)
test("int * float promotes", 2 * 3.5 == 7.0)

-- String-to-number coercion in arithmetic
test("string + int coercion", "10" + 5 == 15)
test("string * string coercion", "3" * "4" == 12)

-- Negative floor division and modulo
test("negative floor div", -7 // 2 == -4)
test("negative modulo", -7 % 3 == 2)

end)()

;(function()
--------------------------------------------------------------------------------
-- 3. Comparison Operators
--------------------------------------------------------------------------------
section("Comparison Operators")

test("equal integers", 1 == 1)
test("not equal integers", 1 ~= 2)
test("less than", 1 < 2)
test("greater than", 3 > 2)
test("less or equal", 2 <= 2)
test("greater or equal", 3 >= 2)
test("int-float equality", 1 == 1.0)
test("int-float not equal", 1 ~= 1.5)

-- String comparisons
test("string equal", "abc" == "abc")
test("string not equal", "abc" ~= "def")
test("string less than", "abc" < "abd")
test("string greater than", "b" > "a")

-- Nil comparisons
test("nil == nil", nil == nil)
test("nil ~= false", nil ~= false)
test("nil ~= 0", nil ~= 0)

end)()

;(function()
--------------------------------------------------------------------------------
-- 4. Logical Operators
--------------------------------------------------------------------------------
section("Logical Operators")

test("true and true", (true and true) == true)
test("true and false", (true and false) == false)
test("false and true", (false and true) == false)
test("true or false", (true or false) == true)
test("false or true", (false or true) == true)
test("false or false", (false or false) == false)
test("not true", not true == false)
test("not false", not false == true)
test("not nil", not nil == true)

-- Short-circuit and value semantics
test("and returns first falsy", (nil and 5) == nil)
test("and returns last truthy", (1 and 2) == 2)
test("or returns first truthy", (1 or 2) == 1)
test("or returns last falsy", (false or nil) == nil)

-- Truthiness
test("0 is truthy", (0 and true) == true)
test("empty string is truthy", ("" and true) == true)
test("empty table is truthy", ({} and true) == true)

end)()

;(function()
--------------------------------------------------------------------------------
-- 5. Bitwise Operators
--------------------------------------------------------------------------------
section("Bitwise Operators")

test("bitwise and", 0xFF & 0x0F == 0x0F)
test("bitwise or", 0xF0 | 0x0F == 0xFF)
test("bitwise xor", 0xFF ~ 0x0F == 0xF0)
test("left shift", 1 << 4 == 16)
test("right shift", 16 >> 4 == 1)
test("bitwise not", ~0 == -1)
test("bitwise not of 1", ~1 == -2)

end)()

;(function()
--------------------------------------------------------------------------------
-- 6. String Operations
--------------------------------------------------------------------------------
section("String Operations")

test("concatenation", "hello" .. " " .. "world" == "hello world")
test("concat with number", "val=" .. 42 == "val=42")
test("concat with float", "pi=" .. 3.14 ~= "pi=")
test("length operator", #"hello" == 5)
test("empty string length", #"" == 0)
test("concat right-assoc", "a" .. "b" .. "c" == "abc")

end)()

;(function()
--------------------------------------------------------------------------------
-- 7. Variables and Scoping
--------------------------------------------------------------------------------
section("Variables and Scoping")

-- Global variables
x_global = 10
test("global assignment", x_global == 10)
x_global = 20
test("global reassignment", x_global == 20)

plain_implicit = 5
test("implicit global plain assignment", plain_implicit == 5)

-- Local variables
local a = 5
test("local variable", a == 5)

-- Multiple assignment
local m1, m2, m3 = 1, 2, 3
test("multiple assignment first", m1 == 1)
test("multiple assignment second", m2 == 2)
test("multiple assignment third", m3 == 3)

-- Fewer values than variables
local f1, f2 = 10
test("missing values are nil", f2 == nil)

-- Swap via multiple assignment
local sw1, sw2 = 1, 2
sw1, sw2 = sw2, sw1
test("swap via multiple assignment", sw1 == 2 and sw2 == 1)

-- Block scoping
do
    local inner = 99
    test("inner scope visible", inner == 99)
end
-- inner should not be visible here
test("outer scope unchanged", type(inner) == "nil" or inner == nil)

-- Variable shadowing
local shadow = 1
do
    local shadow = 2
    test("shadow in block", shadow == 2)
end
test("shadow restored", shadow == 1)

-- Const variable
local MAX <const> = 100
test("const variable readable", MAX == 100)

end)()

;(function()
--------------------------------------------------------------------------------
-- 8. Control Flow — if/elseif/else
--------------------------------------------------------------------------------
section("Control Flow — if/elseif/else")

local r1
if true then r1 = "yes" end
test("if true", r1 == "yes")

local r2
if false then r2 = "yes" else r2 = "no" end
test("if false else", r2 == "no")

local r3 = "none"
local val = 2
if val == 1 then r3 = "one"
elseif val == 2 then r3 = "two"
elseif val == 3 then r3 = "three"
else r3 = "other"
end
test("elseif chain", r3 == "two")

end)()

;(function()
--------------------------------------------------------------------------------
-- 9. Control Flow — while loop
--------------------------------------------------------------------------------
section("Control Flow — while loop")

local sum = 0
local i = 1
while i <= 5 do
    sum = sum + i
    i = i + 1
end
test("while loop sum 1..5", sum == 15)

-- While with break
local bk = 0
while true do
    bk = bk + 1
    if bk == 3 then break end
end
test("while break", bk == 3)

end)()

;(function()
--------------------------------------------------------------------------------
-- 10. Control Flow — repeat-until
--------------------------------------------------------------------------------
section("Control Flow — repeat-until")

local rp = 0
repeat
    rp = rp + 1
until rp >= 5
test("repeat until", rp == 5)

-- Repeat accesses loop body locals in condition
local rv = 0
repeat
    local x = rv + 1
    rv = x
until x == 3
test("repeat-until sees body locals", rv == 3)

end)()

;(function()
--------------------------------------------------------------------------------
-- 11. Control Flow — numeric for
--------------------------------------------------------------------------------
section("Control Flow — numeric for")

local nf_sum = 0
for i = 1, 5 do
    nf_sum = nf_sum + i
end
test("numeric for 1..5", nf_sum == 15)

-- With step
local nf_step = 0
for i = 0, 10, 2 do
    nf_step = nf_step + 1
end
test("numeric for with step", nf_step == 6) -- 0,2,4,6,8,10

-- Negative step
local nf_neg = 0
for i = 5, 1, -1 do
    nf_neg = nf_neg + i
end
test("numeric for negative step", nf_neg == 15)

-- Break in for
local nf_break = 0
for i = 1, 100 do
    if i > 3 then break end
    nf_break = nf_break + 1
end
test("numeric for with break", nf_break == 3)

-- Loop variable is local
do
    for j = 1, 1 do end
    test("for loop var is local", type(j) == "nil" or j == nil)
end

end)()

;(function()
--------------------------------------------------------------------------------
-- 12. Control Flow — generic for
--------------------------------------------------------------------------------
section("Control Flow — generic for")

-- ipairs
local arr = {10, 20, 30}
local ip_sum = 0
for i, v in ipairs(arr) do
    ip_sum = ip_sum + v
end
test("generic for ipairs", ip_sum == 60)

-- pairs
local dict = {a = 1, b = 2, c = 3}
local p_sum = 0
for k, v in pairs(dict) do
    p_sum = p_sum + v
end
test("generic for pairs", p_sum == 6)

end)()

do
--------------------------------------------------------------------------------
-- 13. Control Flow — goto and labels
--------------------------------------------------------------------------------
section("Control Flow — goto and labels")

local g = 0
g = g + 1
goto skip
g = g + 100
::skip::
g = g + 1
test("goto skips code", g == 2)

-- Goto forward over blocks
local g2 = "start"
goto done
do
    g2 = "should not reach"
end
::done::
test("goto forward over block", g2 == "start")

end

;(function()
--------------------------------------------------------------------------------
-- 14. Functions
--------------------------------------------------------------------------------
section("Functions")

-- Basic function
local function add(a, b)
    return a + b
end
test("function call", add(2, 3) == 5)

-- Recursive function
local function fib(n)
    if n <= 1 then return n end
    return fib(n - 1) + fib(n - 2)
end
test("recursion", fib(10) == 55)

-- Anonymous function
local mul = function(a, b) return a * b end
test("anonymous function", mul(3, 4) == 12)

-- Multiple return values
local function multi()
    return 1, 2, 3
end
local mr1, mr2, mr3 = multi()
test("multiple return first", mr1 == 1)
test("multiple return second", mr2 == 2)
test("multiple return third", mr3 == 3)

-- Varargs
local function vsum(...)
    local s = 0
    local args = {...}
    for i = 1, #args do
        s = s + args[i]
    end
    return s
end
test("varargs", vsum(1, 2, 3, 4) == 10)

-- Varargs with leading params
local function vfirst(first, ...)
    return first, select("#", ...)
end
local vf1, vf2 = vfirst(10, 20, 30)
test("vararg with leading param", vf1 == 10)
test("vararg count via select", vf2 == 2)

-- Higher-order function
local function apply(f, x)
    return f(x)
end
test("higher-order function", apply(function(x) return x * 2 end, 5) == 10)

end)()

;(function()
--------------------------------------------------------------------------------
-- 15. Closures
--------------------------------------------------------------------------------
section("Closures")

local function counter()
    local n = 0
    return function()
        n = n + 1
        return n
    end
end
local c = counter()
test("closure first call", c() == 1)
test("closure second call", c() == 2)
test("closure third call", c() == 3)

-- Shared state between closures
local function make_pair()
    local val = 0
    local function get() return val end
    local function set(v) val = v end
    return get, set
end
local get, set = make_pair()
test("closure shared state initial", get() == 0)
set(42)
test("closure shared state after set", get() == 42)

-- Independent closure instances
local c2 = counter()
test("independent closure", c2() == 1)
test("original closure preserved", c() == 4)

end)()

;(function()
--------------------------------------------------------------------------------
-- 16. Tables — Construction
--------------------------------------------------------------------------------
section("Tables — Construction")

local empty = {}
test("empty table", type(empty) == "table")
test("empty table length", #empty == 0)

local arr2 = {10, 20, 30}
test("array constructor", arr2[1] == 10 and arr2[2] == 20 and arr2[3] == 30)
test("array length", #arr2 == 3)

local rec = {x = 1, y = 2}
test("record constructor x", rec.x == 1)
test("record constructor y", rec.y == 2)

local mixed = {10, x = "a", 20, y = "b"}
test("mixed table array", mixed[1] == 10 and mixed[2] == 20)
test("mixed table record", mixed.x == "a" and mixed.y == "b")

local indexed = {[3] = "three", [1] = "one"}
test("indexed constructor", indexed[3] == "three" and indexed[1] == "one")

-- Trailing separator
local trail = {1, 2, 3,}
test("trailing comma", #trail == 3)

-- Semicolon separator
local semi = {1; 2; 3}
test("semicolon separator", #semi == 3)

end)()

;(function()
--------------------------------------------------------------------------------
-- 17. Tables — Access and Assignment
--------------------------------------------------------------------------------
section("Tables — Access and Assignment")

local t = {}
t.name = "lua"
test("field assignment", t.name == "lua")

t["key"] = "value"
test("bracket assignment", t["key"] == "value")

t[1] = "first"
test("integer key assignment", t[1] == "first")

-- Nested tables
local nested = {inner = {val = 42}}
test("nested field access", nested.inner.val == 42)

-- Nil for missing keys
test("missing key is nil", t.nonexistent == nil)

-- Delete by setting nil
t.name = nil
test("delete by nil", t.name == nil)

end)()

;(function()
--------------------------------------------------------------------------------
-- 18. Tables — Methods
--------------------------------------------------------------------------------
section("Tables — Methods")

local obj = {value = 10}
function obj:getValue()
    return self.value
end
function obj:setValue(v)
    self.value = v
end
test("method call get", obj:getValue() == 10)
obj:setValue(99)
test("method call set", obj:getValue() == 99)

-- Dot-name function definition
local mod = {}
function mod.greet(name)
    return "hi " .. name
end
test("dotted function name", mod.greet("lua") == "hi lua")

end)()

;(function()
--------------------------------------------------------------------------------
-- 19. Metatables — Arithmetic
--------------------------------------------------------------------------------
section("Metatables — Arithmetic")

local Vec = {}
Vec.__index = Vec

function Vec.new(x, y)
    return setmetatable({x = x, y = y}, Vec)
end

Vec.__add = function(a, b)
    return Vec.new(a.x + b.x, a.y + b.y)
end
Vec.__sub = function(a, b)
    return Vec.new(a.x - b.x, a.y - b.y)
end
Vec.__mul = function(a, b)
    if type(a) == "number" then return Vec.new(a * b.x, a * b.y) end
    if type(b) == "number" then return Vec.new(a.x * b, a.y * b) end
    return a.x * b.x + a.y * b.y -- dot product
end
Vec.__unm = function(a)
    return Vec.new(-a.x, -a.y)
end

local v1 = Vec.new(1, 2)
local v2 = Vec.new(3, 4)
local v3 = v1 + v2
test("__add", v3.x == 4 and v3.y == 6)
local v4 = v2 - v1
test("__sub", v4.x == 2 and v4.y == 2)
local v5 = v1 * 3
test("__mul scalar", v5.x == 3 and v5.y == 6)
local v6 = -v1
test("__unm", v6.x == -1 and v6.y == -2)

end)()

;(function()
--------------------------------------------------------------------------------
-- 20. Metatables — Comparison and Equality
--------------------------------------------------------------------------------
section("Metatables — Comparison and Equality")

local Num = {}
Num.__index = Num
function Num.new(v) return setmetatable({v = v}, Num) end
Num.__eq = function(a, b) return a.v == b.v end
Num.__lt = function(a, b) return a.v < b.v end
Num.__le = function(a, b) return a.v <= b.v end

local n1 = Num.new(5)
local n2 = Num.new(5)
local n3 = Num.new(10)
test("__eq true", n1 == n2)
test("__eq false", n1 ~= n3)
test("__lt true", n1 < n3)
test("__lt false", n3 < n1 == false)
test("__le true", n1 <= n2)

end)()

;(function()
--------------------------------------------------------------------------------
-- 21. Metatables — Index and Newindex
--------------------------------------------------------------------------------
section("Metatables — Index and Newindex")

-- __index as table (prototype chain)
local proto = {greet = function() return "hello" end}
local child = setmetatable({}, {__index = proto})
test("__index table lookup", child.greet() == "hello")

-- __index as function
local defaults = setmetatable({}, {
    __index = function(t, k)
        return "default:" .. k
    end
})
test("__index function", defaults.foo == "default:foo")

-- __newindex as function
local log = {}
local logged = setmetatable({}, {
    __newindex = function(t, k, v)
        log[#log + 1] = k
        rawset(t, k, v)
    end
})
logged.x = 1
logged.y = 2
test("__newindex function", #log == 2)
test("__newindex stored value", logged.x == 1)

end)()

;(function()
--------------------------------------------------------------------------------
-- 22. Metatables — Other
--------------------------------------------------------------------------------
section("Metatables — Other")

-- __len
local custom_len = setmetatable({}, {__len = function() return 42 end})
test("__len", #custom_len == 42)

-- __concat
local Str = {}
Str.__index = Str
function Str.new(s) return setmetatable({s = s}, Str) end
Str.__concat = function(a, b)
    local as = type(a) == "table" and a.s or a
    local bs = type(b) == "table" and b.s or b
    return Str.new(as .. bs)
end
local s1 = Str.new("hello")
local s2 = Str.new(" world")
local s3 = s1 .. s2
test("__concat", s3.s == "hello world")

-- __call
local callable = setmetatable({}, {
    __call = function(self, x)
        return x * 2
    end
})
test("__call", callable(5) == 10)

-- __tostring
local ts = setmetatable({}, {
    __tostring = function() return "custom_tostring" end
})
test("__tostring", tostring(ts) == "custom_tostring")

-- getmetatable / setmetatable
local mt = {}
local obj2 = setmetatable({}, mt)
test("getmetatable", getmetatable(obj2) == mt)

-- __metatable guard
local guarded = setmetatable({}, {__metatable = "protected"})
test("__metatable hides real mt", getmetatable(guarded) == "protected")
test_error("__metatable blocks setmetatable", function()
    setmetatable(guarded, {})
end)

end)()

;(function()
--------------------------------------------------------------------------------
-- 23. Error Handling
--------------------------------------------------------------------------------
section("Error Handling")

-- pcall success
local ok, val = pcall(function() return 42 end)
test("pcall success ok", ok == true)
test("pcall success value", val == 42)

-- pcall failure
local ok2, err2 = pcall(function() error("boom") end)
test("pcall failure ok", ok2 == false)
test("pcall failure message", type(err2) == "string")

-- pcall with args
local ok3, val3 = pcall(function(a, b) return a + b end, 10, 20)
test("pcall with args", ok3 == true and val3 == 30)

-- xpcall with handler
local ok4, val4 = xpcall(
    function() error("oops") end,
    function(e) return "handled: " .. e end
)
test("xpcall handler called", ok4 == false)
test("xpcall handler result", type(val4) == "string")

-- error with non-string
local ok5, val5 = pcall(function() error(123) end)
test("error with number", val5 == 123)

-- assert success
local ok6, val6 = pcall(function() return assert(42, "msg") end)
test("assert success", ok6 == true and val6 == 42)

-- assert failure
local ok7, err7 = pcall(function() assert(false, "fail msg") end)
test("assert failure", ok7 == false)

end)()

;(function()
--------------------------------------------------------------------------------
-- 24. Standard Library — type, tostring, tonumber
--------------------------------------------------------------------------------
section("Standard Library — Conversion")

test("tostring nil", tostring(nil) == "nil")
test("tostring true", tostring(true) == "true")
test("tostring false", tostring(false) == "false")
test("tostring int", tostring(42) == "42")
test("tostring float", tostring(3.5) == "3.5")
test("tostring string", tostring("hi") == "hi")

test("tonumber int string", tonumber("42") == 42)
test("tonumber float string", tonumber("3.14") == 3.14)
test("tonumber hex string", tonumber("0xFF") == 255)
test("tonumber nil for bad input", tonumber("abc") == nil)
test("tonumber identity int", tonumber(42) == 42)
test("tonumber with base", tonumber("ff", 16) == 255)
test("tonumber base 2", tonumber("1010", 2) == 10)

end)()

;(function()
--------------------------------------------------------------------------------
-- 25. Standard Library — select, unpack
--------------------------------------------------------------------------------
section("Standard Library — select, unpack")

test("select index", select(2, "a", "b", "c") == "b")
test("select count", select("#", "a", "b", "c") == 3)

local u1, u2, u3 = table.unpack({10, 20, 30})
test("table.unpack all", u1 == 10 and u2 == 20 and u3 == 30)
local u4, u5 = table.unpack({10, 20, 30}, 2, 3)
test("table.unpack range", u4 == 20 and u5 == 30)

end)()

;(function()
--------------------------------------------------------------------------------
-- 26. Standard Library — raw functions
--------------------------------------------------------------------------------
section("Standard Library — Raw Access")

local raw_t = setmetatable({}, {
    __index = function() return "meta" end,
    __newindex = function() end,
    __eq = function() return true end,
    __len = function() return 999 end
})

test("rawget bypasses __index", rawget(raw_t, "x") == nil)
rawset(raw_t, "x", 42)
test("rawset bypasses __newindex", rawget(raw_t, "x") == 42)
test("rawequal bypasses __eq", rawequal(raw_t, raw_t) == true)
test("rawequal different", rawequal(raw_t, {}) == false)
test("rawlen bypasses __len", rawlen({1, 2, 3}) == 3)

end)()

;(function()
--------------------------------------------------------------------------------
-- 27. Standard Library — String Library
--------------------------------------------------------------------------------
section("Standard Library — String")

test("string.len", string.len("hello") == 5)
test("string.len empty", string.len("") == 0)
test("string.sub", string.sub("hello", 2, 4) == "ell")
test("string.sub negative", string.sub("hello", -3) == "llo")
test("string.sub from start", string.sub("hello", 1, 1) == "h")
test("string.rep", string.rep("ab", 3) == "ababab")
test("string.rep with sep", string.rep("a", 3, ",") == "a,a,a")
test("string.reverse", string.reverse("hello") == "olleh")
test("string.upper", string.upper("hello") == "HELLO")
test("string.lower", string.lower("HELLO") == "hello")

-- byte and char
test("string.byte", string.byte("A") == 65)
test("string.byte with index", string.byte("ABC", 2) == 66)
test("string.char", string.char(65, 66, 67) == "ABC")

-- format
test("string.format %d", string.format("%d", 42) == "42")
test("string.format %s", string.format("%s", "hi") == "hi")
test("string.format %f", string.format("%.2f", 3.14) == "3.14")
test("string.format %x", string.format("%x", 255) == "ff")
test("string.format %%", string.format("100%%") == "100%")
test("string.format multiple", string.format("%s=%d", "x", 5) == "x=5")

-- find
local s, e = string.find("hello world", "world")
test("string.find found", s == 7 and e == 11)
local s2 = string.find("hello", "xyz")
test("string.find not found", s2 == nil)
local s3, e3 = string.find("hello", "ll", 1, true)
test("string.find plain", s3 == 3 and e3 == 4)

end)()

;(function()
--------------------------------------------------------------------------------
-- 28. Standard Library — Table Library
--------------------------------------------------------------------------------
section("Standard Library — Table")

-- insert and remove
local ti = {1, 2, 3}
table.insert(ti, 4)
test("table.insert append", ti[4] == 4 and #ti == 4)
table.insert(ti, 1, 0)
test("table.insert at pos", ti[1] == 0 and #ti == 5)

local removed = table.remove(ti)
test("table.remove last", removed == 4 and #ti == 4)
local removed2 = table.remove(ti, 1)
test("table.remove at pos", removed2 == 0 and #ti == 3)

-- concat
local tc = {"a", "b", "c"}
test("table.concat", table.concat(tc, ", ") == "a, b, c")
test("table.concat no sep", table.concat(tc) == "abc")
test("table.concat range", table.concat(tc, "-", 2, 3) == "b-c")

-- move
local src = {1, 2, 3, 4, 5}
local dst = {0, 0, 0, 0, 0}
table.move(src, 2, 4, 1, dst)
test("table.move", dst[1] == 2 and dst[2] == 3 and dst[3] == 4)

-- sort
local ts = {3, 1, 4, 1, 5, 9}
table.sort(ts)
test("table.sort ascending", ts[1] == 1 and ts[2] == 1 and ts[6] == 9)
local ts2 = {5, 3, 1, 4, 2}
table.sort(ts2)
test("table.sort default asc", ts2[1] == 1 and ts2[5] == 5)

-- unpack (table.unpack alias)
local tu1, tu2 = table.unpack({10, 20})
test("table.unpack", tu1 == 10 and tu2 == 20)

end)()

;(function()
--------------------------------------------------------------------------------
-- 29. Standard Library — Math Library
--------------------------------------------------------------------------------
section("Standard Library — Math")

-- Constants
test("math.pi", math.pi > 3.14 and math.pi < 3.15)
test("math.huge", math.huge > 1e308)
test("math.maxinteger", math.maxinteger > 0)
test("math.mininteger", math.mininteger < 0)

-- Basic functions
test("math.abs positive", math.abs(5) == 5)
test("math.abs negative", math.abs(-5) == 5)
test("math.ceil", math.ceil(2.3) == 3)
test("math.floor", math.floor(2.9) == 2)
test("math.max", math.max(1, 5, 3) == 5)
test("math.min", math.min(4, 1, 7) == 1)
test("math.sqrt", math.sqrt(16) == 4.0)

-- Trig
test("math.sin(0)", math.sin(0) == 0.0)
test("math.cos(0)", math.cos(0) == 1.0)
test("math.tan(0)", math.tan(0) == 0.0)

-- Exp and log
test("math.exp(0)", math.exp(0) == 1.0)
test("math.log(1)", math.log(1) == 0.0)
test("math.log with base", math.log(8, 2) == 3.0)

-- Integer conversion
test("math.tointeger from int", math.tointeger(5) == 5)
test("math.tointeger from float", math.tointeger(5.0) == 5)
test("math.tointeger non-int float", math.tointeger(5.5) == nil)

-- math.type
test("math.type integer", math.type(1) == "integer")
test("math.type float", math.type(1.0) == "float")
test("math.type non-number", math.type("x") == nil)

-- random (just ensure it doesn't error)
local r = math.random()
test("math.random [0,1)", r >= 0 and r < 1)
local ri = math.random(1, 10)
test("math.random range", ri >= 1 and ri <= 10)

end)()

;(function()
--------------------------------------------------------------------------------
-- 30. Iterators — pairs and ipairs
--------------------------------------------------------------------------------
section("Iterators — pairs and ipairs")

-- ipairs stops at first nil
local sparse = {1, 2, nil, 4}
local ip_count = 0
for _ in ipairs(sparse) do ip_count = ip_count + 1 end
test("ipairs stops at nil", ip_count == 2)

-- pairs visits all keys
local all = {a = 1, b = 2}
all[1] = "x"
local pair_keys = 0
for _ in pairs(all) do pair_keys = pair_keys + 1 end
test("pairs visits all", pair_keys == 3)

-- next function
local nt = {a = 1}
local k, v = next(nt)
test("next first", k == "a" and v == 1)
local k2 = next(nt, k)
test("next exhausted", k2 == nil)
test("next empty", next({}) == nil)

end)()

;(function()
--------------------------------------------------------------------------------
-- 31. Operator Precedence
--------------------------------------------------------------------------------
section("Operator Precedence")

test("mul before add", 2 + 3 * 4 == 14)
test("parens override", (2 + 3) * 4 == 20)
test("comparison over logical", true and 1 < 2 == true)
test("and before or", false and true or true == true)
test("not before and", not false and true == true)
test("unary minus vs power", -2 ^ 2 == -4.0)
test("power right-assoc", 2 ^ 2 ^ 3 == 256.0)
test("concat right-assoc result", "a" .. "b" .. "c" == "abc")

end)()

;(function()
--------------------------------------------------------------------------------
-- 32. Multiple Return Values — Edge Cases
--------------------------------------------------------------------------------
section("Multiple Return Values — Edge Cases")

local function two() return 1, 2 end

-- Only last expression expands
local t_multi = {two(), "x"}
test("multi-return truncated in middle", t_multi[1] == 1 and t_multi[2] == "x")

-- Last position expands
local t_multi2 = {"x", two()}
test("multi-return expands at end", t_multi2[1] == "x" and t_multi2[2] == 1 and t_multi2[3] == 2)

-- Multi-return in assignment
local p1, p2 = two()
test("multi-return assignment", p1 == 1 and p2 == 2)

end)()

;(function()
--------------------------------------------------------------------------------
-- 33. do-end Blocks
--------------------------------------------------------------------------------
section("Do-End Blocks")

local do_val = 1
do
    local do_val = 2
    test("do block inner scope", do_val == 2)
end
test("do block outer scope", do_val == 1)

end)()

;(function()
--------------------------------------------------------------------------------
-- 34. Empty Statement
--------------------------------------------------------------------------------
section("Empty Statement")

;; -- should parse fine
local es = 1;
test("empty statements parse", es == 1)

end)()

;(function()
--------------------------------------------------------------------------------
-- 35. Pattern Matching — string.find with patterns
--------------------------------------------------------------------------------
section("Pattern Matching — string.find")

-- Literal find still works
local fs, fe = string.find("hello world", "world")
test("find literal", fs == 7 and fe == 11)
test("find literal miss", string.find("hello", "xyz") == nil)

-- Plain mode
local ps, pe = string.find("hello%world", "%world", 1, true)
test("find plain with magic chars", ps == 6 and pe == 11)

-- Character classes
local ds, de = string.find("abc123def", "%d+")
test("find %d+", ds == 4 and de == 6)
local as1, ae1 = string.find("123abc", "%a+")
test("find %a+", as1 == 4 and ae1 == 6)

-- Anchored patterns
test("find ^anchor hit", string.find("hello", "^hello") == 1)
test("find ^anchor miss", string.find("say hello", "^hello") == nil)
local ds2, de2 = string.find("hello", "lo$")
test("find $anchor", ds2 == 4 and de2 == 5)
test("find $anchor miss", string.find("hello!", "hello$") == nil)

-- Captures returned by find
local fs2, fe2, cap1 = string.find("2025-04-06", "(%d+)-(%d+)-(%d+)")
test("find with captures start", fs2 == 1)

-- Dot matches any
local ds3, de3 = string.find("abc", "..")
test("find dot", ds3 == 1 and de3 == 2)

-- Init parameter
local is1, ie1 = string.find("abcabc", "abc", 2)
test("find with init", is1 == 4 and ie1 == 6)

end)()

;(function()
--------------------------------------------------------------------------------
-- 36. Pattern Matching — string.match
--------------------------------------------------------------------------------
section("Pattern Matching — string.match")

-- No captures: returns whole match
test("match whole", string.match("hello world", "%a+") == "hello")
test("match digits", string.match("abc123", "%d+") == "123")
test("match miss", string.match("hello", "%d") == nil)

-- Single capture
test("match single capture", string.match("hello", "(el)") == "el")

-- Multiple captures
local y, m, d = string.match("2025-04-06", "(%d+)-(%d+)-(%d+)")
test("match year", y == "2025")
test("match month", m == "04")
test("match day", d == "06")

-- Character classes
test("match %a", string.match("123abc", "%a+") == "abc")
test("match %l", string.match("Hello", "%l+") == "ello")
test("match %u", string.match("helloWorld", "%u%a*") == "World")
test("match %w", string.match("hi there", "%w+") == "hi")
test("match %s", string.match("hello world", "%s+") == " ")
test("match %p", string.match("hi! there", "%p") == "!")
test("match %x", string.match("xyz0Fa", "%x+") == "0Fa")

-- Complement classes
test("match %D", string.match("123abc", "%D+") == "abc")
test("match %A", string.match("abc123", "%A+") == "123")
test("match %S", string.match("  hello  ", "%S+") == "hello")

-- Dot matches any
test("match dot", string.match("abc", "..") == "ab")

-- Quantifiers
test("match * zero", string.match("bcd", "a*") == "")
test("match * greedy", string.match("aaa", "a*") == "aaa")
test("match + one", string.match("aaa", "a+") == "aaa")
test("match + miss", string.match("bbb", "a+") == nil)
test("match ? present", string.match("abc", "ab?c") == "abc")
test("match ? absent", string.match("ac", "ab?c") == "ac")

-- Lazy quantifier -
test("match - lazy", string.match("<tag>content</tag>", "<(.-)>") == "tag")

-- Anchors
test("match ^ anchor", string.match("hello world", "^%a+") == "hello")
test("match $ anchor", string.match("hello world", "%a+$") == "world")
test("match ^$ full", string.match("hello", "^hello$") == "hello")
test("match ^$ fail", string.match("hello!", "^hello$") == nil)

-- Character sets
test("match [set]", string.match("hello", "[helo]+") == "hello")
test("match [range]", string.match("test123", "[0-9]+") == "123")
test("match [^set]", string.match("hello world", "[^ ]+") == "hello")
test("match [%d%a]", string.match("a1b2", "[%d%a]+") == "a1b2")

-- Position captures
local p1, p2 = string.match("hello", "()el()")
test("position capture start", p1 == 2)
test("position capture end", p2 == 4)

-- Escaped magic characters
test("match escaped dot", string.match("a.b", "a%.b") == "a.b")
test("match escaped paren", string.match("a(b)", "a%(b%)") == "a(b)")

end)()

;(function()
--------------------------------------------------------------------------------
-- 37. Pattern Matching — string.gmatch
--------------------------------------------------------------------------------
section("Pattern Matching — string.gmatch")

-- Iterate words
local words = {}
for w in string.gmatch("hello world foo", "%a+") do
    words[#words + 1] = w
end
test("gmatch words count", #words == 3)
test("gmatch words first", words[1] == "hello")
test("gmatch words last", words[3] == "foo")

-- Iterate with captures
local pairs_t = {}
for k, v in string.gmatch("a=1, b=2, c=3", "(%a)=(%d)") do
    pairs_t[k] = v
end
test("gmatch captures a", pairs_t.a == "1")
test("gmatch captures b", pairs_t.b == "2")
test("gmatch captures c", pairs_t.c == "3")

-- Iterate digits
local nums = {}
for n in string.gmatch("12 34 56", "%d+") do
    nums[#nums + 1] = tonumber(n)
end
test("gmatch digits", nums[1] == 12 and nums[2] == 34 and nums[3] == 56)

end)()

;(function()
--------------------------------------------------------------------------------
-- 38. Pattern Matching — string.gsub
--------------------------------------------------------------------------------
section("Pattern Matching — string.gsub")

-- Simple string replacement
local r1, c1 = string.gsub("hello world", "world", "lua")
test("gsub simple", r1 == "hello lua")
test("gsub count", c1 == 1)

-- Pattern replacement
local r2, c2 = string.gsub("abc123def456", "%d+", "#")
test("gsub pattern", r2 == "abc#def#")
test("gsub pattern count", c2 == 2)

-- With max replacements
local r3, c3 = string.gsub("aaa", "a", "b", 2)
test("gsub max n", r3 == "bba")
test("gsub max n count", c3 == 2)

-- Capture references in replacement
local r4 = string.gsub("hello world", "(%a+)", "(%1)")
test("gsub capture ref", r4 == "(hello) (world)")

-- %0 for whole match
local r5 = string.gsub("abc", "%a+", "[%0]")
test("gsub %0 whole match", r5 == "[abc]")

-- Table replacement
local t = {hello = "HI", world = "EARTH"}
local r6 = string.gsub("hello world", "%a+", t)
test("gsub table", r6 == "HI EARTH")

-- Function replacement
local r7 = string.gsub("hello world", "%a+", function(w)
    return string.upper(w)
end)
test("gsub function", r7 == "HELLO WORLD")

-- Function returning nil keeps original
local r8 = string.gsub("hello world", "%a+", function(w)
    if w == "hello" then return "HI" end
    -- return nil for "world"
end)
test("gsub function nil keeps original", r8 == "HI world")

-- Escaped % in replacement
local r9 = string.gsub("hello", "hello", "100%%")
test("gsub escaped percent", r9 == "100%")

end)()

;(function()
--------------------------------------------------------------------------------
-- 39. Pattern Matching — Advanced
--------------------------------------------------------------------------------
section("Pattern Matching — Advanced")

-- Balanced match %bxy
local r10 = string.match("(hello (world))", "%b()")
test("balanced parens", r10 == "(hello (world))")

-- Frontier %f
local r11 = string.gsub("hello World foo Bar", "%f[%u]%a+", "X")
test("frontier uppercase words", r11 == "hello X foo X")

-- Back-reference
local r12 = string.match("aabbc", "(%a)%1")
test("back-reference", r12 == "a")

-- Nested captures
local full, inner = string.match("hello world", "((%a+))")
test("nested capture outer", full == "hello")
test("nested capture inner", inner == "hello")

-- Empty pattern match
test("empty pattern", string.match("hello", "") == "")

-- Match at start
test("match at string start", string.match("hello", "^h") == "h")

end)()

;(function()
--------------------------------------------------------------------------------
-- 40. To-Be-Closed Variables
--------------------------------------------------------------------------------
section("To-Be-Closed Variables")

-- Helper: create a closable value that records when it's closed
local function make_closable(log, name)
    local t = {name = name}
    setmetatable(t, {__close = function(self)
        log[#log + 1] = "close:" .. self.name
    end})
    return t
end

-- Basic close on normal scope exit
local log1 = {}
do
    local x <close> = make_closable(log1, "x")
end
test("close on block exit", log1[1] == "close:x")

-- Reverse order closing
local log2 = {}
do
    local a <close> = make_closable(log2, "a")
    local b <close> = make_closable(log2, "b")
    local c <close> = make_closable(log2, "c")
end
test("close reverse order count", #log2 == 3)
test("close reverse order first", log2[1] == "close:c")
test("close reverse order second", log2[2] == "close:b")
test("close reverse order third", log2[3] == "close:a")

-- Close on function return
local log3 = {}
local function test_return()
    local x <close> = make_closable(log3, "ret")
    return 42
end
local rv = test_return()
test("close on return value", rv == 42)
test("close on return", log3[1] == "close:ret")

-- Close on error (via pcall)
local log4 = {}
local ok4 = pcall(function()
    local x <close> = make_closable(log4, "err")
    error("boom")
end)
test("close on error pcall", ok4 == false)
test("close on error called", log4[1] == "close:err")

-- __close receives error value
local log5 = {}
local received_err = nil
pcall(function()
    local x <close> = setmetatable({}, {__close = function(self, err)
        received_err = err
    end})
    error("the error")
end)
test("close receives error", type(received_err) == "string")

-- nil value is silently ignored
local log6 = {}
do
    local x <close> = nil
    log6[#log6 + 1] = "after"
end
test("close nil ignored", log6[1] == "after")

-- false value is silently ignored
local log7 = {}
do
    local x <close> = false
    log7[#log7 + 1] = "after"
end
test("close false ignored", log7[1] == "after")

-- Close in while loop with break
local log8 = {}
local i8 = 0
while true do
    local x <close> = make_closable(log8, "w" .. tostring(i8))
    i8 = i8 + 1
    if i8 >= 2 then break end
end
test("close in while count", #log8 == 2)
test("close in while break", log8[2] == "close:w1")

-- Close in numeric for
local log9 = {}
for i = 1, 3 do
    local x <close> = make_closable(log9, "f" .. tostring(i))
end
test("close in for count", #log9 == 3)
test("close in for order", log9[1] == "close:f1")

-- Close in repeat-until
local log10 = {}
local i10 = 0
repeat
    local x <close> = make_closable(log10, "r" .. tostring(i10))
    i10 = i10 + 1
until i10 >= 2
test("close in repeat count", #log10 == 2)

-- Multiple close: all called even if one errors
local log11 = {}
local ok11 = pcall(function()
    local a <close> = make_closable(log11, "a")
    local b <close> = setmetatable({}, {__close = function()
        log11[#log11 + 1] = "close:b"
        error("close error")
    end})
    local c <close> = make_closable(log11, "c")
end)
test("close all called despite error", #log11 == 3)
test("close error propagated", ok11 == false)

end)()

--------------------------------------------------------------------------------
-- Optimization-Sensitive Tests
-- These tests cover scenarios where a buggy optimizer could produce different
-- results than the unoptimized interpreter. They are written in plain Lua so
-- they pass regardless of whether the optimizer is enabled or disabled — the
-- point is that the semantics are preserved either way.
--------------------------------------------------------------------------------
;(function()
section("Optimizer: side effects in unused locals")

-- A function call on the RHS of an unused local must still execute.
local side_effect_count = 0
local function bump() side_effect_count = side_effect_count + 1 return 99 end

local _unused = bump()
test("unused local RHS call still executes", side_effect_count == 1)

-- Multiple unused locals from a single call — the call fires once.
local _a, _b = bump(), bump()
test("two unused locals each fire their RHS", side_effect_count == 3)

-- Mixed: one used, one unused — binding kept, call fires.
local used_val, _unused2 = bump(), bump()
test("mixed local: used value is correct", used_val == 99)
test("mixed local: both calls fired (count is now 5)", side_effect_count == 5)

end)()

;(function()
section("Optimizer: goto / label preservation")

-- goto must still jump to its label even after optimization.
local reached_label = false
local skipped = false
do
    goto skip_me
    skipped = true         -- dead code, but goto must reach label
    ::skip_me::
    reached_label = true
end
test("goto reaches its label", reached_label == true)
test("dead code after goto not executed", skipped == false)

-- goto inside a block jumping forward.
local log = {}
for i = 1, 3 do
    if i == 2 then goto continue end
    log[#log + 1] = i
    ::continue::
end
test("goto continue pattern: skips iteration 2", #log == 2)
test("goto continue pattern: log[1] == 1", log[1] == 1)
test("goto continue pattern: log[2] == 3", log[2] == 3)

end)()

;(function()
section("Optimizer: constant-condition branches")

-- while false — body must never execute.
local while_ran = false
while false do
    while_ran = true
end
test("while false body never executes", while_ran == false)

-- if false — then-branch must not execute; else-branch must.
local if_false_then = false
local if_false_else = false
if false then
    if_false_then = true
else
    if_false_else = true
end
test("if false: then branch not taken", if_false_then == false)
test("if false: else branch taken", if_false_else == true)

-- if true — then-branch always executes; else-branch must not.
local if_true_then = false
local if_true_else = false
if true then
    if_true_then = true
else
    if_true_else = true
end
test("if true: then branch taken", if_true_then == true)
test("if true: else branch not taken", if_true_else == false)

end)()

;(function()
section("Optimizer: and/or short-circuit side effects")

local calls = 0
local function side() calls = calls + 1 return true end

-- false and side() — right side must NOT be evaluated.
local _ = false and side()
test("false and expr: right side not evaluated", calls == 0)

-- true or side() — right side must NOT be evaluated.
_ = true or side()
test("true or expr: right side not evaluated", calls == 0)

-- true and side() — right side MUST be evaluated.
_ = true and side()
test("true and expr: right side evaluated", calls == 1)

-- false or side() — right side MUST be evaluated.
_ = false or side()
test("false or expr: right side evaluated", calls == 2)

end)()

;(function()
section("Optimizer: numeric type preservation")

-- Division always produces a float.
local d = 4 / 2
test("4 / 2 is float", math.type(d) == "float")
test("4 / 2 == 2.0", d == 2.0)

-- Floor division of integers stays integer.
local fd = 7 // 2
test("7 // 2 is integer", math.type(fd) == "integer")
test("7 // 2 == 3", fd == 3)

-- Exponentiation always produces a float.
local p = 2 ^ 3
test("2 ^ 3 is float", math.type(p) == "float")
test("2 ^ 3 == 8.0", p == 8.0)

-- Arithmetic on two integers stays integer.
local s = 3 + 4
test("3 + 4 is integer", math.type(s) == "integer")
test("3 + 4 == 7", s == 7)

-- Arithmetic mixing int and float produces float.
local m = 3 + 1.0
test("3 + 1.0 is float", math.type(m) == "float")

end)()

;(function()
section("Optimizer: integer overflow wrapping")

local max = math.maxinteger
local wrapped = max + 1
test("maxinteger + 1 wraps to mininteger", wrapped == math.mininteger)

local min = math.mininteger
local wrapped2 = min - 1
test("mininteger - 1 wraps to maxinteger", wrapped2 == math.maxinteger)

end)()

;(function()
section("Optimizer: concatenation coercion")

-- Integer concatenated to integer produces string "12".
local r1 = 1 .. 2
test("1 .. 2 == '12'", r1 == "12")

-- Float concatenated to string preserves float representation.
local r2 = 1.0 .. "x"
test("1.0 .. 'x' == '1.0x'", r2 == "1.0x")

-- String concat of computed integers.
local r3 = (3 + 4) .. (10 - 3)
test("(3+4) .. (10-3) == '77'", r3 == "77")

end)()

;(function()
section("Optimizer: dead code after break")

-- Statements after break inside a loop must not execute.
local after_break = false
for i = 1, 5 do
    if i == 2 then
        break
        after_break = true   -- dead code
    end
end
test("dead code after break not executed", after_break == false)

-- A label after break must still be reachable from outside the block.
-- (The label is preserved so any goto targeting it from the loop body works.)
local label_reached = false
for i = 1, 3 do
    if i == 1 then
        break
    end
    ::after::
    label_reached = true
end
test("label after break: loop terminated at i==1", label_reached == false)

end)()

;(function()
section("Optimizer: constant folding correctness")

test("2 + 3 == 5",           2 + 3 == 5)
test("10 - 4 == 6",          10 - 4 == 6)
test("3 * 7 == 21",          3 * 7 == 21)
test("10 / 4 == 2.5",        10 / 4 == 2.5)
test("10 // 3 == 3",         10 // 3 == 3)
test("10 % 3 == 1",          10 % 3 == 1)
test("-(-5) == 5",           -(-5) == 5)
test("not false == true",    not false == true)
test("not true == false",    not true == false)
test("2 ^ 10 == 1024.0",     2 ^ 10 == 1024.0)
test("'hello' .. ' ' .. 'world' == 'hello world'",
     'hello' .. ' ' .. 'world' == 'hello world')
test("#'abc' == 3",          #'abc' == 3)

-- Nested constant expressions.
test("(2 + 3) * (4 - 1) == 15",  (2 + 3) * (4 - 1) == 15)
test("2 ^ 3 ^ 2 == 512.0",       2 ^ 3 ^ 2 == 512.0)  -- right-assoc: 2^(3^2)=2^9

end)()

;(function()
section("Optimizer: constant propagation correctness")

-- Mutated local: must read the updated value, not the initial literal.
local x = 5
x = 10
test("mutated local reads updated value", x == 10)

-- Reassignment in an expression context.
local y = 1
y = y + 1
test("local incremented correctly", y == 2)

-- Inner shadowing: a nested local with the same name must not inherit
-- the outer value in inner-scope reads.
local z = 100
do
    local z = 42
    test("inner shadow reads inner value", z == 42)
end
test("outer value unchanged after inner shadow", z == 100)

-- Shadowing with non-literal: inner local initialised from a call must
-- not bleed the outer literal into the inner scope.
local w = 7
do
    local w = math.max(3, 4)   -- non-literal initialiser
    test("inner non-literal shadow reads correct value", w == 4)
end
test("outer value unchanged after non-literal shadow", w == 7)

-- Upvalue mutation through a closure: calling a function that writes an
-- outer local must be visible at the call site.
local counter = 0
local function inc() counter = counter + 1 end
inc()
test("upvalue mutation visible after closure call", counter == 1)
inc()
inc()
test("upvalue mutation accumulates correctly", counter == 3)

-- Parameter shadow: a function parameter with the same name as an outer
-- constant must not receive the outer value inside the function.
local base = 10
local function add(base, n) return base + n end
test("parameter shadows outer constant", add(1, 2) == 3)

end)()


print("")
print("========================================")
print(string.format("  TOTAL: %d  |  PASS: %d  |  FAIL: %d", pass_count + fail_count, pass_count, fail_count))
print("========================================")

if fail_count > 0 then
    print("  *** SOME TESTS FAILED ***")
else
    print("  All tests passed!")
end