1 files changed, 259 insertions, 0 deletions

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)