util.signal: Add support for signalfd(2) on Linux
signalfd allows handling signal events using the same method as sockets,
via file descriptors. Thus all signal dispatch can go through the same
main event loop as everything else, removing need for thread-scary
signal handling where execution would just jump to the signal handler
regardless of the state of Lua, and needing to keep track of Lua
states/threads.
describe("util.fsm", function ()
local new_fsm = require "util.fsm".new;
do
local fsm = new_fsm({
transitions = {
{ name = "melt", from = "solid", to = "liquid" };
{ name = "freeze", from = "liquid", to = "solid" };
};
});
it("works", function ()
local water = fsm:init("liquid");
water:freeze();
assert.equal("solid", water.state);
water:melt();
assert.equal("liquid", water.state);
end);
it("does not allow invalid transitions", function ()
local water = fsm:init("liquid");
assert.has_errors(function ()
water:melt();
end, "Invalid state transition: liquid cannot melt");
water:freeze();
assert.equal("solid", water.state);
water:melt();
assert.equal("liquid", water.state);
assert.has_errors(function ()
water:melt();
end, "Invalid state transition: liquid cannot melt");
end);
end
it("notifies observers", function ()
local n = 0;
local has_become_solid = spy.new(function (transition)
assert.is_table(transition);
assert.equal("solid", transition.to);
assert.is_not_nil(transition.instance);
n = n + 1;
if n == 1 then
assert.is_nil(transition.from);
assert.is_nil(transition.from_attr);
elseif n == 2 then
assert.equal("liquid", transition.from);
assert.is_nil(transition.from_attr);
assert.equal("freeze", transition.name);
end
end);
local is_melting = spy.new(function (transition)
assert.is_table(transition);
assert.equal("melt", transition.name);
assert.is_not_nil(transition.instance);
end);
local fsm = new_fsm({
transitions = {
{ name = "melt", from = "solid", to = "liquid" };
{ name = "freeze", from = "liquid", to = "solid" };
};
state_handlers = {
solid = has_become_solid;
};
transition_handlers = {
melt = is_melting;
};
});
local water = fsm:init("liquid");
assert.spy(has_become_solid).was_not_called();
local ice = fsm:init("solid"); --luacheck: ignore 211/ice
assert.spy(has_become_solid).was_called(1);
water:freeze();
assert.spy(is_melting).was_not_called();
water:melt();
assert.spy(is_melting).was_called(1);
end);
local function test_machine(fsm_spec, expected_transitions, test_func)
fsm_spec.handlers = fsm_spec.handlers or {};
fsm_spec.handlers.transitioned = function (transition)
local expected_transition = table.remove(expected_transitions, 1);
assert.same(expected_transition, {
name = transition.name;
to = transition.to;
to_attr = transition.to_attr;
from = transition.from;
from_attr = transition.from_attr;
});
end;
local fsm = new_fsm(fsm_spec);
test_func(fsm);
assert.equal(0, #expected_transitions);
end
it("handles transitions with the same name", function ()
local expected_transitions = {
{ name = nil , from = "none", to = "A" };
{ name = "step", from = "A", to = "B" };
{ name = "step", from = "B", to = "C" };
{ name = "step", from = "C", to = "D" };
};
test_machine({
default_state = "none";
transitions = {
{ name = "step", from = "A", to = "B" };
{ name = "step", from = "B", to = "C" };
{ name = "step", from = "C", to = "D" };
};
}, expected_transitions, function (fsm)
local i = fsm:init("A");
i:step(); -- B
i:step(); -- C
i:step(); -- D
assert.has_errors(function ()
i:step();
end, "Invalid state transition: D cannot step");
end);
end);
it("handles supports wildcard transitions", function ()
local expected_transitions = {
{ name = nil , from = "none", to = "A" };
{ name = "step", from = "A", to = "B" };
{ name = "step", from = "B", to = "C" };
{ name = "reset", from = "C", to = "A" };
{ name = "step", from = "A", to = "B" };
{ name = "step", from = "B", to = "C" };
{ name = "step", from = "C", to = "D" };
};
test_machine({
default_state = "none";
transitions = {
{ name = "step", from = "A", to = "B" };
{ name = "step", from = "B", to = "C" };
{ name = "step", from = "C", to = "D" };
{ name = "reset", from = "*", to = "A" };
};
}, expected_transitions, function (fsm)
local i = fsm:init("A");
i:step(); -- B
i:step(); -- C
i:reset(); -- A
i:step(); -- B
i:step(); -- C
i:step(); -- D
assert.has_errors(function ()
i:step();
end, "Invalid state transition: D cannot step");
end);
end);
it("supports specifying multiple from states", function ()
local expected_transitions = {
{ name = nil , from = "none", to = "A" };
{ name = "step", from = "A", to = "B" };
{ name = "step", from = "B", to = "C" };
{ name = "reset", from = "C", to = "A" };
{ name = "step", from = "A", to = "B" };
{ name = "step", from = "B", to = "C" };
{ name = "step", from = "C", to = "D" };
};
test_machine({
default_state = "none";
transitions = {
{ name = "step", from = "A", to = "B" };
{ name = "step", from = "B", to = "C" };
{ name = "step", from = "C", to = "D" };
{ name = "reset", from = {"B", "C", "D"}, to = "A" };
};
}, expected_transitions, function (fsm)
local i = fsm:init("A");
i:step(); -- B
i:step(); -- C
i:reset(); -- A
assert.has_errors(function ()
i:reset();
end, "Invalid state transition: A cannot reset");
i:step(); -- B
i:step(); -- C
i:step(); -- D
assert.has_errors(function ()
i:step();
end, "Invalid state transition: D cannot step");
end);
end);
it("handles transitions with the same start/end state", function ()
local expected_transitions = {
{ name = nil , from = "none", to = "A" };
{ name = "step", from = "A", to = "B" };
{ name = "step", from = "B", to = "B" };
{ name = "step", from = "B", to = "B" };
};
test_machine({
default_state = "none";
transitions = {
{ name = "step", from = "A", to = "B" };
{ name = "step", from = "B", to = "B" };
};
}, expected_transitions, function (fsm)
local i = fsm:init("A");
i:step(); -- B
i:step(); -- B
i:step(); -- B
end);
end);
it("can identify instances of a specific fsm", function ()
local fsm1 = new_fsm({ default_state = "a" });
local fsm2 = new_fsm({ default_state = "a" });
local i1 = fsm1:init();
local i2 = fsm2:init();
assert.truthy(fsm1:is_instance(i1));
assert.truthy(fsm2:is_instance(i2));
assert.falsy(fsm1:is_instance(i2));
assert.falsy(fsm2:is_instance(i1));
end);
it("errors when an invalid initial state is passed", function ()
local fsm1 = new_fsm({
transitions = {
{ name = "", from = "A", to = "B" };
};
});
assert.has_no_errors(function ()
fsm1:init("A");
end);
assert.has_errors(function ()
fsm1:init("C");
end);
end);
end);