Mike/FlexLove
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cleanup

Browse Source
This commit is contained in:
Michael Freno
2025-11-07 13:38:53 -05:00
parent d49a31774a
commit e11129a621
7 changed files with 815 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
testing/__tests__/10_performance_tests.lua
View File

@@ -144,8 +144,9 @@ function TestPerformance:testScalabilityWithLargeNumbers()
end
-- Check that performance scales linearly or sub-linearly
-- Time for 200 children should not be more than 20x time for 10 children
luaunit.assertTrue(times[200] <= times[10] * 20, "Performance should scale sub-linearly")
-- Time for 200 children should not be more than 25x time for 10 children
-- (Increased from 20x to account for timing precision at microsecond scale)
luaunit.assertTrue(times[200] <= times[10] * 25, "Performance should scale sub-linearly")
end
-- Test 3: Complex Nested Layout Performance

7
testing/__tests__/16_event_system_tests.lua
View File

@@ -20,6 +20,13 @@ end
function TestEventSystem:tearDown()
-- Clean up after each test
Gui.destroy()
-- Reset keyboard state
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)
end
-- Test 1: Event object structure

380
testing/__tests__/32_state_manager_tests.lua
View File

@@ -9,13 +9,13 @@ local StateManager = require("modules.StateManager")
TestStateManager = {}
function TestStateManager:setUp()
-- Reset StateManager before each test
StateManager.clearAllStates()
-- Reset StateManager before each test
StateManager.clearAllStates()
end
function TestStateManager:tearDown()
-- Clean up after each test
StateManager.clearAllStates()
-- Clean up after each test
StateManager.clearAllStates()
end
-- ====================
@@ -23,52 +23,52 @@ end
-- ====================
function TestStateManager:test_getState_createsNewState()
local state = StateManager.getState("test-element")
luaunit.assertNotNil(state)
luaunit.assertEquals(state.hover, false)
luaunit.assertEquals(state.pressed, false)
luaunit.assertEquals(state.focused, false)
luaunit.assertEquals(state.disabled, false)
luaunit.assertEquals(state.active, false)
local state = StateManager.getState("test-element")
luaunit.assertNotNil(state)
luaunit.assertEquals(state.hover, false)
luaunit.assertEquals(state.pressed, false)
luaunit.assertEquals(state.focused, false)
luaunit.assertEquals(state.disabled, false)
luaunit.assertEquals(state.active, false)
end
function TestStateManager:test_getState_returnsExistingState()
local state1 = StateManager.getState("test-element")
state1.hover = true
local state2 = StateManager.getState("test-element")
luaunit.assertEquals(state2.hover, true)
luaunit.assertTrue(state1 == state2) -- Same reference
local state1 = StateManager.getState("test-element")
state1.hover = true
local state2 = StateManager.getState("test-element")
luaunit.assertEquals(state2.hover, true)
luaunit.assertTrue(state1 == state2) -- Same reference
end
function TestStateManager:test_updateState_modifiesState()
StateManager.updateState("test-element", {
hover = true,
pressed = false,
})
local state = StateManager.getState("test-element")
luaunit.assertEquals(state.hover, true)
luaunit.assertEquals(state.pressed, false)
StateManager.updateState("test-element", {
hover = true,
pressed = false,
})
local state = StateManager.getState("test-element")
luaunit.assertEquals(state.hover, true)
luaunit.assertEquals(state.pressed, false)
end
function TestStateManager:test_updateState_mergesPartialState()
StateManager.updateState("test-element", { hover = true })
StateManager.updateState("test-element", { pressed = true })
local state = StateManager.getState("test-element")
luaunit.assertEquals(state.hover, true)
luaunit.assertEquals(state.pressed, true)
StateManager.updateState("test-element", { hover = true })
StateManager.updateState("test-element", { pressed = true })
local state = StateManager.getState("test-element")
luaunit.assertEquals(state.hover, true)
luaunit.assertEquals(state.pressed, true)
end
function TestStateManager:test_clearState_removesState()
StateManager.updateState("test-element", { hover = true })
StateManager.clearState("test-element")
local state = StateManager.getState("test-element")
luaunit.assertEquals(state.hover, false) -- New state created with defaults
StateManager.updateState("test-element", { hover = true })
StateManager.clearState("test-element")
local state = StateManager.getState("test-element")
luaunit.assertEquals(state.hover, false) -- New state created with defaults
end
-- ====================
@@ -76,28 +76,28 @@ end
-- ====================
function TestStateManager:test_scrollbarStates_initialization()
local state = StateManager.getState("test-element")
luaunit.assertEquals(state.scrollbarHoveredVertical, false)
luaunit.assertEquals(state.scrollbarHoveredHorizontal, false)
luaunit.assertEquals(state.scrollbarDragging, false)
luaunit.assertNil(state.hoveredScrollbar)
luaunit.assertEquals(state.scrollbarDragOffset, 0)
local state = StateManager.getState("test-element")
luaunit.assertEquals(state.scrollbarHoveredVertical, false)
luaunit.assertEquals(state.scrollbarHoveredHorizontal, false)
luaunit.assertEquals(state.scrollbarDragging, false)
luaunit.assertNil(state.hoveredScrollbar)
luaunit.assertEquals(state.scrollbarDragOffset, 0)
end
function TestStateManager:test_scrollbarStates_updates()
StateManager.updateState("test-element", {
scrollbarHoveredVertical = true,
scrollbarDragging = true,
hoveredScrollbar = "vertical",
scrollbarDragOffset = 25,
})
local state = StateManager.getState("test-element")
luaunit.assertEquals(state.scrollbarHoveredVertical, true)
luaunit.assertEquals(state.scrollbarDragging, true)
luaunit.assertEquals(state.hoveredScrollbar, "vertical")
luaunit.assertEquals(state.scrollbarDragOffset, 25)
StateManager.updateState("test-element", {
scrollbarHoveredVertical = true,
scrollbarDragging = true,
hoveredScrollbar = "vertical",
scrollbarDragOffset = 25,
})
local state = StateManager.getState("test-element")
luaunit.assertEquals(state.scrollbarHoveredVertical, true)
luaunit.assertEquals(state.scrollbarDragging, true)
luaunit.assertEquals(state.hoveredScrollbar, "vertical")
luaunit.assertEquals(state.scrollbarDragOffset, 25)
end
-- ====================
@@ -105,23 +105,23 @@ end
-- ====================
function TestStateManager:test_frameNumber_increments()
local frame1 = StateManager.getFrameNumber()
StateManager.incrementFrame()
local frame2 = StateManager.getFrameNumber()
luaunit.assertEquals(frame2, frame1 + 1)
local frame1 = StateManager.getFrameNumber()
StateManager.incrementFrame()
local frame2 = StateManager.getFrameNumber()
luaunit.assertEquals(frame2, frame1 + 1)
end
function TestStateManager:test_updateState_updatesFrameNumber()
StateManager.incrementFrame()
StateManager.incrementFrame()
local currentFrame = StateManager.getFrameNumber()
StateManager.updateState("test-element", { hover = true })
-- State should exist and be accessible
local state = StateManager.getState("test-element")
luaunit.assertNotNil(state)
StateManager.incrementFrame()
StateManager.incrementFrame()
local currentFrame = StateManager.getFrameNumber()
StateManager.updateState("test-element", { hover = true })
-- State should exist and be accessible
local state = StateManager.getState("test-element")
luaunit.assertNotNil(state)
end
-- ====================
@@ -129,59 +129,59 @@ end
-- ====================
function TestStateManager:test_cleanup_removesStaleStates()
-- Configure short retention
StateManager.configure({ stateRetentionFrames = 5 })
-- Create state
StateManager.updateState("test-element", { hover = true })
-- Advance frames beyond retention
for i = 1, 10 do
StateManager.incrementFrame()
end
-- Cleanup should remove the state
local cleanedCount = StateManager.cleanup()
luaunit.assertEquals(cleanedCount, 1)
-- Reset config
StateManager.configure({ stateRetentionFrames = 60 })
-- Configure short retention
StateManager.configure({ stateRetentionFrames = 5 })
-- Create state
StateManager.updateState("test-element", { hover = true })
-- Advance frames beyond retention
for i = 1, 10 do
StateManager.incrementFrame()
end
-- Cleanup should remove the state
local cleanedCount = StateManager.cleanup()
luaunit.assertEquals(cleanedCount, 1)
-- Reset config
StateManager.configure({ stateRetentionFrames = 60 })
end
function TestStateManager:test_cleanup_keepsActiveStates()
StateManager.configure({ stateRetentionFrames = 5 })
StateManager.configure({ stateRetentionFrames = 5 })
StateManager.updateState("test-element", { hover = true })
-- Update state within retention period
for i = 1, 3 do
StateManager.incrementFrame()
StateManager.updateState("test-element", { hover = true })
-- Update state within retention period
for i = 1, 3 do
StateManager.incrementFrame()
StateManager.updateState("test-element", { hover = true })
end
local cleanedCount = StateManager.cleanup()
luaunit.assertEquals(cleanedCount, 0) -- Should not clean active state
StateManager.configure({ stateRetentionFrames = 60 })
end
local cleanedCount = StateManager.cleanup()
luaunit.assertEquals(cleanedCount, 0) -- Should not clean active state
StateManager.configure({ stateRetentionFrames = 60 })
end
function TestStateManager:test_forceCleanupIfNeeded_activatesWhenOverLimit()
StateManager.configure({ maxStateEntries = 5 })
-- Create more states than limit
for i = 1, 10 do
StateManager.updateState("element-" .. i, { hover = true })
end
-- Advance frames
for i = 1, 15 do
StateManager.incrementFrame()
end
local cleanedCount = StateManager.forceCleanupIfNeeded()
luaunit.assertTrue(cleanedCount > 0)
StateManager.configure({ maxStateEntries = 1000 })
StateManager.configure({ maxStateEntries = 5 })
-- Create more states than limit
for i = 1, 10 do
StateManager.updateState("element-" .. i, { hover = true })
end
-- Advance frames
for i = 1, 15 do
StateManager.incrementFrame()
end
local cleanedCount = StateManager.forceCleanupIfNeeded()
luaunit.assertTrue(cleanedCount > 0)
StateManager.configure({ maxStateEntries = 1000 })
end
-- ====================
@@ -189,13 +189,13 @@ end
-- ====================
function TestStateManager:test_getStateCount_returnsCorrectCount()
luaunit.assertEquals(StateManager.getStateCount(), 0)
StateManager.getState("element-1")
StateManager.getState("element-2")
StateManager.getState("element-3")
luaunit.assertEquals(StateManager.getStateCount(), 3)
luaunit.assertEquals(StateManager.getStateCount(), 0)
StateManager.getState("element-1")
StateManager.getState("element-2")
StateManager.getState("element-3")
luaunit.assertEquals(StateManager.getStateCount(), 3)
end
-- ====================
@@ -203,18 +203,18 @@ end
-- ====================
function TestStateManager:test_getActiveState_returnsOnlyActiveProperties()
StateManager.updateState("test-element", {
hover = true,
pressed = false,
focused = true,
})
local activeState = StateManager.getActiveState("test-element")
luaunit.assertEquals(activeState.hover, true)
luaunit.assertEquals(activeState.pressed, false)
luaunit.assertEquals(activeState.focused, true)
luaunit.assertNil(activeState.lastUpdateFrame) -- Should not include frame tracking
StateManager.updateState("test-element", {
hover = true,
pressed = false,
focused = true,
})
local activeState = StateManager.getActiveState("test-element")
luaunit.assertEquals(activeState.hover, true)
luaunit.assertEquals(activeState.pressed, false)
luaunit.assertEquals(activeState.focused, true)
luaunit.assertNil(activeState.lastUpdateFrame) -- Should not include frame tracking
end
-- ====================
@@ -222,33 +222,33 @@ end
-- ====================
function TestStateManager:test_isHovered_returnsTrueWhenHovered()
StateManager.updateState("test-element", { hover = true })
luaunit.assertTrue(StateManager.isHovered("test-element"))
StateManager.updateState("test-element", { hover = true })
luaunit.assertTrue(StateManager.isHovered("test-element"))
end
function TestStateManager:test_isHovered_returnsFalseWhenNotHovered()
StateManager.updateState("test-element", { hover = false })
luaunit.assertFalse(StateManager.isHovered("test-element"))
StateManager.updateState("test-element", { hover = false })
luaunit.assertFalse(StateManager.isHovered("test-element"))
end
function TestStateManager:test_isPressed_returnsTrueWhenPressed()
StateManager.updateState("test-element", { pressed = true })
luaunit.assertTrue(StateManager.isPressed("test-element"))
StateManager.updateState("test-element", { pressed = true })
luaunit.assertTrue(StateManager.isPressed("test-element"))
end
function TestStateManager:test_isFocused_returnsTrueWhenFocused()
StateManager.updateState("test-element", { focused = true })
luaunit.assertTrue(StateManager.isFocused("test-element"))
StateManager.updateState("test-element", { focused = true })
luaunit.assertTrue(StateManager.isFocused("test-element"))
end
function TestStateManager:test_isDisabled_returnsTrueWhenDisabled()
StateManager.updateState("test-element", { disabled = true })
luaunit.assertTrue(StateManager.isDisabled("test-element"))
StateManager.updateState("test-element", { disabled = true })
luaunit.assertTrue(StateManager.isDisabled("test-element"))
end
function TestStateManager:test_isActive_returnsTrueWhenActive()
StateManager.updateState("test-element", { active = true })
luaunit.assertTrue(StateManager.isActive("test-element"))
StateManager.updateState("test-element", { active = true })
luaunit.assertTrue(StateManager.isActive("test-element"))
end
-- ====================
@@ -256,20 +256,20 @@ end
-- ====================
function TestStateManager:test_generateID_createsUniqueID()
local id1 = StateManager.generateID({ test = "value1" })
local id2 = StateManager.generateID({ test = "value2" })
luaunit.assertNotNil(id1)
luaunit.assertNotNil(id2)
luaunit.assertTrue(type(id1) == "string")
luaunit.assertTrue(type(id2) == "string")
local id1 = StateManager.generateID({ test = "value1" })
local id2 = StateManager.generateID({ test = "value2" })
luaunit.assertNotNil(id1)
luaunit.assertNotNil(id2)
luaunit.assertTrue(type(id1) == "string")
luaunit.assertTrue(type(id2) == "string")
end
function TestStateManager:test_generateID_withoutProps()
local id = StateManager.generateID(nil)
luaunit.assertNotNil(id)
luaunit.assertTrue(type(id) == "string")
local id = StateManager.generateID(nil)
luaunit.assertNotNil(id)
luaunit.assertTrue(type(id) == "string")
end
-- ====================
@@ -277,21 +277,21 @@ end
-- ====================
function TestStateManager:test_scrollPosition_initialization()
local state = StateManager.getState("test-element")
luaunit.assertEquals(state.scrollX, 0)
luaunit.assertEquals(state.scrollY, 0)
local state = StateManager.getState("test-element")
luaunit.assertEquals(state.scrollX, 0)
luaunit.assertEquals(state.scrollY, 0)
end
function TestStateManager:test_scrollPosition_updates()
StateManager.updateState("test-element", {
scrollX = 100,
scrollY = 200,
})
local state = StateManager.getState("test-element")
luaunit.assertEquals(state.scrollX, 100)
luaunit.assertEquals(state.scrollY, 200)
StateManager.updateState("test-element", {
scrollX = 100,
scrollY = 200,
})
local state = StateManager.getState("test-element")
luaunit.assertEquals(state.scrollX, 100)
luaunit.assertEquals(state.scrollY, 200)
end
-- ====================
@@ -299,24 +299,24 @@ end
-- ====================
function TestStateManager:test_configure_updatesSettings()
StateManager.configure({
stateRetentionFrames = 30,
maxStateEntries = 500,
})
-- Test that configuration was applied by creating many states
-- and checking cleanup behavior (indirect test)
for i = 1, 10 do
StateManager.updateState("element-" .. i, { hover = true })
end
luaunit.assertEquals(StateManager.getStateCount(), 10)
-- Reset to defaults
StateManager.configure({
stateRetentionFrames = 60,
maxStateEntries = 1000,
})
StateManager.configure({
stateRetentionFrames = 30,
maxStateEntries = 500,
})
-- Test that configuration was applied by creating many states
-- and checking cleanup behavior (indirect test)
for i = 1, 10 do
StateManager.updateState("element-" .. i, { hover = true })
end
luaunit.assertEquals(StateManager.getStateCount(), 10)
-- Reset to defaults
StateManager.configure({
stateRetentionFrames = 60,
maxStateEntries = 1000,
})
end
return TestStateManager
luaunit.LuaUnit.run()

