613 lines
13 KiB
Lua
613 lines
13 KiB
Lua
-- Advanced test suite for Element.lua to increase coverage
|
|
-- Focuses on uncovered edge cases and complex scenarios
|
|
|
|
package.path = package.path .. ";./?.lua;./modules/?.lua"
|
|
|
|
require("testing.loveStub")
|
|
|
|
local luaunit = require("testing.luaunit")
|
|
local FlexLove = require("FlexLove")
|
|
local Color = require("modules.Color")
|
|
|
|
-- Initialize FlexLove
|
|
FlexLove.init()
|
|
|
|
-- Test suite for resize behavior with different unit types
|
|
TestElementResize = {}
|
|
|
|
function TestElementResize:setUp()
|
|
love.window.setMode(1920, 1080)
|
|
FlexLove.beginFrame()
|
|
end
|
|
|
|
function TestElementResize:tearDown()
|
|
FlexLove.endFrame()
|
|
end
|
|
|
|
function TestElementResize:test_resize_with_percentage_units()
|
|
-- Test that percentage units calculate correctly initially
|
|
local parent = FlexLove.new({
|
|
id = "resize_parent",
|
|
x = 0,
|
|
y = 0,
|
|
width = 1000,
|
|
height = 500,
|
|
})
|
|
|
|
local child = FlexLove.new({
|
|
id = "resize_child",
|
|
width = "50%",
|
|
height = "50%",
|
|
parent = parent,
|
|
})
|
|
|
|
-- Initial calculation should be 50% of parent
|
|
luaunit.assertEquals(child.width, 500)
|
|
luaunit.assertEquals(child.height, 250)
|
|
|
|
-- Verify units are stored correctly
|
|
luaunit.assertEquals(child.units.width.unit, "%")
|
|
luaunit.assertEquals(child.units.height.unit, "%")
|
|
end
|
|
|
|
function TestElementResize:test_resize_with_viewport_units()
|
|
-- Test that viewport units calculate correctly
|
|
local element = FlexLove.new({
|
|
id = "vp_resize",
|
|
x = 0,
|
|
y = 0,
|
|
width = "50vw",
|
|
height = "50vh",
|
|
})
|
|
|
|
-- Should be 50% of viewport (1920x1080)
|
|
luaunit.assertEquals(element.width, 960)
|
|
luaunit.assertEquals(element.height, 540)
|
|
|
|
-- Verify units are stored correctly
|
|
luaunit.assertEquals(element.units.width.unit, "vw")
|
|
luaunit.assertEquals(element.units.height.unit, "vh")
|
|
end
|
|
|
|
function TestElementResize:test_resize_with_textSize_scaling()
|
|
-- Test that textSize with viewport units calculates correctly
|
|
local element = FlexLove.new({
|
|
id = "text_resize",
|
|
x = 0,
|
|
y = 0,
|
|
width = 200,
|
|
height = 100,
|
|
text = "Test",
|
|
textSize = "2vh",
|
|
autoScaleText = true,
|
|
})
|
|
|
|
-- 2vh of 1080 = 21.6
|
|
luaunit.assertAlmostEquals(element.textSize, 21.6, 0.1)
|
|
|
|
-- Verify unit is stored
|
|
luaunit.assertEquals(element.units.textSize.unit, "vh")
|
|
end
|
|
|
|
-- Test suite for positioning offset application (top/right/bottom/left)
|
|
TestElementPositioningOffsets = {}
|
|
|
|
function TestElementPositioningOffsets:setUp()
|
|
love.window.setMode(1920, 1080)
|
|
FlexLove.beginFrame()
|
|
end
|
|
|
|
function TestElementPositioningOffsets:tearDown()
|
|
FlexLove.endFrame()
|
|
end
|
|
|
|
function TestElementPositioningOffsets:test_applyPositioningOffsets_with_absolute()
|
|
local parent = FlexLove.new({
|
|
id = "offset_parent",
|
|
x = 0,
|
|
y = 0,
|
|
width = 500,
|
|
height = 500,
|
|
positioning = "absolute",
|
|
})
|
|
|
|
local child = FlexLove.new({
|
|
id = "offset_child",
|
|
width = 100,
|
|
height = 100,
|
|
positioning = "absolute",
|
|
top = 50,
|
|
left = 50,
|
|
parent = parent,
|
|
})
|
|
|
|
-- Apply positioning offsets
|
|
parent:applyPositioningOffsets(child)
|
|
|
|
-- Child should be offset from parent
|
|
luaunit.assertTrue(child.y >= parent.y + 50)
|
|
luaunit.assertTrue(child.x >= parent.x + 50)
|
|
end
|
|
|
|
function TestElementPositioningOffsets:test_applyPositioningOffsets_with_right_bottom()
|
|
local parent = FlexLove.new({
|
|
id = "rb_parent",
|
|
x = 0,
|
|
y = 0,
|
|
width = 500,
|
|
height = 500,
|
|
positioning = "relative",
|
|
})
|
|
|
|
local child = FlexLove.new({
|
|
id = "rb_child",
|
|
width = 100,
|
|
height = 100,
|
|
positioning = "absolute",
|
|
right = 50,
|
|
bottom = 50,
|
|
parent = parent,
|
|
})
|
|
|
|
parent:applyPositioningOffsets(child)
|
|
|
|
-- Child should be positioned from right/bottom
|
|
luaunit.assertNotNil(child.x)
|
|
luaunit.assertNotNil(child.y)
|
|
end
|
|
|
|
-- Test suite for scroll-related methods
|
|
TestElementScrollMethods = {}
|
|
|
|
function TestElementScrollMethods:setUp()
|
|
love.window.setMode(1920, 1080)
|
|
FlexLove.beginFrame()
|
|
end
|
|
|
|
function TestElementScrollMethods:tearDown()
|
|
FlexLove.endFrame()
|
|
end
|
|
|
|
function TestElementScrollMethods:test_scrollToTop()
|
|
local container = FlexLove.new({
|
|
id = "scroll_container",
|
|
x = 0,
|
|
y = 0,
|
|
width = 300,
|
|
height = 200,
|
|
overflow = "scroll",
|
|
positioning = "flex",
|
|
flexDirection = "vertical",
|
|
})
|
|
|
|
-- Add content that overflows
|
|
for i = 1, 10 do
|
|
FlexLove.new({
|
|
id = "item_" .. i,
|
|
width = 280,
|
|
height = 50,
|
|
parent = container,
|
|
})
|
|
end
|
|
|
|
-- Scroll down first
|
|
container:setScrollPosition(nil, 100)
|
|
local _, scrollY = container:getScrollPosition()
|
|
luaunit.assertEquals(scrollY, 100)
|
|
|
|
-- Scroll to top
|
|
container:scrollToTop()
|
|
_, scrollY = container:getScrollPosition()
|
|
luaunit.assertEquals(scrollY, 0)
|
|
end
|
|
|
|
function TestElementScrollMethods:test_scrollToBottom()
|
|
local container = FlexLove.new({
|
|
id = "scroll_bottom",
|
|
x = 0,
|
|
y = 0,
|
|
width = 300,
|
|
height = 200,
|
|
overflow = "scroll",
|
|
positioning = "flex",
|
|
flexDirection = "vertical",
|
|
})
|
|
|
|
-- Add overflowing content
|
|
for i = 1, 10 do
|
|
FlexLove.new({
|
|
id = "item_" .. i,
|
|
width = 280,
|
|
height = 50,
|
|
parent = container,
|
|
})
|
|
end
|
|
|
|
container:scrollToBottom()
|
|
|
|
local _, scrollY = container:getScrollPosition()
|
|
local _, maxScrollY = container:getMaxScroll()
|
|
|
|
luaunit.assertEquals(scrollY, maxScrollY)
|
|
end
|
|
|
|
function TestElementScrollMethods:test_scrollBy()
|
|
local container = FlexLove.new({
|
|
id = "scroll_by",
|
|
x = 0,
|
|
y = 0,
|
|
width = 300,
|
|
height = 200,
|
|
overflow = "scroll",
|
|
positioning = "flex",
|
|
flexDirection = "vertical",
|
|
})
|
|
|
|
for i = 1, 10 do
|
|
FlexLove.new({
|
|
id = "item_" .. i,
|
|
width = 280,
|
|
height = 50,
|
|
parent = container,
|
|
})
|
|
end
|
|
|
|
container:scrollBy(nil, 50)
|
|
local _, scrollY = container:getScrollPosition()
|
|
luaunit.assertEquals(scrollY, 50)
|
|
|
|
container:scrollBy(nil, 25)
|
|
_, scrollY = container:getScrollPosition()
|
|
luaunit.assertEquals(scrollY, 75)
|
|
end
|
|
|
|
function TestElementScrollMethods:test_getScrollPercentage()
|
|
local container = FlexLove.new({
|
|
id = "scroll_pct",
|
|
x = 0,
|
|
y = 0,
|
|
width = 300,
|
|
height = 200,
|
|
overflow = "scroll",
|
|
positioning = "flex",
|
|
flexDirection = "vertical",
|
|
})
|
|
|
|
for i = 1, 10 do
|
|
FlexLove.new({
|
|
id = "item_" .. i,
|
|
width = 280,
|
|
height = 50,
|
|
parent = container,
|
|
})
|
|
end
|
|
|
|
-- At top
|
|
local _, percentY = container:getScrollPercentage()
|
|
luaunit.assertEquals(percentY, 0)
|
|
|
|
-- Scroll halfway
|
|
local _, maxScrollY = container:getMaxScroll()
|
|
container:setScrollPosition(nil, maxScrollY / 2)
|
|
_, percentY = container:getScrollPercentage()
|
|
luaunit.assertAlmostEquals(percentY, 0.5, 0.01)
|
|
end
|
|
|
|
-- Test suite for auto-sizing with complex scenarios
|
|
TestElementComplexAutoSizing = {}
|
|
|
|
function TestElementComplexAutoSizing:setUp()
|
|
love.window.setMode(1920, 1080)
|
|
FlexLove.beginFrame()
|
|
end
|
|
|
|
function TestElementComplexAutoSizing:tearDown()
|
|
FlexLove.endFrame()
|
|
end
|
|
|
|
function TestElementComplexAutoSizing:test_autosize_with_nested_flex()
|
|
local root = FlexLove.new({
|
|
id = "root",
|
|
x = 0,
|
|
y = 0,
|
|
positioning = "flex",
|
|
flexDirection = "vertical",
|
|
})
|
|
|
|
local row1 = FlexLove.new({
|
|
id = "row1",
|
|
positioning = "flex",
|
|
flexDirection = "horizontal",
|
|
parent = root,
|
|
})
|
|
|
|
FlexLove.new({
|
|
id = "item1",
|
|
width = 100,
|
|
height = 50,
|
|
parent = row1,
|
|
})
|
|
|
|
FlexLove.new({
|
|
id = "item2",
|
|
width = 100,
|
|
height = 50,
|
|
parent = row1,
|
|
})
|
|
|
|
-- Root should auto-size to contain row
|
|
luaunit.assertTrue(root.width >= 200)
|
|
luaunit.assertTrue(root.height >= 50)
|
|
end
|
|
|
|
function TestElementComplexAutoSizing:test_autosize_with_absolutely_positioned_child()
|
|
local parent = FlexLove.new({
|
|
id = "abs_parent",
|
|
x = 0,
|
|
y = 0,
|
|
positioning = "flex",
|
|
})
|
|
|
|
-- Regular child affects size
|
|
FlexLove.new({
|
|
id = "regular",
|
|
width = 100,
|
|
height = 100,
|
|
parent = parent,
|
|
})
|
|
|
|
-- Absolutely positioned child should NOT affect parent size
|
|
FlexLove.new({
|
|
id = "absolute",
|
|
width = 200,
|
|
height = 200,
|
|
positioning = "absolute",
|
|
parent = parent,
|
|
})
|
|
|
|
-- Parent should only size to regular child
|
|
luaunit.assertTrue(parent.width < 150)
|
|
luaunit.assertTrue(parent.height < 150)
|
|
end
|
|
|
|
function TestElementComplexAutoSizing:test_autosize_with_margin()
|
|
local parent = FlexLove.new({
|
|
id = "margin_parent",
|
|
x = 0,
|
|
y = 0,
|
|
positioning = "flex",
|
|
flexDirection = "horizontal",
|
|
})
|
|
|
|
-- Add two children with margins to test margin collapsing
|
|
FlexLove.new({
|
|
id = "margin_child1",
|
|
width = 100,
|
|
height = 100,
|
|
margin = { right = 20 },
|
|
parent = parent,
|
|
})
|
|
|
|
FlexLove.new({
|
|
id = "margin_child2",
|
|
width = 100,
|
|
height = 100,
|
|
margin = { left = 20 },
|
|
parent = parent,
|
|
})
|
|
|
|
-- Parent should size to children (margins don't add to content size in flex layout)
|
|
luaunit.assertEquals(parent.width, 200)
|
|
luaunit.assertEquals(parent.height, 100)
|
|
end
|
|
|
|
-- Test suite for theme integration
|
|
TestElementThemeIntegration = {}
|
|
|
|
function TestElementThemeIntegration:setUp()
|
|
love.window.setMode(1920, 1080)
|
|
FlexLove.beginFrame()
|
|
end
|
|
|
|
function TestElementThemeIntegration:tearDown()
|
|
FlexLove.endFrame()
|
|
end
|
|
|
|
function TestElementThemeIntegration:test_getScaledContentPadding()
|
|
local element = FlexLove.new({
|
|
id = "themed",
|
|
x = 0,
|
|
y = 0,
|
|
width = 200,
|
|
height = 100,
|
|
})
|
|
|
|
local padding = element:getScaledContentPadding()
|
|
-- Should return nil if no theme component
|
|
luaunit.assertNil(padding)
|
|
end
|
|
|
|
function TestElementThemeIntegration:test_getAvailableContentWidth_with_padding()
|
|
local element = FlexLove.new({
|
|
id = "content_width",
|
|
x = 0,
|
|
y = 0,
|
|
width = 200,
|
|
height = 100,
|
|
padding = 10,
|
|
})
|
|
|
|
local availableWidth = element:getAvailableContentWidth()
|
|
-- Should be width minus padding
|
|
luaunit.assertEquals(availableWidth, 180) -- 200 - 10*2
|
|
end
|
|
|
|
function TestElementThemeIntegration:test_getAvailableContentHeight_with_padding()
|
|
local element = FlexLove.new({
|
|
id = "content_height",
|
|
x = 0,
|
|
y = 0,
|
|
width = 200,
|
|
height = 100,
|
|
padding = 10,
|
|
})
|
|
|
|
local availableHeight = element:getAvailableContentHeight()
|
|
luaunit.assertEquals(availableHeight, 80) -- 100 - 10*2
|
|
end
|
|
|
|
-- Test suite for child management edge cases
|
|
TestElementChildManagementEdgeCases = {}
|
|
|
|
function TestElementChildManagementEdgeCases:setUp()
|
|
love.window.setMode(1920, 1080)
|
|
FlexLove.beginFrame()
|
|
end
|
|
|
|
function TestElementChildManagementEdgeCases:tearDown()
|
|
FlexLove.endFrame()
|
|
end
|
|
|
|
function TestElementChildManagementEdgeCases:test_addChild_triggers_autosize_recalc()
|
|
local parent = FlexLove.new({
|
|
id = "dynamic_parent",
|
|
x = 0,
|
|
y = 0,
|
|
positioning = "flex",
|
|
})
|
|
|
|
local initialWidth = parent.width
|
|
local initialHeight = parent.height
|
|
|
|
-- Add child dynamically
|
|
local child = FlexLove.new({
|
|
id = "dynamic_child",
|
|
width = 150,
|
|
height = 150,
|
|
})
|
|
|
|
parent:addChild(child)
|
|
|
|
-- Parent should have resized
|
|
luaunit.assertTrue(parent.width >= initialWidth)
|
|
luaunit.assertTrue(parent.height >= initialHeight)
|
|
end
|
|
|
|
function TestElementChildManagementEdgeCases:test_removeChild_triggers_autosize_recalc()
|
|
local parent = FlexLove.new({
|
|
id = "shrink_parent",
|
|
x = 0,
|
|
y = 0,
|
|
positioning = "flex",
|
|
})
|
|
|
|
local child1 = FlexLove.new({
|
|
id = "child1",
|
|
width = 100,
|
|
height = 100,
|
|
parent = parent,
|
|
})
|
|
|
|
local child2 = FlexLove.new({
|
|
id = "child2",
|
|
width = 100,
|
|
height = 100,
|
|
parent = parent,
|
|
})
|
|
|
|
local widthWithTwo = parent.width
|
|
|
|
parent:removeChild(child2)
|
|
|
|
-- Parent should shrink
|
|
luaunit.assertTrue(parent.width < widthWithTwo)
|
|
end
|
|
|
|
function TestElementChildManagementEdgeCases:test_clearChildren_resets_autosize()
|
|
local parent = FlexLove.new({
|
|
id = "clear_parent",
|
|
x = 0,
|
|
y = 0,
|
|
positioning = "flex",
|
|
})
|
|
|
|
for i = 1, 5 do
|
|
FlexLove.new({
|
|
id = "child_" .. i,
|
|
width = 50,
|
|
height = 50,
|
|
parent = parent,
|
|
})
|
|
end
|
|
|
|
local widthWithChildren = parent.width
|
|
|
|
parent:clearChildren()
|
|
|
|
-- Parent should shrink to minimal size
|
|
luaunit.assertTrue(parent.width < widthWithChildren)
|
|
luaunit.assertEquals(#parent.children, 0)
|
|
end
|
|
|
|
-- Test suite for grid layout edge cases
|
|
TestElementGridEdgeCases = {}
|
|
|
|
function TestElementGridEdgeCases:setUp()
|
|
love.window.setMode(1920, 1080)
|
|
FlexLove.beginFrame()
|
|
end
|
|
|
|
function TestElementGridEdgeCases:tearDown()
|
|
FlexLove.endFrame()
|
|
end
|
|
|
|
function TestElementGridEdgeCases:test_grid_with_uneven_children()
|
|
local grid = FlexLove.new({
|
|
id = "uneven_grid",
|
|
x = 0,
|
|
y = 0,
|
|
width = 300,
|
|
height = 300,
|
|
positioning = "grid",
|
|
gridRows = 2,
|
|
gridColumns = 2,
|
|
})
|
|
|
|
-- Add only 3 children to a 2x2 grid
|
|
for i = 1, 3 do
|
|
FlexLove.new({
|
|
id = "grid_item_" .. i,
|
|
width = 50,
|
|
height = 50,
|
|
parent = grid,
|
|
})
|
|
end
|
|
|
|
luaunit.assertEquals(#grid.children, 3)
|
|
end
|
|
|
|
function TestElementGridEdgeCases:test_grid_with_percentage_gaps()
|
|
local grid = FlexLove.new({
|
|
id = "pct_gap_grid",
|
|
x = 0,
|
|
y = 0,
|
|
width = 400,
|
|
height = 400,
|
|
positioning = "grid",
|
|
gridRows = 2,
|
|
gridColumns = 2,
|
|
columnGap = "5%",
|
|
rowGap = "5%",
|
|
})
|
|
|
|
luaunit.assertNotNil(grid.columnGap)
|
|
luaunit.assertNotNil(grid.rowGap)
|
|
luaunit.assertTrue(grid.columnGap > 0)
|
|
luaunit.assertTrue(grid.rowGap > 0)
|
|
end
|
|
|
|
-- Run tests
|
|
if not _G.RUNNING_ALL_TESTS then
|
|
os.exit(luaunit.LuaUnit.run())
|
|
end
|