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/table_comprehension_spec.lua | 297 +++++++++++++++++++++++++ 1 file changed, 297 insertions(+) create mode 100644 spec/outputs/test/table_comprehension_spec.lua (limited to 'spec/outputs/test/table_comprehension_spec.lua') diff --git a/spec/outputs/test/table_comprehension_spec.lua b/spec/outputs/test/table_comprehension_spec.lua new file mode 100644 index 0000000..90fa647 --- /dev/null +++ b/spec/outputs/test/table_comprehension_spec.lua @@ -0,0 +1,297 @@ +return describe("table comprehension", function() + it("should create simple table copy", function() + local thing = { + color = "red", + name = "fast", + width = 123 + } + local thing_copy + do + local _tbl_0 = { } + for k, v in pairs(thing) do + _tbl_0[k] = v + end + thing_copy = _tbl_0 + end + assert.same(thing_copy.color, thing.color) + assert.same(thing_copy.name, thing.name) + return assert.same(thing_copy.width, thing.width) + end) + it("should filter with when clause", function() + local thing = { + color = "red", + name = "fast", + width = 123 + } + local no_color + do + local _tbl_0 = { } + for k, v in pairs(thing) do + if k ~= "color" then + _tbl_0[k] = v + end + end + no_color = _tbl_0 + end + assert.same(no_color.color, nil) + assert.same(no_color.name, "fast") + return assert.same(no_color.width, 123) + end) + it("should transform values", function() + local numbers = { + a = 1, + b = 2, + c = 3 + } + local doubled + do + local _tbl_0 = { } + for k, v in pairs(numbers) do + _tbl_0[k] = v * 2 + end + doubled = _tbl_0 + end + assert.same(doubled.a, 2) + assert.same(doubled.b, 4) + return assert.same(doubled.c, 6) + end) + it("should transform keys", function() + local data = { + a = 1, + b = 2 + } + local upper_keys + do + local _tbl_0 = { } + for k, v in pairs(data) do + _tbl_0[k:upper()] = v + end + upper_keys = _tbl_0 + end + assert.same(upper_keys.A, 1) + return assert.same(upper_keys.B, 2) + end) + it("should work with ipairs", function() + local items = { + "a", + "b", + "c" + } + local reversed + do + local _tbl_0 = { } + for i, v in ipairs(items) do + _tbl_0[i] = v + end + reversed = _tbl_0 + end + assert.same(reversed[1], "a") + assert.same(reversed[2], "b") + return assert.same(reversed[3], "c") + end) + it("should filter array items", function() + local items = { + 1, + 2, + 3, + 4, + 5 + } + local evens + do + local _tbl_0 = { } + for i, v in ipairs(items) do + if v % 2 == 0 then + _tbl_0[i] = v + end + end + evens = _tbl_0 + end + assert.same(evens[2], 2) + assert.same(evens[4], 4) + return assert.same(evens[1], nil) + end) + it("should work with numeric for loop", function() + local squares + do + local _tbl_0 = { } + for i = 1, 5 do + _tbl_0[i] = i * i + end + squares = _tbl_0 + end + assert.same(squares[1], 1) + assert.same(squares[2], 4) + assert.same(squares[3], 9) + assert.same(squares[4], 16) + return assert.same(squares[5], 25) + end) + it("should support nested comprehensions", function() + local matrix = { + { + 1, + 2 + }, + { + 3, + 4 + }, + { + 5, + 6 + } + } + local flat = { } + for _index_0 = 1, #matrix do + local row = matrix[_index_0] + for i, v in ipairs(row) do + flat[#flat + 1] = v + end + end + return assert.same(flat, { + 1, + 2, + 3, + 4, + 5, + 6 + }) + end) + it("should combine pairs and when", function() + local data = { + a = 1, + b = 2, + c = 3, + d = 4 + } + local greater_than_two + do + local _tbl_0 = { } + for k, v in pairs(data) do + if v > 2 then + _tbl_0[k] = v + end + end + greater_than_two = _tbl_0 + end + assert.same(greater_than_two.a, nil) + assert.same(greater_than_two.b, nil) + assert.same(greater_than_two.c, 3) + return assert.same(greater_than_two.d, 4) + end) + it("should work with string keys", function() + local obj = { + ["key-with-dash"] = "value1", + ["key_with_underscore"] = "value2" + } + local result + do + local _tbl_0 = { } + for k, v in pairs(obj) do + _tbl_0[k] = v + end + result = _tbl_0 + end + assert.same(result["key-with-dash"], "value1") + return assert.same(result["key_with_underscore"], "value2") + end) + it("should handle empty source", function() + local empty = { } + local result + do + local _tbl_0 = { } + for k, v in pairs(empty) do + _tbl_0[k] = v + end + result = _tbl_0 + end + return assert.same(#result, 0) + end) + it("should work with computed keys", function() + local base = { + a = 1, + b = 2 + } + local result + do + local _tbl_0 = { } + for k, v in pairs(base) do + _tbl_0[k .. "_suffix"] = v * 10 + end + result = _tbl_0 + end + assert.same(result.a_suffix, 10) + return assert.same(result.b_suffix, 20) + end) + it("should support nested table transformation", function() + local data = { + first = { + x = 1, + y = 2 + }, + second = { + x = 3, + y = 4 + } + } + local transformed + do + local _tbl_0 = { } + for k, v in pairs(data) do + _tbl_0[k] = v.x + v.y + end + transformed = _tbl_0 + end + assert.same(transformed.first, 3) + return assert.same(transformed.second, 7) + end) + it("should filter with multiple conditions", function() + local numbers = { + a = 1, + b = 2, + c = 3, + d = 4, + e = 5 + } + local result + do + local _tbl_0 = { } + for k, v in pairs(numbers) do + if v > 1 and v < 5 then + _tbl_0[k] = v + end + end + result = _tbl_0 + end + assert.same(result.a, nil) + assert.same(result.b, 2) + assert.same(result.c, 3) + assert.same(result.d, 4) + return assert.same(result.e, nil) + end) + return it("should work with custom iterator", function() + local custom_iter + custom_iter = function() + local state = 0 + return function() + state = state + 1 + if state <= 3 then + return state, state * 10 + else + return nil + end + end + end + local result + do + local _tbl_0 = { } + for k, v in custom_iter() do + _tbl_0[k] = v + end + result = _tbl_0 + end + assert.same(result[1], 10) + assert.same(result[2], 20) + return assert.same(result[3], 30) + end) +end) -- cgit v1.2.3-55-g6feb