731 lines
16 KiB
Lua
731 lines
16 KiB
Lua
local lu = require("testing.luaunit")
|
|
local FlexLove = require("FlexLove")
|
|
local Gui = FlexLove.Gui
|
|
local Element = FlexLove.Element
|
|
|
|
TestKeyboardInput = {}
|
|
|
|
-- Helper function to ensure clean keyboard state
|
|
local function clearModifierKeys()
|
|
love.keyboard.setDown("lshift", false)
|
|
love.keyboard.setDown("rshift", false)
|
|
love.keyboard.setDown("lctrl", false)
|
|
love.keyboard.setDown("rctrl", false)
|
|
love.keyboard.setDown("lalt", false)
|
|
love.keyboard.setDown("ralt", false)
|
|
love.keyboard.setDown("lgui", false)
|
|
love.keyboard.setDown("rgui", false)
|
|
end
|
|
|
|
function TestKeyboardInput:setUp()
|
|
-- Clear all keyboard modifier states at start of each test
|
|
if love.keyboard.isDown("lgui", "rgui", "lalt", "ralt", "lctrl", "rctrl", "lshift", "rshift") then
|
|
local mods = {}
|
|
if love.keyboard.isDown("lshift") then table.insert(mods, "lshift") end
|
|
if love.keyboard.isDown("rshift") then table.insert(mods, "rshift") end
|
|
if love.keyboard.isDown("lctrl") then table.insert(mods, "lctrl") end
|
|
if love.keyboard.isDown("rctrl") then table.insert(mods, "rctrl") end
|
|
if love.keyboard.isDown("lalt") then table.insert(mods, "lalt") end
|
|
if love.keyboard.isDown("ralt") then table.insert(mods, "ralt") end
|
|
if love.keyboard.isDown("lgui") then table.insert(mods, "lgui") end
|
|
if love.keyboard.isDown("rgui") then table.insert(mods, "rgui") end
|
|
print("WARNING: Modifiers down at setUp: " .. table.concat(mods, ", "))
|
|
end
|
|
love.keyboard.setDown("lshift", false)
|
|
love.keyboard.setDown("rshift", false)
|
|
love.keyboard.setDown("lctrl", false)
|
|
love.keyboard.setDown("rctrl", false)
|
|
love.keyboard.setDown("lalt", false)
|
|
love.keyboard.setDown("ralt", false)
|
|
love.keyboard.setDown("lgui", false)
|
|
love.keyboard.setDown("rgui", false)
|
|
|
|
Gui.init({ baseScale = { width = 1920, height = 1080 } })
|
|
end
|
|
|
|
function TestKeyboardInput:tearDown()
|
|
-- Clear all keyboard modifier states
|
|
love.keyboard.setDown("lshift", false)
|
|
love.keyboard.setDown("rshift", false)
|
|
love.keyboard.setDown("lctrl", false)
|
|
love.keyboard.setDown("rctrl", false)
|
|
love.keyboard.setDown("lalt", false)
|
|
love.keyboard.setDown("ralt", false)
|
|
love.keyboard.setDown("lgui", false)
|
|
love.keyboard.setDown("rgui", false)
|
|
|
|
Gui.destroy()
|
|
end
|
|
|
|
-- ====================
|
|
-- Focus Management Tests
|
|
-- ====================
|
|
|
|
function TestKeyboardInput:testFocusEditable()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
})
|
|
|
|
lu.assertFalse(input:isFocused())
|
|
|
|
input:focus()
|
|
|
|
lu.assertTrue(input:isFocused())
|
|
lu.assertEquals(Gui._focusedElement, input)
|
|
end
|
|
|
|
function TestKeyboardInput:testBlurEditable()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
})
|
|
|
|
input:focus()
|
|
lu.assertTrue(input:isFocused())
|
|
|
|
input:blur()
|
|
|
|
lu.assertFalse(input:isFocused())
|
|
lu.assertNil(Gui._focusedElement)
|
|
end
|
|
|
|
function TestKeyboardInput:testFocusSwitching()
|
|
local input1 = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Input 1",
|
|
})
|
|
|
|
local input2 = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Input 2",
|
|
})
|
|
|
|
input1:focus()
|
|
lu.assertTrue(input1:isFocused())
|
|
lu.assertFalse(input2:isFocused())
|
|
|
|
input2:focus()
|
|
lu.assertFalse(input1:isFocused())
|
|
lu.assertTrue(input2:isFocused())
|
|
lu.assertEquals(Gui._focusedElement, input2)
|
|
end
|
|
|
|
function TestKeyboardInput:testSelectOnFocus()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello World",
|
|
selectOnFocus = true,
|
|
})
|
|
|
|
lu.assertFalse(input:hasSelection())
|
|
|
|
input:focus()
|
|
|
|
lu.assertTrue(input:hasSelection())
|
|
local startPos, endPos = input:getSelection()
|
|
lu.assertEquals(startPos, 0)
|
|
lu.assertEquals(endPos, 11) -- Length of "Hello World"
|
|
end
|
|
|
|
-- ====================
|
|
-- Text Input Tests
|
|
-- ====================
|
|
|
|
function TestKeyboardInput:testTextInput()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "",
|
|
})
|
|
|
|
input:focus()
|
|
input:textinput("H")
|
|
input:textinput("i")
|
|
|
|
lu.assertEquals(input:getText(), "Hi")
|
|
lu.assertEquals(input._cursorPosition, 2)
|
|
end
|
|
|
|
function TestKeyboardInput:testTextInputAtPosition()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
})
|
|
|
|
input:focus()
|
|
input:setCursorPosition(2) -- After "He"
|
|
input:textinput("X")
|
|
|
|
lu.assertEquals(input:getText(), "HeXllo")
|
|
lu.assertEquals(input._cursorPosition, 3)
|
|
end
|
|
|
|
function TestKeyboardInput:testTextInputWithSelection()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello World",
|
|
})
|
|
|
|
input:focus()
|
|
input:setSelection(0, 5) -- Select "Hello"
|
|
input:textinput("Hi")
|
|
|
|
lu.assertEquals(input:getText(), "Hi World")
|
|
lu.assertEquals(input._cursorPosition, 2)
|
|
lu.assertFalse(input:hasSelection())
|
|
end
|
|
|
|
function TestKeyboardInput:testMaxLengthConstraint()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "",
|
|
maxLength = 5,
|
|
})
|
|
|
|
input:focus()
|
|
input:textinput("Hello")
|
|
lu.assertEquals(input:getText(), "Hello")
|
|
|
|
input:textinput("X") -- Should not be added
|
|
lu.assertEquals(input:getText(), "Hello")
|
|
end
|
|
|
|
-- ====================
|
|
-- Backspace/Delete Tests
|
|
-- ====================
|
|
|
|
function TestKeyboardInput:testBackspace()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
})
|
|
|
|
input:focus()
|
|
input:setCursorPosition(5) -- At end
|
|
input:keypressed("backspace", "backspace", false)
|
|
|
|
lu.assertEquals(input:getText(), "Hell")
|
|
lu.assertEquals(input._cursorPosition, 4)
|
|
end
|
|
|
|
function TestKeyboardInput:testBackspaceAtStart()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
})
|
|
|
|
input:focus()
|
|
input:setCursorPosition(0) -- At start
|
|
input:keypressed("backspace", "backspace", false)
|
|
|
|
lu.assertEquals(input:getText(), "Hello") -- No change
|
|
lu.assertEquals(input._cursorPosition, 0)
|
|
end
|
|
|
|
function TestKeyboardInput:testDelete()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
})
|
|
|
|
input:focus()
|
|
input:setCursorPosition(0) -- At start
|
|
input:keypressed("delete", "delete", false)
|
|
|
|
lu.assertEquals(input:getText(), "ello")
|
|
lu.assertEquals(input._cursorPosition, 0)
|
|
end
|
|
|
|
function TestKeyboardInput:testDeleteAtEnd()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
})
|
|
|
|
input:focus()
|
|
input:setCursorPosition(5) -- At end
|
|
input:keypressed("delete", "delete", false)
|
|
|
|
lu.assertEquals(input:getText(), "Hello") -- No change
|
|
lu.assertEquals(input._cursorPosition, 5)
|
|
end
|
|
|
|
function TestKeyboardInput:testBackspaceWithSelection()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello World",
|
|
})
|
|
|
|
input:focus()
|
|
input:setSelection(0, 5) -- Select "Hello"
|
|
input:keypressed("backspace", "backspace", false)
|
|
|
|
lu.assertEquals(input:getText(), " World")
|
|
lu.assertEquals(input._cursorPosition, 0)
|
|
lu.assertFalse(input:hasSelection())
|
|
end
|
|
|
|
-- ====================
|
|
-- Cursor Movement Tests
|
|
-- ====================
|
|
|
|
function TestKeyboardInput:testArrowLeft()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
})
|
|
|
|
input:focus()
|
|
input:setCursorPosition(5)
|
|
input:keypressed("left", "left", false)
|
|
|
|
lu.assertEquals(input._cursorPosition, 4)
|
|
end
|
|
|
|
function TestKeyboardInput:testArrowRight()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
})
|
|
|
|
input:focus()
|
|
input:setCursorPosition(0)
|
|
input:keypressed("right", "right", false)
|
|
|
|
lu.assertEquals(input._cursorPosition, 1)
|
|
end
|
|
|
|
function TestKeyboardInput:testHomeKey()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
})
|
|
|
|
input:focus()
|
|
input:setCursorPosition(5)
|
|
input:keypressed("home", "home", false)
|
|
|
|
lu.assertEquals(input._cursorPosition, 0)
|
|
end
|
|
|
|
function TestKeyboardInput:testEndKey()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
})
|
|
|
|
input:focus()
|
|
input:setCursorPosition(0)
|
|
input:keypressed("end", "end", false)
|
|
|
|
lu.assertEquals(input._cursorPosition, 5)
|
|
end
|
|
|
|
-- ====================
|
|
-- Modifier Key Tests
|
|
-- ====================
|
|
|
|
function TestKeyboardInput:testSuperLeftMovesToStart()
|
|
clearModifierKeys()
|
|
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello World",
|
|
})
|
|
|
|
input:focus()
|
|
input:setCursorPosition(8) -- Middle of text
|
|
|
|
-- Simulate Super (Cmd/Win) key being held
|
|
love.keyboard.setDown("lgui", true)
|
|
input:keypressed("left", "left", false)
|
|
love.keyboard.setDown("lgui", false)
|
|
|
|
lu.assertEquals(input._cursorPosition, 0)
|
|
end
|
|
|
|
function TestKeyboardInput:testSuperRightMovesToEnd()
|
|
clearModifierKeys()
|
|
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello World",
|
|
})
|
|
|
|
input:focus()
|
|
input:setCursorPosition(3) -- Middle of text
|
|
|
|
-- Simulate Super (Cmd/Win) key being held
|
|
love.keyboard.setDown("lgui", true)
|
|
input:keypressed("right", "right", false)
|
|
love.keyboard.setDown("lgui", false)
|
|
|
|
lu.assertEquals(input._cursorPosition, 11) -- End of "Hello World"
|
|
end
|
|
|
|
function TestKeyboardInput:testAltLeftMovesByWord()
|
|
clearModifierKeys()
|
|
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello World Test",
|
|
})
|
|
|
|
input:focus()
|
|
input:setCursorPosition(16) -- End of text
|
|
|
|
-- Simulate Alt key being held and move left by word
|
|
love.keyboard.setDown("lalt", true)
|
|
input:keypressed("left", "left", false)
|
|
love.keyboard.setDown("lalt", false)
|
|
|
|
lu.assertEquals(input._cursorPosition, 12) -- Start of "Test"
|
|
end
|
|
|
|
function TestKeyboardInput:testAltRightMovesByWord()
|
|
clearModifierKeys()
|
|
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello World Test",
|
|
})
|
|
|
|
input:focus()
|
|
input:setCursorPosition(0) -- Start of text
|
|
|
|
-- Simulate Alt key being held and move right by word
|
|
love.keyboard.setDown("lalt", true)
|
|
input:keypressed("right", "right", false)
|
|
love.keyboard.setDown("lalt", false)
|
|
|
|
lu.assertEquals(input._cursorPosition, 6) -- After "Hello "
|
|
end
|
|
|
|
function TestKeyboardInput:testAltLeftMultipleWords()
|
|
clearModifierKeys()
|
|
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "The quick brown fox",
|
|
})
|
|
|
|
input:focus()
|
|
input:setCursorPosition(19) -- End of text
|
|
|
|
-- Move left by word three times
|
|
love.keyboard.setDown("lalt", true)
|
|
input:keypressed("left", "left", false) -- to "fox"
|
|
input:keypressed("left", "left", false) -- to "brown"
|
|
input:keypressed("left", "left", false) -- to "quick"
|
|
love.keyboard.setDown("lalt", false)
|
|
|
|
lu.assertEquals(input._cursorPosition, 4) -- Start of "quick"
|
|
end
|
|
|
|
function TestKeyboardInput:testAltRightMultipleWords()
|
|
clearModifierKeys()
|
|
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "The quick brown fox",
|
|
})
|
|
|
|
input:focus()
|
|
input:setCursorPosition(0) -- Start of text
|
|
|
|
-- Move right by word three times
|
|
love.keyboard.setDown("lalt", true)
|
|
input:keypressed("right", "right", false) -- after "The "
|
|
input:keypressed("right", "right", false) -- after "quick "
|
|
input:keypressed("right", "right", false) -- after "brown "
|
|
love.keyboard.setDown("lalt", false)
|
|
|
|
lu.assertEquals(input._cursorPosition, 16) -- After "brown "
|
|
end
|
|
|
|
function TestKeyboardInput:testSuperLeftWithSelection()
|
|
clearModifierKeys()
|
|
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello World",
|
|
})
|
|
|
|
input:focus()
|
|
input:setSelection(3, 8)
|
|
lu.assertTrue(input:hasSelection())
|
|
|
|
-- Super+Left should move to start and clear selection
|
|
love.keyboard.setDown("lgui", true)
|
|
input:keypressed("left", "left", false)
|
|
love.keyboard.setDown("lgui", false)
|
|
|
|
lu.assertEquals(input._cursorPosition, 0)
|
|
lu.assertFalse(input:hasSelection())
|
|
end
|
|
|
|
function TestKeyboardInput:testSuperRightWithSelection()
|
|
clearModifierKeys()
|
|
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello World",
|
|
})
|
|
|
|
input:focus()
|
|
input:setSelection(3, 8)
|
|
lu.assertTrue(input:hasSelection())
|
|
|
|
-- Super+Right should move to end and clear selection
|
|
love.keyboard.setDown("lgui", true)
|
|
input:keypressed("right", "right", false)
|
|
love.keyboard.setDown("lgui", false)
|
|
|
|
lu.assertEquals(input._cursorPosition, 11)
|
|
lu.assertFalse(input:hasSelection())
|
|
end
|
|
|
|
function TestKeyboardInput:testEscapeClearsSelection()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
})
|
|
|
|
input:focus()
|
|
input:selectAll()
|
|
lu.assertTrue(input:hasSelection())
|
|
|
|
input:keypressed("escape", "escape", false)
|
|
|
|
lu.assertFalse(input:hasSelection())
|
|
lu.assertTrue(input:isFocused()) -- Still focused
|
|
end
|
|
|
|
function TestKeyboardInput:testEscapeBlurs()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
})
|
|
|
|
input:focus()
|
|
lu.assertTrue(input:isFocused())
|
|
|
|
input:keypressed("escape", "escape", false)
|
|
|
|
lu.assertFalse(input:isFocused())
|
|
end
|
|
|
|
-- ====================
|
|
-- Callback Tests
|
|
-- ====================
|
|
|
|
function TestKeyboardInput:testOnTextChangeCallback()
|
|
local changeCount = 0
|
|
local oldTextValue = nil
|
|
local newTextValue = nil
|
|
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
onTextChange = function(element, newText, oldText)
|
|
changeCount = changeCount + 1
|
|
newTextValue = newText
|
|
oldTextValue = oldText
|
|
end,
|
|
})
|
|
|
|
input:focus()
|
|
input:textinput("X")
|
|
|
|
lu.assertEquals(changeCount, 1)
|
|
lu.assertEquals(oldTextValue, "Hello")
|
|
lu.assertEquals(newTextValue, "HelloX")
|
|
end
|
|
|
|
function TestKeyboardInput:testOnTextInputCallback()
|
|
local inputCount = 0
|
|
local lastChar = nil
|
|
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "",
|
|
onTextInput = function(element, text)
|
|
inputCount = inputCount + 1
|
|
lastChar = text
|
|
end,
|
|
})
|
|
|
|
input:focus()
|
|
input:textinput("A")
|
|
input:textinput("B")
|
|
|
|
lu.assertEquals(inputCount, 2)
|
|
lu.assertEquals(lastChar, "B")
|
|
end
|
|
|
|
function TestKeyboardInput:testOnEnterCallback()
|
|
local enterCalled = false
|
|
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
multiline = false,
|
|
text = "Hello",
|
|
onEnter = function(element)
|
|
enterCalled = true
|
|
end,
|
|
})
|
|
|
|
input:focus()
|
|
input:keypressed("return", "return", false)
|
|
|
|
lu.assertTrue(enterCalled)
|
|
end
|
|
|
|
function TestKeyboardInput:testOnFocusCallback()
|
|
local focusCalled = false
|
|
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
onFocus = function(element)
|
|
focusCalled = true
|
|
end,
|
|
})
|
|
|
|
input:focus()
|
|
|
|
lu.assertTrue(focusCalled)
|
|
end
|
|
|
|
function TestKeyboardInput:testOnBlurCallback()
|
|
local blurCalled = false
|
|
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
onBlur = function(element)
|
|
blurCalled = true
|
|
end,
|
|
})
|
|
|
|
input:focus()
|
|
input:blur()
|
|
|
|
lu.assertTrue(blurCalled)
|
|
end
|
|
|
|
-- ====================
|
|
-- GUI-level Input Forwarding Tests
|
|
-- ====================
|
|
|
|
function TestKeyboardInput:testGuiTextinputForwarding()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "",
|
|
})
|
|
|
|
input:focus()
|
|
Gui.textinput("A")
|
|
|
|
lu.assertEquals(input:getText(), "A")
|
|
end
|
|
|
|
function TestKeyboardInput:testGuiKeypressedForwarding()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
})
|
|
|
|
input:focus()
|
|
input:setCursorPosition(5)
|
|
Gui.keypressed("backspace", "backspace", false)
|
|
|
|
lu.assertEquals(input:getText(), "Hell")
|
|
end
|
|
|
|
function TestKeyboardInput:testGuiInputWithoutFocus()
|
|
local input = Element.new({
|
|
width = 200,
|
|
height = 40,
|
|
editable = true,
|
|
text = "Hello",
|
|
})
|
|
|
|
-- No focus
|
|
Gui.textinput("X")
|
|
|
|
lu.assertEquals(input:getText(), "Hello") -- No change
|
|
end
|
|
|
|
lu.LuaUnit.run()
|