From dd64edd58fe25ec74ae5958128cf3f74b0692f3b Mon Sep 17 00:00:00 2001 From: Li Jin Date: Wed, 28 Jan 2026 18:43:14 +0800 Subject: Fixed compiler issues and added 800+ test cases. --- spec/outputs/test/functions_advanced_spec.lua | 259 ++++++++++++++++++++++++++ 1 file changed, 259 insertions(+) create mode 100644 spec/outputs/test/functions_advanced_spec.lua (limited to 'spec/outputs/test/functions_advanced_spec.lua') diff --git a/spec/outputs/test/functions_advanced_spec.lua b/spec/outputs/test/functions_advanced_spec.lua new file mode 100644 index 0000000..4e99023 --- /dev/null +++ b/spec/outputs/test/functions_advanced_spec.lua @@ -0,0 +1,259 @@ +return describe("advanced functions", function() + it("should support fat arrow with self", function() + local obj = { + value = 10, + getValue = function(self) + return self.value + end + } + return assert.same(obj:getValue(), 10) + end) + it("should work with argument defaults", function() + local fn + fn = function(name, height) + if name == nil then + name = "something" + end + if height == nil then + height = 100 + end + return tostring(name) .. ", " .. tostring(height) + end + assert.same(fn(), "something, 100") + assert.same(fn("test"), "test, 100") + return assert.same(fn("test", 50), "test, 50") + end) + it("should handle defaults with previous arguments", function() + local fn + fn = function(x, y) + if x == nil then + x = 100 + end + if y == nil then + y = x + 1000 + end + return x + y + end + assert.same(fn(), 1200) + return assert.same(fn(50), 1100) + end) + it("should work with multi-line arguments", function() + local my_func + my_func = function(a, b, c, d, e, f) + return a + b + c + d + e + f + end + local result = my_func(5, 4, 3, 8, 9, 10) + return assert.same(result, 39) + end) + it("should support nested function calls", function() + local another_func + another_func = function(a, b, c, d, e, f) + return a + b + c + d + e + f + end + local my_func + my_func = function(a, b, c, d, e, f, g) + return a + b + c + d + e + f + g + end + local result = my_func(5, 6, 7, 6, another_func(6, 7, 8, 9, 1, 2), 5, 4) + return assert.same(result, 66) + end) + it("should handle implicit return", function() + local sum + sum = function(x, y) + return x + y + end + return assert.same(sum(10, 20), 30) + end) + it("should work with explicit return", function() + local difference + difference = function(x, y) + return x - y + end + return assert.same(difference(20, 10), 10) + end) + it("should support multiple return values", function() + local mystery + mystery = function(x, y) + return x + y, x - y + end + local a, b = mystery(10, 20) + assert.same(a, 30) + return assert.same(b, -10) + end) + it("should work with function as argument", function() + local apply + apply = function(fn, x, y) + return fn(x, y) + end + local result = apply((function(a, b) + return a + b + end), 5, 10) + return assert.same(result, 15) + end) + it("should handle function returning function", function() + local create_adder + create_adder = function(x) + return function(y) + return x + y + end + end + local add_five = create_adder(5) + return assert.same(add_five(10), 15) + end) + it("should support immediately invoked function", function() + local result = (function(x) + return x * 2 + end)(5) + return assert.same(result, 10) + end) + it("should work with varargs", function() + local sum_all + sum_all = function(...) + local total = 0 + for i = 1, select('#', ...) do + if type(select(i, ...)) == "number" then + total = total + select(i, ...) + end + end + return total + end + return assert.same(sum_all(1, 2, 3, 4, 5), 15) + end) + it("should handle named varargs", function() + local fn + fn = function(...) + local t = { + n = select("#", ...), + ... + } + local count = 0 + for i = 1, t.n do + count = count + 1 + end + return count + end + return assert.same(fn(1, 2, 3), 3) + end) + it("should support prefixed return", function() + local findValue + findValue = function() + local items = { + 1, + 2, + 3 + } + for _index_0 = 1, #items do + local item = items[_index_0] + if item == 5 then + return item + end + end + return "not found" + end + local result = findValue() + return assert.same(result, "not found") + end) + it("should work with parameter destructuring", function() + local fn + fn = function(_arg_0) + local a, b, c + a, b, c = _arg_0.a, _arg_0.b, _arg_0.c + return a + b + c + end + return assert.same(fn({ + a = 1, + b = 2, + c = 3 + }), 6) + end) + it("should handle default values in destructuring", function() + local fn + fn = function(_arg_0) + local a1, b + a1, b = _arg_0.a, _arg_0.b + if a1 == nil then + a1 = 123 + end + if b == nil then + b = 'abc' + end + return a1 .. " " .. b + end + assert.same(fn({ }), "123 abc") + return assert.same(fn({ + a = 456 + }), "456 abc") + end) + it("should support empty function body", function() + local empty_fn + empty_fn = function() end + return assert.same(empty_fn(), nil) + end) + it("should work with function in table", function() + local tb = { + value = 10, + double = function(self) + return self.value * 2 + end + } + return assert.same(tb:double(), 20) + end) + it("should handle function with no arguments", function() + local fn + fn = function() + return "result" + end + assert.same(fn(), "result") + return assert.same(fn(), "result") + end) + it("should support calling function with !", function() + local fn + fn = function() + return 42 + end + return assert.same(fn(), 42) + end) + it("should work with nested functions", function() + local outer + outer = function(x) + local inner + inner = function(y) + return x + y + end + return inner + end + local add_five = outer(5) + return assert.same(add_five(10), 15) + end) + it("should handle function in expression", function() + local result + if (function(x) + return x > 10 + end)(15) then + result = "large" + else + result = "small" + end + return assert.same(result, "large") + end) + return it("should support function as return value", function() + local get_operation + get_operation = function(op) + if "add" == op then + return function(a, b) + return a + b + end + elseif "subtract" == op then + return function(a, b) + return a - b + end + else + return function() + return 0 + end + end + end + local add = get_operation("add") + return assert.same(add(5, 3), 8) + end) +end) -- cgit v1.2.3-55-g6feb