prosody
3f49c35607ca
spec/util_async_spec.lua

Find changesets by keywords by author, files, the commit message, revision number or hash, or revset expression.

Software / code / prosody

Annotate

spec/util_async_spec.lua @ 11936:3f49c35607ca

mod_smacks: Fix timer lifetimes to follow session instead of module module:add_timer() creates a timer that stops working after the module is reloaded or unloaded, in order to prevent leaks. However, when the timers control vital session behavior, breakage occurs after reload. E.g. sessions would stop requesting acks and stop responding to acks.
author Kim Alvefur <zash@zash.se>
date Wed, 24 Nov 2021 21:27:45 +0100
parent 10541:6c6ff4509082
child 11961:542a9a503073
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
1 local async = require "util.async";
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
2
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
3 describe("util.async", function()
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
4 local debug = false;
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
5 local print = print;
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
6 if debug then
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
7 require "util.logger".add_simple_sink(print);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
8 else
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
9 print = function () end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
10 end
8623
ab242c513bf4 util.async: tests: Add helper function to create mock watcher callbacks
Matthew Wild <mwild1@gmail.com>
parents: 8622
diff changeset
11
8630
deade38ffbbd util.async: tests: slight modifications to allow more code reuse in tests
Matthew Wild <mwild1@gmail.com>
parents: 8628
diff changeset
12 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
13 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
14 return function (...)
deade38ffbbd util.async: tests: slight modifications to allow more code reuse in tests
Matthew Wild <mwild1@gmail.com>
parents: 8628
diff changeset
15 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
16 end;
deade38ffbbd util.async: tests: slight modifications to allow more code reuse in tests
Matthew Wild <mwild1@gmail.com>
parents: 8628
diff changeset
17 end;
8623
ab242c513bf4 util.async: tests: Add helper function to create mock watcher callbacks
Matthew Wild <mwild1@gmail.com>
parents: 8622
diff changeset
18 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
19 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
20 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
21 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
22 }, {
ab242c513bf4 util.async: tests: Add helper function to create mock watcher callbacks
Matthew Wild <mwild1@gmail.com>
parents: 8622
diff changeset
23 __index = function (_, event)
ab242c513bf4 util.async: tests: Add helper function to create mock watcher callbacks
Matthew Wild <mwild1@gmail.com>
parents: 8622
diff changeset
24 -- Unexpected watcher called
8632
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
25 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
26 end;
ab242c513bf4 util.async: tests: Add helper function to create mock watcher callbacks
Matthew Wild <mwild1@gmail.com>
parents: 8622
diff changeset
27 })
ab242c513bf4 util.async: tests: Add helper function to create mock watcher callbacks
Matthew Wild <mwild1@gmail.com>
parents: 8622
diff changeset
28 end
ab242c513bf4 util.async: tests: Add helper function to create mock watcher callbacks
Matthew Wild <mwild1@gmail.com>
parents: 8622
diff changeset
29
8632
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
30 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
31 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
32 local spy_func = spy.new(func);
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
33 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
34 end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
35 describe("#runner", function()
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
36 it("should work", function()
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
37 local r = new(function (item) assert(type(item) == "number") end);
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
38 r:run(1);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
39 r:run(2);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
40 end);
8607
62bb06cf8a43 util.async: Add tests to specifically cover error handling
Matthew Wild <mwild1@gmail.com>
parents: 8605
diff changeset
41
62bb06cf8a43 util.async: Add tests to specifically cover error handling
Matthew Wild <mwild1@gmail.com>
parents: 8605
diff changeset
42 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
43 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
44 assert.equal(r.state, "ready");
62bb06cf8a43 util.async: Add tests to specifically cover error handling
Matthew Wild <mwild1@gmail.com>
parents: 8605
diff changeset
45 end);
62bb06cf8a43 util.async: Add tests to specifically cover error handling
Matthew Wild <mwild1@gmail.com>
parents: 8605
diff changeset
46
8614
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
47 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
48 local did_run;
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
49 local r = new(function () did_run = true end);
8614
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
50 r:run();
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
51 assert.equal(r.state, "ready");
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
52 assert.is_nil(did_run);
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
53 r:run("hello");
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
54 assert.is_true(did_run);
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
55 end);
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
56
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
57 it("should support queuing work items without running", function ()
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
58 local did_run;
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
59 local r = new(function () did_run = true end);
8614
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
60 r:enqueue("hello");
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
61 assert.equal(r.state, "ready");
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
62 assert.is_nil(did_run);
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
63 r:run();
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
64 assert.is_true(did_run);
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
65 end);
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
66
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
67 it("should support queuing multiple work items", function ()
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
68 local last_item;
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
69 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
70 r:enqueue("hello");
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
71 r:enqueue("there");
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
72 r:enqueue("world");
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
73 assert.equal(r.state, "ready");
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
74 r:run();
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
75 assert.equal(r.state, "ready");
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
76 assert.spy(s).was.called(3);
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
77 assert.equal(last_item, "world");
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
78 end);
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
79
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
80 it("should support all simple data types", function ()
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
81 local last_item;
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
82 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
83 local values = { {}, 123, "hello", true, false };
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
84 for i = 1, #values do
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
85 r:enqueue(values[i]);
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
86 end
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
87 assert.equal(r.state, "ready");
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
88 r:run();
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
89 assert.equal(r.state, "ready");
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
90 assert.spy(s).was.called(#values);
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
91 for i = 1, #values do
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
92 assert.spy(s).was.called_with(values[i]);
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
93 end
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
94 assert.equal(last_item, values[#values]);
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
95 end);
bfbafeced0c4 util.async: Yet more tests
Matthew Wild <mwild1@gmail.com>
parents: 8609
diff changeset
96
8681
0c077800cd70 util.async: Make parameters to async.runner() optional
Matthew Wild <mwild1@gmail.com>
parents: 8669
diff changeset
97 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
98 local item = "fail";
0c077800cd70 util.async: Make parameters to async.runner() optional
Matthew Wild <mwild1@gmail.com>
parents: 8669
diff changeset
99 local r = async.runner();
0c077800cd70 util.async: Make parameters to async.runner() optional
Matthew Wild <mwild1@gmail.com>
parents: 8669
diff changeset
100 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
101 r:run(f);
0c077800cd70 util.async: Make parameters to async.runner() optional
Matthew Wild <mwild1@gmail.com>
parents: 8669
diff changeset
102 assert.spy(f).was.called();
0c077800cd70 util.async: Make parameters to async.runner() optional
Matthew Wild <mwild1@gmail.com>
parents: 8669
diff changeset
103 assert.equal(item, "success");
0c077800cd70 util.async: Make parameters to async.runner() optional
Matthew Wild <mwild1@gmail.com>
parents: 8669
diff changeset
104 end);
0c077800cd70 util.async: Make parameters to async.runner() optional
Matthew Wild <mwild1@gmail.com>
parents: 8669
diff changeset
105
0c077800cd70 util.async: Make parameters to async.runner() optional
Matthew Wild <mwild1@gmail.com>
parents: 8669
diff changeset
106 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
107 local item = "fail";
0c077800cd70 util.async: Make parameters to async.runner() optional
Matthew Wild <mwild1@gmail.com>
parents: 8669
diff changeset
108 local r = async.runner();
0c077800cd70 util.async: Make parameters to async.runner() optional
Matthew Wild <mwild1@gmail.com>
parents: 8669
diff changeset
109 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
110 assert.error_matches(function ()
0c077800cd70 util.async: Make parameters to async.runner() optional
Matthew Wild <mwild1@gmail.com>
parents: 8669
diff changeset
111 r:run(f);
0c077800cd70 util.async: Make parameters to async.runner() optional
Matthew Wild <mwild1@gmail.com>
parents: 8669
diff changeset
112 end, "test error");
0c077800cd70 util.async: Make parameters to async.runner() optional
Matthew Wild <mwild1@gmail.com>
parents: 8669
diff changeset
113 assert.spy(f).was.called();
0c077800cd70 util.async: Make parameters to async.runner() optional
Matthew Wild <mwild1@gmail.com>
parents: 8669
diff changeset
114 assert.equal(item, "fail");
0c077800cd70 util.async: Make parameters to async.runner() optional
Matthew Wild <mwild1@gmail.com>
parents: 8669
diff changeset
115 end);
0c077800cd70 util.async: Make parameters to async.runner() optional
Matthew Wild <mwild1@gmail.com>
parents: 8669
diff changeset
116
8607
62bb06cf8a43 util.async: Add tests to specifically cover error handling
Matthew Wild <mwild1@gmail.com>
parents: 8605
diff changeset
117 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
118 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
119 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
120 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
121 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
122 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
123 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
124 end
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour
Matthew Wild <mwild1@gmail.com>
parents: 8617
diff changeset
125 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
126 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
127 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
128 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
129 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
130 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
131 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
132 end;
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour
Matthew Wild <mwild1@gmail.com>
parents: 8617
diff changeset
133 });
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 -- 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
136 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
137 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
138 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
139 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
140 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
141
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour
Matthew Wild <mwild1@gmail.com>
parents: 8617
diff changeset
142 -- 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
143 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
144 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
145 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
146 -- 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
147 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
148 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
149 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
150 end);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour
Matthew Wild <mwild1@gmail.com>
parents: 8617
diff changeset
151 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
152 -- 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
153 -- 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
154 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
155 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
156 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
157 end);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour
Matthew Wild <mwild1@gmail.com>
parents: 8617
diff changeset
158 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
159 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
160 end);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour
Matthew Wild <mwild1@gmail.com>
parents: 8617
diff changeset
161
8632
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
162 do
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
163 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
164 local r;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
165 local wait, done;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
166 r = async.runner(function (item)
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
167 if item == "error" then
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
168 error({ e = "test error" });
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
169 elseif item == "wait" then
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
170 wait, done = async.waiter();
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
171 wait();
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
172 error({ e = "post wait error" });
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
173 end
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
174 last_processed_item = item;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
175 end, mock({
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
176 ready = function () end;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
177 waiting = function () end;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
178 error = function (runner, err)
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
179 assert.equal(r, runner);
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
180 last_error = err;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
181 end;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
182 }));
8618
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour
Matthew Wild <mwild1@gmail.com>
parents: 8617
diff changeset
183
8632
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
184 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
185
8632
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
186 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
187 r:run("world");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
188 assert.equal(r.state, "ready");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
189 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
190 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
191 end);
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
192 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
193 -- 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
194 -- 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
195 -- 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
196 -- 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
197 last_error = nil;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
198 r:run("wait");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
199 assert.equal(r.state, "waiting");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
200 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
201 done();
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
202 -- 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
203 assert.equal(r.state, "ready");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
204 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
205 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
206 assert.is_table(last_error);
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
207 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
208 last_error = nil;
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
209 r:run("hello again");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
210 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
211 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
212 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
213 assert.equal(r.state, "ready");
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
214 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
215 end);
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
216 end
8615
e77b37de482e util.async: Behaviour change: continue to process queued items after errors
Matthew Wild <mwild1@gmail.com>
parents: 8614
diff changeset
217
e77b37de482e util.async: Behaviour change: continue to process queued items after errors
Matthew Wild <mwild1@gmail.com>
parents: 8614
diff changeset
218 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
219 local last_item;
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
220 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
221 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
222 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
223 end
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour
Matthew Wild <mwild1@gmail.com>
parents: 8617
diff changeset
224 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
225 end);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour
Matthew Wild <mwild1@gmail.com>
parents: 8617
diff changeset
226 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
227 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
228 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
229 runner:run();
8632
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
230 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
231 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
232 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
233 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
234 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
235 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
236 end);
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour
Matthew Wild <mwild1@gmail.com>
parents: 8617
diff changeset
237
680b1caa2dea util.async: tests: replace peeking at internal state with monitoring correct callback behaviour
Matthew Wild <mwild1@gmail.com>
parents: 8617
diff changeset
238 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
239 local wait, done, last_item;
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
240 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
241 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
242 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
243 wait();
e77b37de482e util.async: Behaviour change: continue to process queued items after errors
Matthew Wild <mwild1@gmail.com>
parents: 8614
diff changeset
244 error("test error");
e77b37de482e util.async: Behaviour change: continue to process queued items after errors
Matthew Wild <mwild1@gmail.com>
parents: 8614
diff changeset
245 end
e77b37de482e util.async: Behaviour change: continue to process queued items after errors
Matthew Wild <mwild1@gmail.com>
parents: 8614
diff changeset
246 last_item = item;
e77b37de482e util.async: Behaviour change: continue to process queued items after errors
Matthew Wild <mwild1@gmail.com>
parents: 8614
diff changeset
247 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
248 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
249 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
250 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
251 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
252 done();
8632
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
253 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
254 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
255 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
256 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
257 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
258 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
259 end);
8607
62bb06cf8a43 util.async: Add tests to specifically cover error handling
Matthew Wild <mwild1@gmail.com>
parents: 8605
diff changeset
260 end);
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
261 end);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
262 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
263 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
264 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
265 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
266 end);
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);
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
268 it("should work", function ()
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
269 local wait, done;
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
270
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
271 local r = new(function (item)
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
272 assert(type(item) == "number")
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
273 if item == 3 then
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
274 wait, done = async.waiter();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
275 wait();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
276 end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
277 end);
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
278
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
279 r:run(1);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
280 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
281 r:run(2);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
282 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
283 r:run(3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
284 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
285 done();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
286 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
287 --for k, v in ipairs(l) do print(k,v) end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
288 end);
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
289
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
290 it("should work", function ()
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
291 --------------------
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
292 local wait, done;
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
293 local last_item = 0;
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
294 local r = new(function (item)
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
295 assert(type(item) == "number")
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
296 assert(item == last_item + 1);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
297 last_item = item;
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
298 if item == 3 then
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
299 wait, done = async.waiter();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
300 wait();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
301 end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
302 end);
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
303
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
304 r:run(1);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
305 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
306 r:run(2);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
307 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
308 r:run(3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
309 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
310 r:run(4);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
311 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
312 done();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
313 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
314 --for k, v in ipairs(l) do print(k,v) end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
315 end);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
316 it("should work", function ()
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
317 --------------------
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
318 local wait, done;
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
319 local last_item = 0;
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
320 local r = new(function (item)
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
321 assert(type(item) == "number")
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
322 assert((item == last_item + 1) or item == 3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
323 last_item = item;
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
324 if item == 3 then
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
325 wait, done = async.waiter();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
326 wait();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
327 end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
328 end);
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
329
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
330 r:run(1);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
331 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
332 r:run(2);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
333 assert(r.state == "ready");
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
334
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
335 r:run(3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
336 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
337 r:run(3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
338 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
339 r:run(3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
340 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
341 r:run(4);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
342 assert(r.state == "waiting");
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
343
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
344 for i = 1, 3 do
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
345 done();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
346 if i < 3 then
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
347 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
348 end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
349 end
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
350
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
351 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
352 --for k, v in ipairs(l) do print(k,v) end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
353 end);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
354 it("should work", function ()
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
355 --------------------
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
356 local wait, done;
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
357 local last_item = 0;
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
358 local r = new(function (item)
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
359 assert(type(item) == "number")
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
360 assert((item == last_item + 1) or item == 3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
361 last_item = item;
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
362 if item == 3 then
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
363 wait, done = async.waiter();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
364 wait();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
365 end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
366 end);
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
367
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
368 r:run(1);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
369 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
370 r:run(2);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
371 assert(r.state == "ready");
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
372
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
373 r:run(3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
374 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
375 r:run(3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
376 assert(r.state == "waiting");
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
377
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
378 for i = 1, 2 do
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
379 done();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
380 if i < 2 then
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
381 assert(r.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
382 end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
383 end
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
384
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
385 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
386 r:run(4);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
387 assert(r.state == "ready");
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
388
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
389 assert(r.state == "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
390 --for k, v in ipairs(l) do print(k,v) end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
391 end);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
392 it("should work with multiple runners in parallel", function ()
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
393 -- Now with multiple runners
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
394 --------------------
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
395 local wait1, done1;
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
396 local last_item1 = 0;
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
397 local r1 = new(function (item)
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
398 assert(type(item) == "number")
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
399 assert((item == last_item1 + 1) or item == 3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
400 last_item1 = item;
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
401 if item == 3 then
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
402 wait1, done1 = async.waiter();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
403 wait1();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
404 end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
405 end, "r1");
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
406
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
407 local wait2, done2;
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
408 local last_item2 = 0;
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
409 local r2 = new(function (item)
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
410 assert(type(item) == "number")
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
411 assert((item == last_item2 + 1) or item == 3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
412 last_item2 = item;
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
413 if item == 3 then
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
414 wait2, done2 = async.waiter();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
415 wait2();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
416 end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
417 end, "r2");
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
418
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
419 r1:run(1);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
420 assert(r1.state == "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
421 r1:run(2);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
422 assert(r1.state == "ready");
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
423
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
424 r1:run(3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
425 assert(r1.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
426 r1:run(3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
427 assert(r1.state == "waiting");
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
428
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
429 r2:run(1);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
430 assert(r1.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
431 assert(r2.state == "ready");
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
432
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
433 r2:run(2);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
434 assert(r1.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
435 assert(r2.state == "ready");
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
436
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
437 r2:run(3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
438 assert(r1.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
439 assert(r2.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
440 done2();
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
441
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
442 r2:run(3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
443 assert(r1.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
444 assert(r2.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
445 done2();
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
446
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
447 r2:run(4);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
448 assert(r1.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
449 assert(r2.state == "ready");
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
450
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
451 for i = 1, 2 do
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
452 done1();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
453 if i < 2 then
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
454 assert(r1.state == "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
455 end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
456 end
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
457
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
458 assert(r1.state == "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
459 r1:run(4);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
460 assert(r1.state == "ready");
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
461
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
462 assert(r1.state == "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
463 --for k, v in ipairs(l1) do print(k,v) end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
464 end);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
465 it("should work work with multiple runners in parallel", function ()
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
466 --------------------
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
467 local wait1, done1;
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
468 local last_item1 = 0;
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
469 local r1 = new(function (item)
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
470 print("r1 processing ", item);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
471 assert(type(item) == "number")
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
472 assert((item == last_item1 + 1) or item == 3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
473 last_item1 = item;
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
474 if item == 3 then
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
475 wait1, done1 = async.waiter();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
476 wait1();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
477 end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
478 end, "r1");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
479
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
480 local wait2, done2;
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
481 local last_item2 = 0;
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
482 local r2 = new(function (item)
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
483 print("r2 processing ", item);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
484 assert.is_number(item);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
485 assert((item == last_item2 + 1) or item == 3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
486 last_item2 = item;
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
487 if item == 3 then
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
488 wait2, done2 = async.waiter();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
489 wait2();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
490 end
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
491 end, "r2");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
492
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
493 r1:run(1);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
494 assert.equal(r1.state, "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
495 r1:run(2);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
496 assert.equal(r1.state, "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
497
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
498 r1:run(5);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
499 assert.equal(r1.state, "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
500
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
501 r1:run(3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
502 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
503 r1:run(5); -- Will error, when we get to it
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
504 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
505 done1();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
506 assert.equal(r1.state, "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
507 r1:run(3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
508 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
509
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
510 r2:run(1);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
511 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
512 assert.equal(r2.state, "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
513
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
514 r2:run(2);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
515 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
516 assert.equal(r2.state, "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
517
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
518 r2:run(3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
519 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
520 assert.equal(r2.state, "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
521
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
522 done2();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
523 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
524 assert.equal(r2.state, "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
525
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
526 r2:run(3);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
527 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
528 assert.equal(r2.state, "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
529
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
530 done2();
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
531 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
532 assert.equal(r2.state, "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
533
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
534 r2:run(4);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
535 assert.equal(r1.state, "waiting");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
536 assert.equal(r2.state, "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
537
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
538 done1();
8622
92fee8a6c988 util.async: Trim trailing whitespace in tests [luacheck]
Kim Alvefur <zash@zash.se>
parents: 8618
diff changeset
539
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
540 assert.equal(r1.state, "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
541 r1:run(4);
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
542 assert.equal(r1.state, "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
543
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
544 assert.equal(r1.state, "ready");
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
545 end);
8624
5325f0e1791b util.async: tests: Ensure done() can be called before wait()
Matthew Wild <mwild1@gmail.com>
parents: 8623
diff changeset
546
10541
6c6ff4509082 tests: Silence [luacheck] warnings
Kim Alvefur <zash@zash.se>
parents: 8683
diff changeset
547 -- luacheck: ignore 211/rf
6c6ff4509082 tests: Silence [luacheck] warnings
Kim Alvefur <zash@zash.se>
parents: 8683
diff changeset
548 -- FIXME what's rf?
8628
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
549 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
550 local processed_item;
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
551 local wait, done;
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
552 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
553 wait, done = async.waiter(4);
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
554 wait();
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
555 processed_item = item;
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
556 end);
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
557 r:run("test");
8632
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
558 for _ = 1, 3 do
8628
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
559 done();
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
560 assert.equal(r.state, "waiting");
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
561 assert.is_nil(processed_item);
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
562 end
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
563 done();
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
564 assert.equal(r.state, "ready");
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
565 assert.equal(processed_item, "test");
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
566 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
567 end);
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
568
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
569 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
570 local processed_item;
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
571 local wait, done;
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
572 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
573 wait, done = async.waiter(4);
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
574 wait();
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
575 processed_item = item;
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
576 end);
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
577 r:run("test");
8632
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
578 for _ = 1, 4 do
8628
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
579 done();
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
580 end
8632
02b841ed03d1 util.async: tests: luacheck-clean, fixes some actual issues
Matthew Wild <mwild1@gmail.com>
parents: 8631
diff changeset
581 assert.has_error(done);
8628
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
582 assert.equal(r.state, "ready");
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
583 assert.equal(processed_item, "test");
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
584 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
585 end);
e88744fa0985 util.async: Add some more tests for wait/done
Matthew Wild <mwild1@gmail.com>
parents: 8624
diff changeset
586
8624
5325f0e1791b util.async: tests: Ensure done() can be called before wait()
Matthew Wild <mwild1@gmail.com>
parents: 8623
diff changeset
587 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
588 local processed_item;
8633
8ec18a002c30 util.async: tests: more code re-use
Matthew Wild <mwild1@gmail.com>
parents: 8632
diff changeset
589 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
590 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
591 done();
5325f0e1791b util.async: tests: Ensure done() can be called before wait()
Matthew Wild <mwild1@gmail.com>
parents: 8623
diff changeset
592 wait();
5325f0e1791b util.async: tests: Ensure done() can be called before wait()
Matthew Wild <mwild1@gmail.com>
parents: 8623
diff changeset
593 processed_item = item;
5325f0e1791b util.async: tests: Ensure done() can be called before wait()
Matthew Wild <mwild1@gmail.com>
parents: 8623
diff changeset
594 end);
5325f0e1791b util.async: tests: Ensure done() can be called before wait()
Matthew Wild <mwild1@gmail.com>
parents: 8623
diff changeset
595 r:run("test");
5325f0e1791b util.async: tests: Ensure done() can be called before wait()
Matthew Wild <mwild1@gmail.com>
parents: 8623
diff changeset
596 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
597 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
598 -- 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
599 -- 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
600 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
601 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
602 end);
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
603 end);
8648
ca710a71d730 util.async: Add ready() to check whether running in async context
Matthew Wild <mwild1@gmail.com>
parents: 8633
diff changeset
604
ca710a71d730 util.async: Add ready() to check whether running in async context
Matthew Wild <mwild1@gmail.com>
parents: 8633
diff changeset
605 describe("#ready()", function ()
ca710a71d730 util.async: Add ready() to check whether running in async context
Matthew Wild <mwild1@gmail.com>
parents: 8633
diff changeset
606 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
607 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
608 end);
ca710a71d730 util.async: Add ready() to check whether running in async context
Matthew Wild <mwild1@gmail.com>
parents: 8633
diff changeset
609 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
610 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
611 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
612 end);
ca710a71d730 util.async: Add ready() to check whether running in async context
Matthew Wild <mwild1@gmail.com>
parents: 8633
diff changeset
613 r:run(true);
ca710a71d730 util.async: Add ready() to check whether running in async context
Matthew Wild <mwild1@gmail.com>
parents: 8633
diff changeset
614 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
615 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
616 end);
ca710a71d730 util.async: Add ready() to check whether running in async context
Matthew Wild <mwild1@gmail.com>
parents: 8633
diff changeset
617 end);
8605
3a1efc0532cb util.async: Add tests
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
618 end);