104 lines
2.7 KiB
Lua
104 lines
2.7 KiB
Lua
local ok, task = pcall(require, "lb:task")
|
|
if not ok then return end
|
|
|
|
describe("spawn", function()
|
|
test("callback receives args", function()
|
|
spawn(function(...)
|
|
assert(select("#", ...) == 0)
|
|
end):await()
|
|
|
|
spawn(function(...)
|
|
assert(select("#", ...) == 1)
|
|
assert((...) == nil)
|
|
end, nil):await()
|
|
|
|
spawn(function(...)
|
|
assert(select("#", ...) == 4)
|
|
local args = table.pack(...)
|
|
assert(args[1] == 1 and args[2] == 2 and args[3] == nil and args[4] == 3)
|
|
end, 1, 2, nil, 3):await()
|
|
end)
|
|
|
|
test("await returns callback results", function()
|
|
local res = table.pack(spawn(function()
|
|
-- no returns
|
|
end):await())
|
|
assert(res.n == 0)
|
|
|
|
local res = table.pack(spawn(function()
|
|
return nil
|
|
end):await())
|
|
assert(res.n == 1 and res[1] == nil)
|
|
|
|
local res = table.pack(spawn(function()
|
|
return 1, 2, nil, 3
|
|
end):await())
|
|
assert(res.n == 4 and res[1] == 1 and res[2] == 2 and res[3] == nil and res[4] == 3)
|
|
end)
|
|
|
|
test("callback args and results", function()
|
|
local res = table.pack(spawn(function(...)
|
|
assert(select("#", ...) == 5)
|
|
local args = table.pack(...)
|
|
assert(args[1] == 5 and args[2] == 4 and args[3] == nil and args[4] == 3, args[5] == nil)
|
|
return 1, 3, nil
|
|
end, 5, 4, nil, 3, nil):await())
|
|
assert(res.n == 3 and res[1] == 1 and res[2] == 3 and res[3] == nil)
|
|
end)
|
|
|
|
test("order is consistent", function()
|
|
-- all tasks spawned in one batch should be resumed in the spawn order
|
|
local tasks, nums = {}, {}
|
|
for i = 1, 10 do
|
|
table.insert(
|
|
tasks,
|
|
spawn(function()
|
|
table.insert(nums, i)
|
|
end)
|
|
)
|
|
end
|
|
for i = 10, 1, -1 do
|
|
tasks[i]:await()
|
|
end
|
|
assert(#nums == 10)
|
|
for i = 1, 10 do
|
|
assert(nums[i] == i)
|
|
end
|
|
end)
|
|
end)
|
|
|
|
describe("sleep", function()
|
|
test("sleep is asynchronous", function()
|
|
local value
|
|
spawn(function()
|
|
value = "value"
|
|
end)
|
|
assert(value == nil)
|
|
task.sleep(100) -- implicit await: if it's synchronous, value wouldn't change
|
|
assert(value == "value")
|
|
end)
|
|
end)
|
|
|
|
describe("task", function()
|
|
test("properly unrefs arg and ret table", function()
|
|
local registry = debug.getregistry()
|
|
local ref, t
|
|
local cb = function()
|
|
return "my ret"
|
|
end
|
|
do
|
|
local task = spawn(cb, "my arg")
|
|
ref = task.__ref
|
|
t = registry[ref]
|
|
assert(type(t) == "table")
|
|
assert(t[1] == cb)
|
|
assert(t[2] == "my arg")
|
|
task:await()
|
|
assert(registry[task.__ref] == t)
|
|
assert(t[1] == "my ret")
|
|
end
|
|
collectgarbage()
|
|
assert(registry[ref] ~= t) -- if task unref'ed it, it should be either nil or the next freelist number
|
|
end)
|
|
end)
|