Software `/` code `/` prosody

Annotate

spec/util_async_spec.lua @ 12672:c8f59ce7d3cf

mod_admin_shell: Ensure account has role before it is usable By creating the account first without a password it can't be used until the role has set. This is most important for restricted accounts, as a failure to set the role would lead to the account having more privileges than indented.

author	Kim Alvefur <zash@zash.se>
date	Thu, 18 Aug 2022 19:00:01 +0200
parent	11964:563ee7969f6c

rev	line source
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	1 local async = require "util.async";
11964 563ee7969f6c util.async tests: Explicitly import match from luassert (luacheck) Matthew Wild <mwild1@gmail.com> parents: 11962 diff changeset	2 local match = require "luassert.match";
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	3
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	4 describe("util.async", function()
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	5 local debug = false;
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	6 local print = print;
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	7 if debug then
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	8 require "util.logger".add_simple_sink(print);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	9 else
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	10 print = function () end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	11 end
8623 ab242c513bf4 util.async: tests: Add helper function to create mock watcher callbacks Matthew Wild <mwild1@gmail.com> parents: 8622 diff changeset	12
8630 deade38ffbbd util.async: tests: slight modifications to allow more code reuse in tests Matthew Wild <mwild1@gmail.com> parents: 8628 diff changeset	13 local function mock_watchers(event_log)
deade38ffbbd util.async: tests: slight modifications to allow more code reuse in tests Matthew Wild <mwild1@gmail.com> parents: 8628 diff changeset	14 local function generic_logging_watcher(name)
deade38ffbbd util.async: tests: slight modifications to allow more code reuse in tests Matthew Wild <mwild1@gmail.com> parents: 8628 diff changeset	15 return function (...)
deade38ffbbd util.async: tests: slight modifications to allow more code reuse in tests Matthew Wild <mwild1@gmail.com> parents: 8628 diff changeset	16 table.insert(event_log, { name = name, n = select("#", ...)-1, select(2, ...) });
deade38ffbbd util.async: tests: slight modifications to allow more code reuse in tests Matthew Wild <mwild1@gmail.com> parents: 8628 diff changeset	17 end;
deade38ffbbd util.async: tests: slight modifications to allow more code reuse in tests Matthew Wild <mwild1@gmail.com> parents: 8628 diff changeset	18 end;
8623 ab242c513bf4 util.async: tests: Add helper function to create mock watcher callbacks Matthew Wild <mwild1@gmail.com> parents: 8622 diff changeset	19 return setmetatable(mock{
8630 deade38ffbbd util.async: tests: slight modifications to allow more code reuse in tests Matthew Wild <mwild1@gmail.com> parents: 8628 diff changeset	20 ready = generic_logging_watcher("ready");
deade38ffbbd util.async: tests: slight modifications to allow more code reuse in tests Matthew Wild <mwild1@gmail.com> parents: 8628 diff changeset	21 waiting = generic_logging_watcher("waiting");
deade38ffbbd util.async: tests: slight modifications to allow more code reuse in tests Matthew Wild <mwild1@gmail.com> parents: 8628 diff changeset	22 error = generic_logging_watcher("error");
8623 ab242c513bf4 util.async: tests: Add helper function to create mock watcher callbacks Matthew Wild <mwild1@gmail.com> parents: 8622 diff changeset	23 }, {
ab242c513bf4 util.async: tests: Add helper function to create mock watcher callbacks Matthew Wild <mwild1@gmail.com> parents: 8622 diff changeset	24 __index = function (_, event)
ab242c513bf4 util.async: tests: Add helper function to create mock watcher callbacks Matthew Wild <mwild1@gmail.com> parents: 8622 diff changeset	25 -- Unexpected watcher called
8632 02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	26 assert(false, "unexpected watcher called: "..event);
8623 ab242c513bf4 util.async: tests: Add helper function to create mock watcher callbacks Matthew Wild <mwild1@gmail.com> parents: 8622 diff changeset	27 end;
ab242c513bf4 util.async: tests: Add helper function to create mock watcher callbacks Matthew Wild <mwild1@gmail.com> parents: 8622 diff changeset	28 })
ab242c513bf4 util.async: tests: Add helper function to create mock watcher callbacks Matthew Wild <mwild1@gmail.com> parents: 8622 diff changeset	29 end
ab242c513bf4 util.async: tests: Add helper function to create mock watcher callbacks Matthew Wild <mwild1@gmail.com> parents: 8622 diff changeset	30
8632 02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	31 local function new(func)
8630 deade38ffbbd util.async: tests: slight modifications to allow more code reuse in tests Matthew Wild <mwild1@gmail.com> parents: 8628 diff changeset	32 local event_log = {};
deade38ffbbd util.async: tests: slight modifications to allow more code reuse in tests Matthew Wild <mwild1@gmail.com> parents: 8628 diff changeset	33 local spy_func = spy.new(func);
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	34 return async.runner(spy_func, mock_watchers(event_log)), spy_func, event_log;
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	35 end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	36 describe("#runner", function()
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	37 it("should work", function()
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	38 local r = new(function (item) assert(type(item) == "number") end);
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	39 r:run(1);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	40 r:run(2);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	41 end);
8607 62bb06cf8a43 util.async: Add tests to specifically cover error handling Matthew Wild <mwild1@gmail.com> parents: 8605 diff changeset	42
62bb06cf8a43 util.async: Add tests to specifically cover error handling Matthew Wild <mwild1@gmail.com> parents: 8605 diff changeset	43 it("should be ready after creation", function ()
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	44 local r = new(function () end);
8607 62bb06cf8a43 util.async: Add tests to specifically cover error handling Matthew Wild <mwild1@gmail.com> parents: 8605 diff changeset	45 assert.equal(r.state, "ready");
62bb06cf8a43 util.async: Add tests to specifically cover error handling Matthew Wild <mwild1@gmail.com> parents: 8605 diff changeset	46 end);
62bb06cf8a43 util.async: Add tests to specifically cover error handling Matthew Wild <mwild1@gmail.com> parents: 8605 diff changeset	47
8614 bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	48 it("should do nothing if the queue is empty", function ()
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	49 local did_run;
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	50 local r = new(function () did_run = true end);
8614 bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	51 r:run();
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	52 assert.equal(r.state, "ready");
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	53 assert.is_nil(did_run);
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	54 r:run("hello");
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	55 assert.is_true(did_run);
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	56 end);
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	57
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	58 it("should support queuing work items without running", function ()
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	59 local did_run;
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	60 local r = new(function () did_run = true end);
8614 bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	61 r:enqueue("hello");
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	62 assert.equal(r.state, "ready");
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	63 assert.is_nil(did_run);
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	64 r:run();
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	65 assert.is_true(did_run);
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	66 end);
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	67
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	68 it("should support queuing multiple work items", function ()
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	69 local last_item;
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	70 local r, s = new(function (item) last_item = item; end);
8614 bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	71 r:enqueue("hello");
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	72 r:enqueue("there");
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	73 r:enqueue("world");
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	74 assert.equal(r.state, "ready");
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	75 r:run();
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	76 assert.equal(r.state, "ready");
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	77 assert.spy(s).was.called(3);
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	78 assert.equal(last_item, "world");
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	79 end);
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	80
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	81 it("should support all simple data types", function ()
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	82 local last_item;
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	83 local r, s = new(function (item) last_item = item; end);
8614 bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	84 local values = { {}, 123, "hello", true, false };
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	85 for i = 1, #values do
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	86 r:enqueue(values[i]);
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	87 end
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	88 assert.equal(r.state, "ready");
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	89 r:run();
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	90 assert.equal(r.state, "ready");
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	91 assert.spy(s).was.called(#values);
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	92 for i = 1, #values do
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	93 assert.spy(s).was.called_with(values[i]);
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	94 end
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	95 assert.equal(last_item, values[#values]);
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	96 end);
bfbafeced0c4 util.async: Yet more tests Matthew Wild <mwild1@gmail.com> parents: 8609 diff changeset	97
8681 0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	98 it("should work with no parameters", function ()
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	99 local item = "fail";
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	100 local r = async.runner();
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	101 local f = spy.new(function () item = "success"; end);
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	102 r:run(f);
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	103 assert.spy(f).was.called();
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	104 assert.equal(item, "success");
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	105 end);
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	106
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	107 it("supports a default error handler", function ()
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	108 local item = "fail";
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	109 local r = async.runner();
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	110 local f = spy.new(function () error("test error"); end);
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	111 assert.error_matches(function ()
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	112 r:run(f);
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	113 end, "test error");
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	114 assert.spy(f).was.called();
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	115 assert.equal(item, "fail");
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	116 end);
0c077800cd70 util.async: Make parameters to async.runner() optional Matthew Wild <mwild1@gmail.com> parents: 8669 diff changeset	117
8607 62bb06cf8a43 util.async: Add tests to specifically cover error handling Matthew Wild <mwild1@gmail.com> parents: 8605 diff changeset	118 describe("#errors", function ()
8618 680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	119 describe("should notify", function ()
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	120 local last_processed_item, last_error;
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	121 local r;
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	122 r = async.runner(function (item)
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	123 if item == "error" then
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	124 error({ e = "test error" });
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	125 end
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	126 last_processed_item = item;
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	127 end, mock{
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	128 ready = function () end;
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	129 waiting = function () end;
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	130 error = function (runner, err)
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	131 assert.equal(r, runner);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	132 last_error = err;
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	133 end;
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	134 });
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	135
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	136 -- Simple item, no error
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	137 r:run("hello");
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	138 assert.equal(r.state, "ready");
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	139 assert.equal(last_processed_item, "hello");
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	140 assert.spy(r.watchers.ready).was_not.called();
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	141 assert.spy(r.watchers.error).was_not.called();
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	142
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	143 -- Trigger an error inside the runner
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	144 assert.equal(last_error, nil);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	145 r:run("error");
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	146 test("the correct watcher functions", function ()
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	147 -- Only the error watcher should have been called
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	148 assert.spy(r.watchers.ready).was_not.called();
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	149 assert.spy(r.watchers.waiting).was_not.called();
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	150 assert.spy(r.watchers.error).was.called(1);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	151 end);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	152 test("with the correct error", function ()
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	153 -- The error watcher state should be correct, to
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	154 -- demonstrate the error was passed correctly
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	155 assert.is_table(last_error);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	156 assert.equal(last_error.e, "test error");
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	157 last_error = nil;
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	158 end);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	159 assert.equal(r.state, "ready");
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	160 assert.equal(last_processed_item, "hello");
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	161 end);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	162
8632 02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	163 do
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	164 local last_processed_item, last_error;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	165 local r;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	166 local wait, done;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	167 r = async.runner(function (item)
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	168 if item == "error" then
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	169 error({ e = "test error" });
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	170 elseif item == "wait" then
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	171 wait, done = async.waiter();
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	172 wait();
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	173 error({ e = "post wait error" });
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	174 end
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	175 last_processed_item = item;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	176 end, mock({
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	177 ready = function () end;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	178 waiting = function () end;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	179 error = function (runner, err)
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	180 assert.equal(r, runner);
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	181 last_error = err;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	182 end;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	183 }));
8618 680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	184
8632 02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	185 randomize(false); --luacheck: ignore 113/randomize
8607 62bb06cf8a43 util.async: Add tests to specifically cover error handling Matthew Wild <mwild1@gmail.com> parents: 8605 diff changeset	186
8632 02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	187 it("should not be fatal to the runner", function ()
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	188 r:run("world");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	189 assert.equal(r.state, "ready");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	190 assert.spy(r.watchers.ready).was_not.called();
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	191 assert.equal(last_processed_item, "world");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	192 end);
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	193 it("should work despite a #waiter", function ()
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	194 -- This test covers an important case where a runner
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	195 -- throws an error while being executed outside of the
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	196 -- main loop. This happens when it was blocked ('waiting'),
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	197 -- and then released (via a call to done()).
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	198 last_error = nil;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	199 r:run("wait");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	200 assert.equal(r.state, "waiting");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	201 assert.spy(r.watchers.waiting).was.called(1);
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	202 done();
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	203 -- At this point an error happens (state goes error->ready)
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	204 assert.equal(r.state, "ready");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	205 assert.spy(r.watchers.error).was.called(1);
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	206 assert.spy(r.watchers.ready).was.called(1);
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	207 assert.is_table(last_error);
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	208 assert.equal(last_error.e, "post wait error");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	209 last_error = nil;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	210 r:run("hello again");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	211 assert.spy(r.watchers.ready).was.called(1);
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	212 assert.spy(r.watchers.waiting).was.called(1);
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	213 assert.spy(r.watchers.error).was.called(1);
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	214 assert.equal(r.state, "ready");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	215 assert.equal(last_processed_item, "hello again");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	216 end);
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	217 end
8615 e77b37de482e util.async: Behaviour change: continue to process queued items after errors Matthew Wild <mwild1@gmail.com> parents: 8614 diff changeset	218
e77b37de482e util.async: Behaviour change: continue to process queued items after errors Matthew Wild <mwild1@gmail.com> parents: 8614 diff changeset	219 it("should continue to process work items", function ()
8632 02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	220 local last_item;
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	221 local runner, runner_func = new(function (item)
8615 e77b37de482e util.async: Behaviour change: continue to process queued items after errors Matthew Wild <mwild1@gmail.com> parents: 8614 diff changeset	222 if item == "error" then
e77b37de482e util.async: Behaviour change: continue to process queued items after errors Matthew Wild <mwild1@gmail.com> parents: 8614 diff changeset	223 error("test error");
8618 680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	224 end
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	225 last_item = item;
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	226 end);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	227 runner:enqueue("one");
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	228 runner:enqueue("error");
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	229 runner:enqueue("two");
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	230 runner:run();
8632 02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	231 assert.equal(runner.state, "ready");
8618 680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	232 assert.spy(runner_func).was.called(3);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	233 assert.spy(runner.watchers.error).was.called(1);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	234 assert.spy(runner.watchers.ready).was.called(0);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	235 assert.spy(runner.watchers.waiting).was.called(0);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	236 assert.equal(last_item, "two");
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	237 end);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	238
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	239 it("should continue to process work items during resume", function ()
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	240 local wait, done, last_item;
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	241 local runner, runner_func = new(function (item)
8618 680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	242 if item == "wait-error" then
8615 e77b37de482e util.async: Behaviour change: continue to process queued items after errors Matthew Wild <mwild1@gmail.com> parents: 8614 diff changeset	243 wait, done = async.waiter();
e77b37de482e util.async: Behaviour change: continue to process queued items after errors Matthew Wild <mwild1@gmail.com> parents: 8614 diff changeset	244 wait();
e77b37de482e util.async: Behaviour change: continue to process queued items after errors Matthew Wild <mwild1@gmail.com> parents: 8614 diff changeset	245 error("test error");
e77b37de482e util.async: Behaviour change: continue to process queued items after errors Matthew Wild <mwild1@gmail.com> parents: 8614 diff changeset	246 end
e77b37de482e util.async: Behaviour change: continue to process queued items after errors Matthew Wild <mwild1@gmail.com> parents: 8614 diff changeset	247 last_item = item;
e77b37de482e util.async: Behaviour change: continue to process queued items after errors Matthew Wild <mwild1@gmail.com> parents: 8614 diff changeset	248 end);
8616 a15c891c6232 util.async: ensure change in e77b37de482e applies after out-of-loop resume also Matthew Wild <mwild1@gmail.com> parents: 8615 diff changeset	249 runner:enqueue("one");
a15c891c6232 util.async: ensure change in e77b37de482e applies after out-of-loop resume also Matthew Wild <mwild1@gmail.com> parents: 8615 diff changeset	250 runner:enqueue("wait-error");
a15c891c6232 util.async: ensure change in e77b37de482e applies after out-of-loop resume also Matthew Wild <mwild1@gmail.com> parents: 8615 diff changeset	251 runner:enqueue("two");
a15c891c6232 util.async: ensure change in e77b37de482e applies after out-of-loop resume also Matthew Wild <mwild1@gmail.com> parents: 8615 diff changeset	252 runner:run();
a15c891c6232 util.async: ensure change in e77b37de482e applies after out-of-loop resume also Matthew Wild <mwild1@gmail.com> parents: 8615 diff changeset	253 done();
8632 02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	254 assert.equal(runner.state, "ready");
8616 a15c891c6232 util.async: ensure change in e77b37de482e applies after out-of-loop resume also Matthew Wild <mwild1@gmail.com> parents: 8615 diff changeset	255 assert.spy(runner_func).was.called(3);
a15c891c6232 util.async: ensure change in e77b37de482e applies after out-of-loop resume also Matthew Wild <mwild1@gmail.com> parents: 8615 diff changeset	256 assert.spy(runner.watchers.error).was.called(1);
8618 680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	257 assert.spy(runner.watchers.waiting).was.called(1);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour Matthew Wild <mwild1@gmail.com> parents: 8617 diff changeset	258 assert.spy(runner.watchers.ready).was.called(1);
8616 a15c891c6232 util.async: ensure change in e77b37de482e applies after out-of-loop resume also Matthew Wild <mwild1@gmail.com> parents: 8615 diff changeset	259 assert.equal(last_item, "two");
a15c891c6232 util.async: ensure change in e77b37de482e applies after out-of-loop resume also Matthew Wild <mwild1@gmail.com> parents: 8615 diff changeset	260 end);
8607 62bb06cf8a43 util.async: Add tests to specifically cover error handling Matthew Wild <mwild1@gmail.com> parents: 8605 diff changeset	261 end);
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	262 end);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	263 describe("#waiter", function()
8608 a2e6caf5848d util.async: Add test to ensure waiters throw an error outside async contexts Matthew Wild <mwild1@gmail.com> parents: 8607 diff changeset	264 it("should error outside of async context", function ()
a2e6caf5848d util.async: Add test to ensure waiters throw an error outside async contexts Matthew Wild <mwild1@gmail.com> parents: 8607 diff changeset	265 assert.has_error(function ()
a2e6caf5848d util.async: Add test to ensure waiters throw an error outside async contexts Matthew Wild <mwild1@gmail.com> parents: 8607 diff changeset	266 async.waiter();
a2e6caf5848d util.async: Add test to ensure waiters throw an error outside async contexts Matthew Wild <mwild1@gmail.com> parents: 8607 diff changeset	267 end);
a2e6caf5848d util.async: Add test to ensure waiters throw an error outside async contexts Matthew Wild <mwild1@gmail.com> parents: 8607 diff changeset	268 end);
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	269 it("should work", function ()
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	270 local wait, done;
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	271
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	272 local r = new(function (item)
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	273 assert(type(item) == "number")
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	274 if item == 3 then
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	275 wait, done = async.waiter();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	276 wait();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	277 end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	278 end);
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	279
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	280 r:run(1);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	281 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	282 r:run(2);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	283 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	284 r:run(3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	285 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	286 done();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	287 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	288 --for k, v in ipairs(l) do print(k,v) end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	289 end);
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	290
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	291 it("should work", function ()
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	292 --------------------
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	293 local wait, done;
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	294 local last_item = 0;
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	295 local r = new(function (item)
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	296 assert(type(item) == "number")
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	297 assert(item == last_item + 1);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	298 last_item = item;
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	299 if item == 3 then
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	300 wait, done = async.waiter();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	301 wait();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	302 end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	303 end);
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	304
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	305 r:run(1);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	306 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	307 r:run(2);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	308 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	309 r:run(3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	310 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	311 r:run(4);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	312 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	313 done();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	314 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	315 --for k, v in ipairs(l) do print(k,v) end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	316 end);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	317 it("should work", function ()
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	318 --------------------
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	319 local wait, done;
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	320 local last_item = 0;
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	321 local r = new(function (item)
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	322 assert(type(item) == "number")
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	323 assert((item == last_item + 1) or item == 3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	324 last_item = item;
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	325 if item == 3 then
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	326 wait, done = async.waiter();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	327 wait();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	328 end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	329 end);
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	330
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	331 r:run(1);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	332 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	333 r:run(2);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	334 assert(r.state == "ready");
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	335
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	336 r:run(3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	337 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	338 r:run(3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	339 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	340 r:run(3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	341 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	342 r:run(4);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	343 assert(r.state == "waiting");
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	344
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	345 for i = 1, 3 do
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	346 done();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	347 if i < 3 then
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	348 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	349 end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	350 end
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	351
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	352 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	353 --for k, v in ipairs(l) do print(k,v) end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	354 end);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	355 it("should work", function ()
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	356 --------------------
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	357 local wait, done;
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	358 local last_item = 0;
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	359 local r = new(function (item)
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	360 assert(type(item) == "number")
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	361 assert((item == last_item + 1) or item == 3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	362 last_item = item;
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	363 if item == 3 then
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	364 wait, done = async.waiter();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	365 wait();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	366 end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	367 end);
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	368
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	369 r:run(1);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	370 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	371 r:run(2);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	372 assert(r.state == "ready");
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	373
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	374 r:run(3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	375 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	376 r:run(3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	377 assert(r.state == "waiting");
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	378
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	379 for i = 1, 2 do
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	380 done();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	381 if i < 2 then
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	382 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	383 end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	384 end
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	385
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	386 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	387 r:run(4);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	388 assert(r.state == "ready");
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	389
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	390 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	391 --for k, v in ipairs(l) do print(k,v) end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	392 end);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	393 it("should work with multiple runners in parallel", function ()
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	394 -- Now with multiple runners
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	395 --------------------
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	396 local wait1, done1;
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	397 local last_item1 = 0;
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	398 local r1 = new(function (item)
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	399 assert(type(item) == "number")
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	400 assert((item == last_item1 + 1) or item == 3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	401 last_item1 = item;
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	402 if item == 3 then
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	403 wait1, done1 = async.waiter();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	404 wait1();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	405 end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	406 end, "r1");
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	407
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	408 local wait2, done2;
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	409 local last_item2 = 0;
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	410 local r2 = new(function (item)
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	411 assert(type(item) == "number")
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	412 assert((item == last_item2 + 1) or item == 3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	413 last_item2 = item;
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	414 if item == 3 then
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	415 wait2, done2 = async.waiter();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	416 wait2();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	417 end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	418 end, "r2");
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	419
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	420 r1:run(1);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	421 assert(r1.state == "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	422 r1:run(2);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	423 assert(r1.state == "ready");
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	424
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	425 r1:run(3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	426 assert(r1.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	427 r1:run(3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	428 assert(r1.state == "waiting");
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	429
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	430 r2:run(1);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	431 assert(r1.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	432 assert(r2.state == "ready");
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	433
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	434 r2:run(2);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	435 assert(r1.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	436 assert(r2.state == "ready");
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	437
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	438 r2:run(3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	439 assert(r1.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	440 assert(r2.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	441 done2();
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	442
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	443 r2:run(3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	444 assert(r1.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	445 assert(r2.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	446 done2();
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	447
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	448 r2:run(4);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	449 assert(r1.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	450 assert(r2.state == "ready");
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	451
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	452 for i = 1, 2 do
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	453 done1();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	454 if i < 2 then
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	455 assert(r1.state == "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	456 end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	457 end
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	458
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	459 assert(r1.state == "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	460 r1:run(4);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	461 assert(r1.state == "ready");
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	462
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	463 assert(r1.state == "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	464 --for k, v in ipairs(l1) do print(k,v) end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	465 end);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	466 it("should work work with multiple runners in parallel", function ()
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	467 --------------------
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	468 local wait1, done1;
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	469 local last_item1 = 0;
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	470 local r1 = new(function (item)
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	471 print("r1 processing ", item);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	472 assert(type(item) == "number")
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	473 assert((item == last_item1 + 1) or item == 3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	474 last_item1 = item;
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	475 if item == 3 then
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	476 wait1, done1 = async.waiter();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	477 wait1();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	478 end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	479 end, "r1");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	480
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	481 local wait2, done2;
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	482 local last_item2 = 0;
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	483 local r2 = new(function (item)
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	484 print("r2 processing ", item);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	485 assert.is_number(item);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	486 assert((item == last_item2 + 1) or item == 3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	487 last_item2 = item;
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	488 if item == 3 then
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	489 wait2, done2 = async.waiter();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	490 wait2();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	491 end
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	492 end, "r2");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	493
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	494 r1:run(1);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	495 assert.equal(r1.state, "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	496 r1:run(2);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	497 assert.equal(r1.state, "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	498
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	499 r1:run(5);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	500 assert.equal(r1.state, "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	501
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	502 r1:run(3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	503 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	504 r1:run(5); -- Will error, when we get to it
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	505 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	506 done1();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	507 assert.equal(r1.state, "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	508 r1:run(3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	509 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	510
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	511 r2:run(1);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	512 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	513 assert.equal(r2.state, "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	514
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	515 r2:run(2);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	516 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	517 assert.equal(r2.state, "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	518
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	519 r2:run(3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	520 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	521 assert.equal(r2.state, "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	522
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	523 done2();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	524 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	525 assert.equal(r2.state, "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	526
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	527 r2:run(3);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	528 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	529 assert.equal(r2.state, "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	530
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	531 done2();
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	532 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	533 assert.equal(r2.state, "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	534
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	535 r2:run(4);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	536 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	537 assert.equal(r2.state, "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	538
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	539 done1();
8622 92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck] Kim Alvefur <zash@zash.se> parents: 8618 diff changeset	540
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	541 assert.equal(r1.state, "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	542 r1:run(4);
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	543 assert.equal(r1.state, "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	544
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	545 assert.equal(r1.state, "ready");
3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	546 end);
8624 5325f0e1791b util.async: tests: Ensure done() can be called before wait() Matthew Wild <mwild1@gmail.com> parents: 8623 diff changeset	547
10541 6c6ff4509082 tests: Silence [luacheck] warnings Kim Alvefur <zash@zash.se> parents: 8683 diff changeset	548 -- luacheck: ignore 211/rf
6c6ff4509082 tests: Silence [luacheck] warnings Kim Alvefur <zash@zash.se> parents: 8683 diff changeset	549 -- FIXME what's rf?
8628 e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	550 it("should support multiple done() calls", function ()
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	551 local processed_item;
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	552 local wait, done;
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	553 local r, rf = new(function (item)
8628 e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	554 wait, done = async.waiter(4);
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	555 wait();
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	556 processed_item = item;
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	557 end);
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	558 r:run("test");
8632 02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	559 for _ = 1, 3 do
8628 e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	560 done();
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	561 assert.equal(r.state, "waiting");
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	562 assert.is_nil(processed_item);
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	563 end
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	564 done();
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	565 assert.equal(r.state, "ready");
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	566 assert.equal(processed_item, "test");
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	567 assert.spy(r.watchers.error).was_not.called();
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	568 end);
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	569
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	570 it("should not allow done() to be called more than specified", function ()
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	571 local processed_item;
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	572 local wait, done;
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	573 local r, rf = new(function (item)
8628 e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	574 wait, done = async.waiter(4);
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	575 wait();
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	576 processed_item = item;
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	577 end);
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	578 r:run("test");
8632 02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	579 for _ = 1, 4 do
8628 e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	580 done();
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	581 end
8632 02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues Matthew Wild <mwild1@gmail.com> parents: 8631 diff changeset	582 assert.has_error(done);
8628 e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	583 assert.equal(r.state, "ready");
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	584 assert.equal(processed_item, "test");
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	585 assert.spy(r.watchers.error).was_not.called();
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	586 end);
e88744fa0985 util.async: Add some more tests for wait/done Matthew Wild <mwild1@gmail.com> parents: 8624 diff changeset	587
8624 5325f0e1791b util.async: tests: Ensure done() can be called before wait() Matthew Wild <mwild1@gmail.com> parents: 8623 diff changeset	588 it("should allow done() to be called before wait()", function ()
5325f0e1791b util.async: tests: Ensure done() can be called before wait() Matthew Wild <mwild1@gmail.com> parents: 8623 diff changeset	589 local processed_item;
8633 8ec18a002c30 util.async: tests: more code re-use Matthew Wild <mwild1@gmail.com> parents: 8632 diff changeset	590 local r, rf = new(function (item)
8624 5325f0e1791b util.async: tests: Ensure done() can be called before wait() Matthew Wild <mwild1@gmail.com> parents: 8623 diff changeset	591 local wait, done = async.waiter();
5325f0e1791b util.async: tests: Ensure done() can be called before wait() Matthew Wild <mwild1@gmail.com> parents: 8623 diff changeset	592 done();
5325f0e1791b util.async: tests: Ensure done() can be called before wait() Matthew Wild <mwild1@gmail.com> parents: 8623 diff changeset	593 wait();
5325f0e1791b util.async: tests: Ensure done() can be called before wait() Matthew Wild <mwild1@gmail.com> parents: 8623 diff changeset	594 processed_item = item;
5325f0e1791b util.async: tests: Ensure done() can be called before wait() Matthew Wild <mwild1@gmail.com> parents: 8623 diff changeset	595 end);
5325f0e1791b util.async: tests: Ensure done() can be called before wait() Matthew Wild <mwild1@gmail.com> parents: 8623 diff changeset	596 r:run("test");
5325f0e1791b util.async: tests: Ensure done() can be called before wait() Matthew Wild <mwild1@gmail.com> parents: 8623 diff changeset	597 assert.equal(processed_item, "test");
5325f0e1791b util.async: tests: Ensure done() can be called before wait() Matthew Wild <mwild1@gmail.com> parents: 8623 diff changeset	598 assert.equal(r.state, "ready");
5325f0e1791b util.async: tests: Ensure done() can be called before wait() Matthew Wild <mwild1@gmail.com> parents: 8623 diff changeset	599 -- Since the observable state did not change,
5325f0e1791b util.async: tests: Ensure done() can be called before wait() Matthew Wild <mwild1@gmail.com> parents: 8623 diff changeset	600 -- the watchers should not have been called
5325f0e1791b util.async: tests: Ensure done() can be called before wait() Matthew Wild <mwild1@gmail.com> parents: 8623 diff changeset	601 assert.spy(r.watchers.waiting).was_not.called();
5325f0e1791b util.async: tests: Ensure done() can be called before wait() Matthew Wild <mwild1@gmail.com> parents: 8623 diff changeset	602 assert.spy(r.watchers.ready).was_not.called();
5325f0e1791b util.async: tests: Ensure done() can be called before wait() Matthew Wild <mwild1@gmail.com> parents: 8623 diff changeset	603 end);
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	604 end);
8648 ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8633 diff changeset	605
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8633 diff changeset	606 describe("#ready()", function ()
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8633 diff changeset	607 it("should return false outside an async context", function ()
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8633 diff changeset	608 assert.falsy(async.ready());
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8633 diff changeset	609 end);
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8633 diff changeset	610 it("should return true inside an async context", function ()
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8633 diff changeset	611 local r = new(function ()
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8633 diff changeset	612 assert.truthy(async.ready());
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8633 diff changeset	613 end);
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8633 diff changeset	614 r:run(true);
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8633 diff changeset	615 assert.spy(r.func).was.called();
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8633 diff changeset	616 assert.spy(r.watchers.error).was_not.called();
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8633 diff changeset	617 end);
ca710a71d730 util.async: Add ready() to check whether running in async context Matthew Wild <mwild1@gmail.com> parents: 8633 diff changeset	618 end);
11961 542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	619
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	620 describe("#sleep()", function ()
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	621 after_each(function ()
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	622 -- Restore to default
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	623 async.set_schedule_function(nil);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	624 end);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	625
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	626 it("should fail if no scheduler configured", function ()
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	627 local r = new(function ()
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	628 async.sleep(5);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	629 end);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	630 r:run(true);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	631 assert.spy(r.watchers.error).was.called();
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	632
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	633 -- Set dummy scheduler
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	634 async.set_schedule_function(function () end);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	635
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	636 local r2 = new(function ()
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	637 async.sleep(5);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	638 end);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	639 r2:run(true);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	640 assert.spy(r2.watchers.error).was_not.called();
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	641 end);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	642 it("should work", function ()
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	643 local queue = {};
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	644 local add_task = spy.new(function (t, f)
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	645 table.insert(queue, { t, f });
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	646 end);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	647 async.set_schedule_function(add_task);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	648
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	649 local processed_item;
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	650 local r = new(function (item)
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	651 async.sleep(5);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	652 processed_item = item;
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	653 end);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	654 r:run("test");
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	655
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	656 -- Nothing happened, because the runner is sleeping
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	657 assert.is_nil(processed_item);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	658 assert.equal(r.state, "waiting");
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	659 assert.spy(add_task).was_called(1);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	660 assert.spy(add_task).was_called_with(match.is_number(), match.is_function());
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	661 assert.spy(r.watchers.waiting).was.called();
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	662 assert.spy(r.watchers.ready).was_not.called();
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	663
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	664 -- Pretend the timer has triggered, call the handler
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	665 queue[1][2]();
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	666
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	667 assert.equal(processed_item, "test");
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	668 assert.equal(r.state, "ready");
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	669
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	670 assert.spy(r.watchers.ready).was.called();
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	671 end);
542a9a503073 util.async: Add sleep() method with configurable scheduling backend Matthew Wild <mwild1@gmail.com> parents: 10541 diff changeset	672 end);
11962 9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	673
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	674 describe("#set_nexttick()", function ()
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	675 after_each(function ()
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	676 -- Restore to default
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	677 async.set_nexttick(nil);
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	678 end);
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	679 it("should work", function ()
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	680 local queue = {};
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	681 local nexttick = spy.new(function (f)
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	682 assert.is_function(f);
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	683 table.insert(queue, f);
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	684 end);
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	685 async.set_nexttick(nexttick);
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	686
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	687 local processed_item;
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	688 local wait, done;
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	689 local r = new(function (item)
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	690 wait, done = async.waiter();
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	691 wait();
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	692 processed_item = item;
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	693 end);
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	694 r:run("test");
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	695
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	696 -- Nothing happened, because the runner is waiting
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	697 assert.is_nil(processed_item);
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	698 assert.equal(r.state, "waiting");
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	699 assert.spy(nexttick).was_called(0);
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	700 assert.spy(r.watchers.waiting).was.called();
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	701 assert.spy(r.watchers.ready).was_not.called();
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	702
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	703 -- Mark the runner as ready, it should be scheduled for
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	704 -- the next tick
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	705 done();
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	706
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	707 assert.spy(nexttick).was_called(1);
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	708 assert.spy(nexttick).was_called_with(match.is_function());
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	709 assert.equal(1, #queue);
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	710
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	711 -- Pretend it's the next tick - call the pending function
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	712 queue[1]();
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	713
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	714 assert.equal(processed_item, "test");
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	715 assert.equal(r.state, "ready");
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	716 assert.spy(r.watchers.ready).was.called();
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	717 end);
9a70a543c727 util.async: Add next-tick configuration Matthew Wild <mwild1@gmail.com> parents: 11961 diff changeset	718 end);
8605 3a1efc0532cb util.async: Add tests Matthew Wild <mwild1@gmail.com> parents: diff changeset	719 end);

prosody

c8f59ce7d3cf

spec/util_async_spec.lua

Software / code / prosody

Annotate

spec/util_async_spec.lua @ 12672:c8f59ce7d3cf

Software `/` code `/` prosody