255 lines
6.9 KiB
Lua
255 lines
6.9 KiB
Lua
require("awful._compat")
|
|
|
|
local runner = require( "_runner" )
|
|
local placement = require( "awful.placement" )
|
|
local gtable = require( "gears.table" )
|
|
local test_client = require( "_client" )
|
|
|
|
local module = {
|
|
key = require( "awful.key" ),
|
|
button = require( "awful.button" )
|
|
}
|
|
|
|
local steps = {}
|
|
|
|
local second = {
|
|
key = { "a", "b", "c", "d" },
|
|
button = { 1 , 2 , 3 , 4 },
|
|
}
|
|
|
|
local function send_events(event_type, step)
|
|
root.fake_input("key_press" , "Alt_L")
|
|
root.fake_input(event_type.."_press" , second[event_type][step])
|
|
root.fake_input(event_type.."_release", second[event_type][step])
|
|
root.fake_input("key_release", "Alt_L")
|
|
end
|
|
|
|
-- Test the shared API between the keys and buttons
|
|
for _, type_name in ipairs { "key", "button" } do
|
|
local objects = {}
|
|
|
|
local pressed, released = {}, {}
|
|
|
|
table.insert(steps, function()
|
|
objects[1] = module[type_name](
|
|
{"Mod1"}, second[type_name][1], function() pressed[1] = true end, function() released[1] = true end
|
|
)
|
|
|
|
assert(objects[1].has_root_binding == false)
|
|
assert(not pressed [1])
|
|
assert(not released[1])
|
|
|
|
root["_append_"..type_name](objects[1])
|
|
|
|
-- It is async, the result need to be verified later
|
|
return true
|
|
end)
|
|
|
|
table.insert(steps, function()
|
|
assert(objects[1].has_root_binding)
|
|
|
|
-- Test "artificial" execution
|
|
objects[1]:trigger()
|
|
|
|
assert(pressed [1])
|
|
assert(released[1])
|
|
|
|
-- Test adding and removing in the same iteration
|
|
root["_remove_"..type_name](objects[1])
|
|
|
|
assert(second[type_name][2])
|
|
|
|
-- Use the multiple parameters syntax.
|
|
objects[2] = module[type_name](
|
|
{"Mod1"}, second[type_name][2], function() pressed[2] = true end, function() released[2] = true end
|
|
)
|
|
|
|
root["_append_"..type_name](objects[2])
|
|
|
|
return true
|
|
end)
|
|
|
|
table.insert(steps, function()
|
|
assert(objects[2].has_root_binding == true )
|
|
assert(objects[1].has_root_binding == false)
|
|
|
|
-- Make sure the cursor is not over the wibar
|
|
placement.centered(mouse)
|
|
|
|
assert(second[type_name][2])
|
|
send_events(type_name, 2)
|
|
|
|
return true
|
|
end)
|
|
|
|
-- Wait until the events are registered.
|
|
table.insert(steps, function()
|
|
if (not pressed[2]) or (not released[2]) then return end
|
|
|
|
-- Spawn a client.
|
|
test_client("myclient")
|
|
|
|
return true
|
|
end)
|
|
|
|
--FIXME it works when manually tested, but automated testing is too flacky
|
|
-- to enable...
|
|
if type_name == "key" then
|
|
table.insert(steps, function()
|
|
if #mouse.screen.clients ~= 1 then return end
|
|
|
|
placement.maximize(mouse.screen.clients[1])
|
|
|
|
return true
|
|
end)
|
|
|
|
local o1, o2 = nil
|
|
|
|
table.insert(steps, function()
|
|
local c = mouse.screen.clients[1]
|
|
|
|
-- This time, use the `args` syntax.
|
|
local args = {
|
|
modifiers = {"Mod1"},
|
|
on_press = function() pressed [3] = true end,
|
|
on_release = function() released[3] = true end
|
|
}
|
|
|
|
args[type_name] = second[type_name][3]
|
|
|
|
-- This time, use the `args` syntax.
|
|
o1 = module[type_name](args)
|
|
|
|
-- Test the old API.
|
|
c[type_name.."s"](c, gtable.join(o1))
|
|
|
|
return true
|
|
end)
|
|
|
|
-- This wont work until the client buttons/keys are updated, there is no
|
|
-- way to know ahead of time.
|
|
table.insert(steps, function(count)
|
|
|
|
if count < 5 then awesome.sync(); return end
|
|
|
|
send_events(type_name, 3)
|
|
|
|
return true
|
|
end)
|
|
|
|
table.insert(steps, function()
|
|
if (not pressed[3]) or (not released[3]) then return end
|
|
|
|
local c = mouse.screen.clients[1]
|
|
|
|
-- Unset the events to make sure keys can be removed.
|
|
pressed[3], released[3] = false, false
|
|
|
|
o2 = module[type_name](
|
|
{"Mod1"}, second[type_name][4], function() pressed[4] = true end, function() released[4] = true end
|
|
)
|
|
|
|
-- Test the new API
|
|
c[type_name.."s"] = {o2}
|
|
|
|
return true
|
|
end)
|
|
|
|
table.insert(steps, function(count)
|
|
if count < 5 then awesome.sync(); return end
|
|
|
|
send_events(type_name, 3)
|
|
send_events(type_name, 4)
|
|
|
|
return true
|
|
end)
|
|
|
|
table.insert(steps, function()
|
|
if (not pressed[4]) or (not released[4]) then return end
|
|
|
|
assert(not pressed [3])
|
|
assert(not released[3])
|
|
|
|
local c = mouse.screen.clients[1]
|
|
|
|
-- Make sure mixing the 2 syntaxes doesn't create a chimera state
|
|
pressed[4], released[4] = false, false
|
|
|
|
-- This *will* happen with older configs because `awful.rules` will
|
|
-- loop the properties, find the old capi list and fail to understand
|
|
-- that the content should use the legacy API.
|
|
|
|
local joined = gtable.join(o1)
|
|
|
|
assert(#joined == 4)
|
|
|
|
c[type_name.."s"] = joined
|
|
|
|
-- It should have been converted to the new format.
|
|
assert(#c[type_name.."s"] == 1)
|
|
|
|
return true
|
|
end)
|
|
|
|
table.insert(steps, function(count)
|
|
if count < 5 then awesome.sync(); return end
|
|
|
|
send_events(type_name, 3)
|
|
send_events(type_name, 4)
|
|
|
|
return true
|
|
end)
|
|
|
|
table.insert(steps, function()
|
|
if (not pressed[3]) or (not released[3]) then return end
|
|
|
|
assert(not pressed [4])
|
|
assert(not released[4])
|
|
|
|
local c = mouse.screen.clients[1]
|
|
|
|
assert(#c[type_name.."s"] == 1)
|
|
|
|
-- Test setting the object to `false` to simulate an inline Lua
|
|
-- expression gone wrong. This used to work and is rather
|
|
-- convenient, so lets not break it even if it is technically a bug.
|
|
c[type_name.."s"] = false
|
|
|
|
assert(#c[type_name.."s"] == 0)
|
|
|
|
c[type_name.."s"] = {o1}
|
|
|
|
assert(#c[type_name.."s"] == 1)
|
|
|
|
-- Test removing the objects using `nil`.
|
|
c[type_name.."s"] = nil
|
|
|
|
assert(#c[type_name.."s"] == 0)
|
|
|
|
c[type_name.."s"] = {o1}
|
|
|
|
assert(#c[type_name.."s"] == 1)
|
|
|
|
-- Test removing using `{}`
|
|
c[type_name.."s"] = {}
|
|
|
|
assert(#c[type_name.."s"] == 0)
|
|
|
|
c:kill()
|
|
|
|
return true
|
|
end)
|
|
|
|
-- Cleanup (otherwise there is a race with the root.buttons tests)
|
|
table.insert(steps, function()
|
|
if #mouse.screen.clients ~= 0 then return end
|
|
|
|
return true
|
|
end)
|
|
end
|
|
end
|
|
|
|
runner.run_steps(steps)
|
|
|
|
-- vim: filetype=lua:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80
|