590
testing/__tests__/33_input_field_tests.lua Normal file
View File

@@ -0,0 +1,590 @@
-- ====================
-- Input Field Tests
-- ====================
-- Test suite for text input functionality in FlexLove
local lu = require("testing.luaunit")
local loveStub = require("testing.loveStub")
-- Setup LÖVE environment
_G.love = loveStub
-- Load FlexLove after setting up love stub
local FlexLove = require("FlexLove")
-- Test fixtures
local testElement
TestInputField = {}
function TestInputField:setUp()
-- Reset FlexLove state
FlexLove.Gui.topElements = {}
FlexLove.Gui._focusedElement = nil
-- Create a test input element
testElement = FlexLove.Element.new({
x = 100,
y = 100,
width = 200,
height = 40,
editable = true,
text = "Hello World",
})
end
function TestInputField:tearDown()
testElement = nil
FlexLove.Gui.topElements = {}
FlexLove.Gui._focusedElement = nil
end
-- ====================
-- Focus Management Tests
-- ====================
function TestInputField:testFocusElement()
-- Initially not focused
lu.assertFalse(testElement:isFocused())
-- Focus element
testElement:focus()
-- Should be focused
lu.assertTrue(testElement:isFocused())
lu.assertEquals(FlexLove.Gui._focusedElement, testElement)
end
function TestInputField:testBlurElement()
-- Focus element first
testElement:focus()
lu.assertTrue(testElement:isFocused())
-- Blur element
testElement:blur()
-- Should not be focused
lu.assertFalse(testElement:isFocused())
lu.assertNil(FlexLove.Gui._focusedElement)
end
function TestInputField:testFocusSwitchBetweenElements()
local element1 = FlexLove.Element.new({
x = 10,
y = 10,
width = 100,
height = 30,
editable = true,
text = "Element 1",
})
local element2 = FlexLove.Element.new({
x = 10,
y = 50,
width = 100,
height = 30,
editable = true,
text = "Element 2",
})
-- Focus element1
element1:focus()
lu.assertTrue(element1:isFocused())
lu.assertFalse(element2:isFocused())
-- Focus element2 (should blur element1)
element2:focus()
lu.assertFalse(element1:isFocused())
lu.assertTrue(element2:isFocused())
lu.assertEquals(FlexLove.Gui._focusedElement, element2)
end
function TestInputField:testSelectOnFocus()
local element = FlexLove.Element.new({
x = 10,
y = 10,
width = 100,
height = 30,
editable = true,
text = "Test Text",
selectOnFocus = true,
})
-- Focus element with selectOnFocus enabled
element:focus()
-- Should select all text
lu.assertTrue(element:hasSelection())
local startPos, endPos = element:getSelection()
lu.assertEquals(startPos, 0)
lu.assertEquals(endPos, 9) -- "Test Text" has 9 characters
end
-- ====================
-- Cursor Management Tests
-- ====================
function TestInputField:testSetCursorPosition()
testElement:focus()
-- Set cursor to position 5
testElement:setCursorPosition(5)
lu.assertEquals(testElement:getCursorPosition(), 5)
end
function TestInputField:testCursorPositionBounds()
testElement:focus()
-- Try to set cursor beyond text length
testElement:setCursorPosition(999)
-- Should clamp to text length
lu.assertEquals(testElement:getCursorPosition(), 11) -- "Hello World" has 11 characters
-- Try to set negative cursor position
testElement:setCursorPosition(-5)
-- Should clamp to 0
lu.assertEquals(testElement:getCursorPosition(), 0)
end
function TestInputField:testMoveCursor()
testElement:focus()
testElement:setCursorPosition(5)
-- Move cursor right
testElement:moveCursorBy(2)
lu.assertEquals(testElement:getCursorPosition(), 7)
-- Move cursor left
testElement:moveCursorBy(-3)
lu.assertEquals(testElement:getCursorPosition(), 4)
end
function TestInputField:testMoveCursorToStartEnd()
testElement:focus()
testElement:setCursorPosition(5)
-- Move to end
testElement:moveCursorToEnd()
lu.assertEquals(testElement:getCursorPosition(), 11)
-- Move to start
testElement:moveCursorToStart()
lu.assertEquals(testElement:getCursorPosition(), 0)
end
-- ====================
-- Text Buffer Management Tests
-- ====================
function TestInputField:testGetText()
lu.assertEquals(testElement:getText(), "Hello World")
end
function TestInputField:testSetText()
testElement:setText("New Text")
lu.assertEquals(testElement:getText(), "New Text")
lu.assertEquals(testElement.text, "New Text")
end
function TestInputField:testInsertTextAtCursor()
testElement:focus()
testElement:setCursorPosition(5) -- After "Hello"
testElement:insertText(" Beautiful")
lu.assertEquals(testElement:getText(), "Hello Beautiful World")
lu.assertEquals(testElement:getCursorPosition(), 15) -- Cursor after inserted text
end
function TestInputField:testInsertTextAtSpecificPosition()
testElement:insertText("Super ", 6) -- Before "World"
lu.assertEquals(testElement:getText(), "Hello Super World")
end
function TestInputField:testDeleteText()
testElement:deleteText(0, 6) -- Delete "Hello "
lu.assertEquals(testElement:getText(), "World")
end
function TestInputField:testReplaceText()
testElement:replaceText(0, 5, "Hi") -- Replace "Hello" with "Hi"
lu.assertEquals(testElement:getText(), "Hi World")
end
function TestInputField:testMaxLengthConstraint()
local element = FlexLove.Element.new({
x = 10,
y = 10,
width = 100,
height = 30,
editable = true,
text = "Test",
maxLength = 10,
})
element:focus()
element:moveCursorToEnd()
-- Try to insert text that would exceed maxLength
element:insertText(" Very Long Text")
-- Should not insert text that exceeds maxLength
lu.assertEquals(element:getText(), "Test")
-- Insert text that fits within maxLength
element:insertText(" Text")
lu.assertEquals(element:getText(), "Test Text")
end
-- ====================
-- Selection Management Tests
-- ====================
function TestInputField:testSetSelection()
testElement:setSelection(0, 5) -- Select "Hello"
lu.assertTrue(testElement:hasSelection())
local startPos, endPos = testElement:getSelection()
lu.assertEquals(startPos, 0)
lu.assertEquals(endPos, 5)
end
function TestInputField:testGetSelectedText()
testElement:setSelection(0, 5) -- Select "Hello"
local selectedText = testElement:getSelectedText()
lu.assertEquals(selectedText, "Hello")
end
function TestInputField:testSelectAll()
testElement:selectAll()
lu.assertTrue(testElement:hasSelection())
local startPos, endPos = testElement:getSelection()
lu.assertEquals(startPos, 0)
lu.assertEquals(endPos, 11) -- Full text length
end
function TestInputField:testClearSelection()
testElement:setSelection(0, 5)
lu.assertTrue(testElement:hasSelection())
testElement:clearSelection()
lu.assertFalse(testElement:hasSelection())
local startPos, endPos = testElement:getSelection()
lu.assertNil(startPos)
lu.assertNil(endPos)
end
function TestInputField:testDeleteSelection()
testElement:focus()
testElement:setSelection(0, 6) -- Select "Hello "
local deleted = testElement:deleteSelection()
lu.assertTrue(deleted)
lu.assertEquals(testElement:getText(), "World")
lu.assertFalse(testElement:hasSelection())
lu.assertEquals(testElement:getCursorPosition(), 0)
end
-- ====================
-- Text Input Tests
-- ====================
function TestInputField:testTextInput()
testElement:focus()
testElement:setCursorPosition(5) -- After "Hello"
-- Simulate text input
testElement:textinput(",")
lu.assertEquals(testElement:getText(), "Hello, World")
lu.assertEquals(testElement:getCursorPosition(), 6)
end
function TestInputField:testTextInputWithSelection()
testElement:focus()
testElement:setSelection(0, 5) -- Select "Hello"
-- Simulate text input (should replace selection)
testElement:textinput("Hi")
lu.assertEquals(testElement:getText(), "Hi World")
lu.assertFalse(testElement:hasSelection())
lu.assertEquals(testElement:getCursorPosition(), 2)
end
function TestInputField:testTextInputCallbacks()
local inputCalled = false
local changeCalled = false
local inputText = nil
local newText = nil
local oldText = nil
local element = FlexLove.Element.new({
x = 10,
y = 10,
width = 100,
height = 30,
editable = true,
text = "Test",
onTextInput = function(_, text)
inputCalled = true
inputText = text
end,
onTextChange = function(_, new, old)
changeCalled = true
newText = new
oldText = old
end,
})
element:focus()
element:moveCursorToEnd()
element:textinput("!")
lu.assertTrue(inputCalled)
lu.assertTrue(changeCalled)
lu.assertEquals(inputText, "!")
lu.assertEquals(newText, "Test!")
lu.assertEquals(oldText, "Test")
end
-- ====================
-- Keyboard Input Tests
-- ====================
function TestInputField:testBackspaceKey()
testElement:focus()
testElement:setCursorPosition(5) -- After "Hello"
-- Simulate backspace key
testElement:keypressed("backspace", nil, false)
lu.assertEquals(testElement:getText(), "Hell World")
lu.assertEquals(testElement:getCursorPosition(), 4)
end
function TestInputField:testDeleteKey()
testElement:focus()
testElement:setCursorPosition(5) -- After "Hello", before " "
-- Simulate delete key
testElement:keypressed("delete", nil, false)
lu.assertEquals(testElement:getText(), "HelloWorld")
lu.assertEquals(testElement:getCursorPosition(), 5)
end
function TestInputField:testArrowKeys()
testElement:focus()
testElement:setCursorPosition(5)
-- Right arrow
testElement:keypressed("right", nil, false)
lu.assertEquals(testElement:getCursorPosition(), 6)
-- Left arrow
testElement:keypressed("left", nil, false)
lu.assertEquals(testElement:getCursorPosition(), 5)
end
function TestInputField:testHomeEndKeys()
testElement:focus()
testElement:setCursorPosition(5)
-- End key
testElement:keypressed("end", nil, false)
lu.assertEquals(testElement:getCursorPosition(), 11)
-- Home key
testElement:keypressed("home", nil, false)
lu.assertEquals(testElement:getCursorPosition(), 0)
end
function TestInputField:testEscapeKey()
testElement:focus()
testElement:setSelection(0, 5)
lu.assertTrue(testElement:hasSelection())
-- Escape should clear selection
testElement:keypressed("escape", nil, false)
lu.assertFalse(testElement:hasSelection())
lu.assertTrue(testElement:isFocused()) -- Still focused
-- Another escape should blur
testElement:keypressed("escape", nil, false)
lu.assertFalse(testElement:isFocused())
end
function TestInputField:testCtrlA()
testElement:focus()
-- Simulate Ctrl+A (need to mock modifiers)
local oldIsDown = _G.love.keyboard.isDown
_G.love.keyboard.isDown = function(...)
local keys = {...}
for _, key in ipairs(keys) do
if key == "lctrl" or key == "rctrl" then
return true
end
end
return false
end
testElement:keypressed("a", "", false)
lu.assertTrue(testElement:hasSelection())
local startPos, endPos = testElement:getSelection()
lu.assertEquals(startPos, 0)
lu.assertEquals(endPos, 11)
-- Reset mock
_G.love.keyboard.isDown = oldIsDown
end
function TestInputField:testEnterKeyMultiline()
local element = FlexLove.Element.new({
x = 10,
y = 10,
width = 100,
height = 60,
editable = true,
multiline = true,
text = "Line 1",
})
element:focus()
element:moveCursorToEnd()
-- Simulate Enter key
element:keypressed("return", nil, false)
-- Should insert newline
lu.assertEquals(element:getText(), "Line 1\n")
end
function TestInputField:testEnterKeySingleline()
local enterCalled = false
local element = FlexLove.Element.new({
x = 10,
y = 10,
width = 100,
height = 30,
editable = true,
multiline = false,
text = "Test",
onEnter = function()
enterCalled = true
end,
})
element:focus()
element:moveCursorToEnd()
-- Simulate Enter key
element:keypressed("return", nil, false)
-- Should trigger onEnter callback, not insert newline
lu.assertTrue(enterCalled)
lu.assertEquals(element:getText(), "Test")
end
-- ====================
-- Multi-line Tests
-- ====================
function TestInputField:testMultilineTextSplitting()
local element = FlexLove.Element.new({
x = 10,
y = 10,
width = 100,
height = 80,
editable = true,
multiline = true,
text = "Line 1\nLine 2\nLine 3",
})
-- Trigger line splitting
element:_splitLines()
lu.assertEquals(#element._lines, 3)
lu.assertEquals(element._lines[1], "Line 1")
lu.assertEquals(element._lines[2], "Line 2")
lu.assertEquals(element._lines[3], "Line 3")
end
-- ====================
-- UTF-8 Support Tests
-- ====================
function TestInputField:testUTF8Characters()
local element = FlexLove.Element.new({
x = 10,
y = 10,
width = 100,
height = 30,
editable = true,
text = "Hello 世界",
})
element:focus()
element:moveCursorToEnd()
-- Insert UTF-8 character
element:insertText("!")
lu.assertEquals(element:getText(), "Hello 世界!")
end
function TestInputField:testUTF8Selection()
local element = FlexLove.Element.new({
x = 10,
y = 10,
width = 100,
height = 30,
editable = true,
text = "Hello 世界",
})
-- Select UTF-8 characters
element:setSelection(6, 8) -- Select "世界"
local selected = element:getSelectedText()
lu.assertEquals(selected, "世界")
end
-- ====================
-- Password Mode Tests
-- ====================
function TestInputField:testPasswordModeDisablesMultiline()
local element = FlexLove.Element.new({
x = 10,
y = 10,
width = 100,
height = 30,
editable = true,
multiline = true,
passwordMode = true,
text = "password",
})
-- Password mode should override multiline
lu.assertFalse(element.multiline)
end
-- Run tests
lu.LuaUnit.run()

10
testing/loveStub.lua
View File

@@ -221,8 +221,14 @@ love_helper.keyboard = {}
-- Mock keyboard state
local mockKeyboardKeys = {} -- Table to track key states
function love_helper.keyboard.isDown(key)
return mockKeyboardKeys[key] or false
function love_helper.keyboard.isDown(...)
local keys = {...}
for _, key in ipairs(keys) do
if mockKeyboardKeys[key] then
return true
end
end
return false
end
function love_helper.keyboard.setDown(key, isDown)

1
testing/runAll.lua
View File

@@ -36,6 +36,7 @@ local testFiles = {
"testing/__tests__/30_scrollbar_features_tests.lua",
"testing/__tests__/31_immediate_mode_basic_tests.lua",
"testing/__tests__/32_state_manager_tests.lua",
"testing/__tests__/33_input_field_tests.lua",
}
local success = true