494 lines
15 KiB
Lua
494 lines
15 KiB
Lua
-- Test file for comprehensive text scaling functionality
|
|
-- This tests all text scaling scenarios including edge cases and multiple resize events
|
|
|
|
package.path = package.path .. ";?.lua"
|
|
|
|
local luaunit = require("testing/luaunit")
|
|
require("testing/loveStub") -- Required to mock LOVE functions
|
|
local FlexLove = require("FlexLove")
|
|
local Gui = FlexLove.GUI
|
|
|
|
-- Test suite for comprehensive text scaling
|
|
TestTextScaling = {}
|
|
|
|
-- Basic functionality tests
|
|
function TestTextScaling.testFixedTextSize()
|
|
-- Create an element with fixed textSize in pixels (auto-scaling disabled)
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 100,
|
|
height = 50,
|
|
textSize = 16, -- Fixed size in pixels
|
|
autoScaleText = false, -- Disable auto-scaling for truly fixed size
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Check initial state
|
|
luaunit.assertEquals(element.textSize, 16)
|
|
luaunit.assertEquals(element.units.textSize.unit, "px")
|
|
|
|
-- Simulate multiple resizes
|
|
element:resize(1600, 1200)
|
|
luaunit.assertEquals(element.textSize, 16) -- Should remain unchanged
|
|
|
|
element:resize(400, 300)
|
|
luaunit.assertEquals(element.textSize, 16) -- Should remain unchanged
|
|
end
|
|
|
|
function TestTextScaling.testPercentageTextSize()
|
|
-- Create an element with percentage textSize (relative to viewport height)
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 100,
|
|
height = 50,
|
|
textSize = "5%", -- Percentage of viewport height
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Check initial state (5% of 600px = 30px)
|
|
luaunit.assertEquals(element.units.textSize.unit, "%")
|
|
luaunit.assertEquals(element.units.textSize.value, 5)
|
|
luaunit.assertEquals(element.textSize, 30.0)
|
|
|
|
-- Simulate resize to larger viewport (5% of 1200px = 60px)
|
|
element:resize(1600, 1200)
|
|
luaunit.assertEquals(element.textSize, 60.0)
|
|
|
|
-- Simulate resize to smaller viewport (5% of 300px = 15px)
|
|
element:resize(400, 300)
|
|
luaunit.assertEquals(element.textSize, 15.0)
|
|
end
|
|
|
|
function TestTextScaling.testVwTextSize()
|
|
-- Create an element with vw textSize
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 100,
|
|
height = 50,
|
|
textSize = "2vw", -- 2% of viewport width
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Check initial state (2% of 800px = 16px)
|
|
luaunit.assertEquals(element.units.textSize.unit, "vw")
|
|
luaunit.assertEquals(element.units.textSize.value, 2)
|
|
luaunit.assertEquals(element.textSize, 16.0)
|
|
|
|
-- Simulate resize to larger viewport (2% of 1600px = 32px)
|
|
element:resize(1600, 1200)
|
|
luaunit.assertEquals(element.textSize, 32.0)
|
|
|
|
-- Simulate resize to smaller viewport (2% of 400px = 8px)
|
|
element:resize(400, 300)
|
|
luaunit.assertEquals(element.textSize, 8.0)
|
|
end
|
|
|
|
function TestTextScaling.testVhTextSize()
|
|
-- Create an element with vh textSize
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 100,
|
|
height = 50,
|
|
textSize = "3vh", -- 3% of viewport height
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Check initial state (3% of 600px = 18px)
|
|
luaunit.assertEquals(element.units.textSize.unit, "vh")
|
|
luaunit.assertEquals(element.units.textSize.value, 3)
|
|
luaunit.assertEquals(element.textSize, 18.0)
|
|
|
|
-- Simulate resize to larger viewport (3% of 1200px = 36px)
|
|
element:resize(1600, 1200)
|
|
luaunit.assertEquals(element.textSize, 36.0)
|
|
|
|
-- Simulate resize to smaller viewport (3% of 300px = 9px)
|
|
element:resize(400, 300)
|
|
luaunit.assertEquals(element.textSize, 9.0)
|
|
end
|
|
|
|
function TestTextScaling.testNoTextSize()
|
|
-- Create an element without textSize specified (auto-scaling enabled by default)
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 100,
|
|
height = 50,
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Check initial state - should auto-scale by default (1.5vh)
|
|
luaunit.assertEquals(element.autoScaleText, true)
|
|
luaunit.assertEquals(element.units.textSize.value, 1.5)
|
|
luaunit.assertEquals(element.units.textSize.unit, "vh")
|
|
luaunit.assertEquals(element.textSize, 9.0) -- 1.5% of 600px
|
|
|
|
-- Resize should scale the text
|
|
element:resize(1600, 1200)
|
|
luaunit.assertEquals(element.textSize, 18.0) -- 1.5% of 1200px
|
|
|
|
-- Test with auto-scaling disabled
|
|
local elementNoScale = Gui.new({
|
|
id = "testElementNoScale",
|
|
width = 100,
|
|
height = 50,
|
|
text = "Hello World",
|
|
autoScaleText = false,
|
|
})
|
|
|
|
luaunit.assertEquals(elementNoScale.autoScaleText, false)
|
|
luaunit.assertEquals(elementNoScale.units.textSize.value, nil)
|
|
luaunit.assertEquals(elementNoScale.textSize, 12) -- Fixed 12px
|
|
|
|
-- Resize should not affect textSize when auto-scaling is disabled
|
|
elementNoScale:resize(1600, 1200)
|
|
luaunit.assertEquals(elementNoScale.textSize, 12)
|
|
end
|
|
|
|
-- Edge case tests
|
|
function TestTextScaling.testZeroPercentageTextSize()
|
|
-- Create an element with 0% textSize (protected to minimum 1px)
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 100,
|
|
height = 50,
|
|
textSize = "0%",
|
|
text = "Hello World",
|
|
})
|
|
|
|
luaunit.assertEquals(element.textSize, 1) -- Protected to minimum 1px
|
|
|
|
-- Should remain at minimum after resize
|
|
element:resize(1600, 1200)
|
|
luaunit.assertEquals(element.textSize, 1) -- Protected to minimum 1px
|
|
end
|
|
|
|
function TestTextScaling.testVerySmallTextSize()
|
|
-- Create an element with very small textSize (protected to minimum 1px)
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 100,
|
|
height = 50,
|
|
textSize = "0.1vh",
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Check initial state (0.1% of 600px = 0.6px, protected to 1px)
|
|
luaunit.assertEquals(element.textSize, 1)
|
|
|
|
-- Should scale proportionally when above minimum
|
|
element:resize(1600, 1200)
|
|
luaunit.assertEquals(element.textSize, 1.2) -- 0.1% of 1200px = 1.2px
|
|
end
|
|
|
|
function TestTextScaling.testVeryLargeTextSize()
|
|
-- Create an element with very large textSize
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 100,
|
|
height = 50,
|
|
textSize = "50vh",
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Check initial state (50% of 600px = 300px)
|
|
luaunit.assertEquals(element.textSize, 300.0)
|
|
|
|
-- Should scale proportionally
|
|
element:resize(1600, 1200)
|
|
luaunit.assertEquals(element.textSize, 600.0) -- 50% of 1200px = 600px
|
|
end
|
|
|
|
function TestTextScaling.testDecimalUnits()
|
|
-- Create an element with decimal units
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 100,
|
|
height = 50,
|
|
textSize = "2.5vw",
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Check initial state (2.5% of 800px = 20px)
|
|
luaunit.assertEquals(element.textSize, 20.0)
|
|
|
|
-- Should handle decimal precision
|
|
element:resize(1000, 800)
|
|
luaunit.assertEquals(element.textSize, 25.0) -- 2.5% of 1000px = 25px
|
|
end
|
|
|
|
-- Multiple resize tests
|
|
function TestTextScaling.testMultipleResizes()
|
|
-- Create an element and perform multiple resize operations
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 100,
|
|
height = 50,
|
|
textSize = "4vh",
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Initial: 4% of 600px = 24px
|
|
luaunit.assertEquals(element.textSize, 24.0)
|
|
|
|
-- First resize: 4% of 800px = 32px
|
|
element:resize(1000, 800)
|
|
luaunit.assertEquals(element.textSize, 32.0)
|
|
|
|
-- Second resize: 4% of 400px = 16px
|
|
element:resize(500, 400)
|
|
luaunit.assertEquals(element.textSize, 16.0)
|
|
|
|
-- Third resize: 4% of 1000px = 40px
|
|
element:resize(1200, 1000)
|
|
luaunit.assertEquals(element.textSize, 40.0)
|
|
|
|
-- Return to original: 4% of 600px = 24px
|
|
element:resize(800, 600)
|
|
luaunit.assertEquals(element.textSize, 24.0)
|
|
end
|
|
|
|
-- Mixed unit tests
|
|
function TestTextScaling.testMixedUnitsInDifferentElements()
|
|
-- Create multiple elements with different unit types
|
|
local elements = {
|
|
Gui.new({ id = "px", textSize = 20, autoScaleText = false, text = "Fixed" }),
|
|
Gui.new({ id = "percent", textSize = "5%", text = "Percent" }),
|
|
Gui.new({ id = "vw", textSize = "3vw", text = "ViewWidth" }),
|
|
Gui.new({ id = "vh", textSize = "4vh", text = "ViewHeight" }),
|
|
}
|
|
|
|
-- Check initial states
|
|
luaunit.assertEquals(elements[1].textSize, 20) -- Fixed
|
|
luaunit.assertEquals(elements[2].textSize, 30.0) -- 5% of 600px
|
|
luaunit.assertEquals(elements[3].textSize, 24.0) -- 3% of 800px
|
|
luaunit.assertEquals(elements[4].textSize, 24.0) -- 4% of 600px
|
|
|
|
-- Resize all elements
|
|
for _, element in ipairs(elements) do
|
|
element:resize(1200, 900)
|
|
end
|
|
|
|
-- Check after resize
|
|
luaunit.assertEquals(elements[1].textSize, 20) -- Fixed (unchanged)
|
|
luaunit.assertEquals(elements[2].textSize, 45.0) -- 5% of 900px
|
|
luaunit.assertEquals(elements[3].textSize, 36.0) -- 3% of 1200px
|
|
luaunit.assertEquals(elements[4].textSize, 36.0) -- 4% of 900px
|
|
end
|
|
|
|
-- Test invalid units handling
|
|
function TestTextScaling.testInvalidUnits()
|
|
-- Test that invalid units are handled gracefully
|
|
local success, err = pcall(function()
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 100,
|
|
height = 50,
|
|
textSize = "5invalidunit",
|
|
text = "Hello World",
|
|
})
|
|
end)
|
|
|
|
-- Should handle invalid units gracefully (might error or default)
|
|
-- The exact behavior depends on implementation, but shouldn't crash
|
|
luaunit.assertTrue(success or string.find(tostring(err), "Unknown unit"))
|
|
end
|
|
|
|
-- Performance test for many resizes
|
|
function TestTextScaling.testPerformanceWithManyResizes()
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 100,
|
|
height = 50,
|
|
textSize = "2vh",
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Perform many resize operations
|
|
local startTime = os.clock()
|
|
for i = 1, 100 do
|
|
local width = 800 + (i * 2)
|
|
local height = 600 + (i * 2)
|
|
element:resize(width, height)
|
|
|
|
-- Verify the calculation is still correct
|
|
local expected = (2 / 100) * height
|
|
luaunit.assertEquals(element.textSize, expected)
|
|
end
|
|
local endTime = os.clock()
|
|
|
|
-- Should complete in reasonable time (less than 1 second for 100 resizes)
|
|
local duration = endTime - startTime
|
|
luaunit.assertTrue(duration < 1.0, "Performance test took too long: " .. duration .. " seconds")
|
|
end
|
|
|
|
-- Element-relative unit tests
|
|
function TestTextScaling.testElementWidthUnits()
|
|
-- Create an element with textSize relative to element width
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 200,
|
|
height = 100,
|
|
textSize = "10ew", -- 10% of element width
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Check initial state (10% of 200px = 20px)
|
|
luaunit.assertEquals(element.units.textSize.unit, "ew")
|
|
luaunit.assertEquals(element.units.textSize.value, 10)
|
|
luaunit.assertEquals(element.textSize, 20.0)
|
|
luaunit.assertEquals(element.width, 200)
|
|
|
|
-- Change element width and recalculate
|
|
element.width = 300
|
|
element:resize(800, 600)
|
|
luaunit.assertEquals(element.textSize, 30.0) -- 10% of 300px = 30px
|
|
end
|
|
|
|
function TestTextScaling.testElementHeightUnits()
|
|
-- Create an element with textSize relative to element height
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 200,
|
|
height = 100,
|
|
textSize = "15eh", -- 15% of element height
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Check initial state (15% of 100px = 15px)
|
|
luaunit.assertEquals(element.units.textSize.unit, "eh")
|
|
luaunit.assertEquals(element.units.textSize.value, 15)
|
|
luaunit.assertEquals(element.textSize, 15.0)
|
|
luaunit.assertEquals(element.height, 100)
|
|
|
|
-- Change element height and recalculate
|
|
element.height = 200
|
|
element:resize(800, 600)
|
|
luaunit.assertEquals(element.textSize, 30.0) -- 15% of 200px = 30px
|
|
end
|
|
|
|
function TestTextScaling.testElementRelativeWithViewportUnits()
|
|
-- Create an element with viewport-based size and element-relative textSize
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = "25%", -- 25% of viewport width = 200px (800px * 0.25)
|
|
height = "20%", -- 20% of viewport height = 120px (600px * 0.20)
|
|
textSize = "8ew", -- 8% of element width
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Check initial state
|
|
luaunit.assertEquals(element.width, 200.0) -- 25% of 800px
|
|
luaunit.assertEquals(element.height, 120.0) -- 20% of 600px
|
|
luaunit.assertEquals(element.textSize, 16.0) -- 8% of 200px
|
|
|
|
-- Resize viewport
|
|
element:resize(1600, 1200)
|
|
|
|
-- Element size should update with viewport, textSize should update with element size
|
|
luaunit.assertEquals(element.width, 400.0) -- 25% of 1600px
|
|
luaunit.assertEquals(element.height, 240.0) -- 20% of 1200px
|
|
luaunit.assertEquals(element.textSize, 32.0) -- 8% of 400px
|
|
end
|
|
|
|
-- Min/Max constraint tests
|
|
function TestTextScaling.testMinTextSizeConstraint()
|
|
-- Create element with textSize that would be smaller than minimum
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 200,
|
|
height = 100,
|
|
textSize = "2vh", -- 2% of 600px = 12px
|
|
minTextSize = 16, -- Minimum 16px
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Should be clamped to minimum
|
|
luaunit.assertEquals(element.textSize, 16)
|
|
|
|
-- Test with very small viewport
|
|
element:resize(400, 300) -- 2% of 300px = 6px, should stay at 16px
|
|
luaunit.assertEquals(element.textSize, 16)
|
|
end
|
|
|
|
function TestTextScaling.testMaxTextSizeConstraint()
|
|
-- Create element with textSize that would be larger than maximum
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 200,
|
|
height = 100,
|
|
textSize = "4vh", -- 4% of 600px = 24px
|
|
maxTextSize = 20, -- Maximum 20px
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Should be clamped to maximum
|
|
luaunit.assertEquals(element.textSize, 20)
|
|
|
|
-- Test with very large viewport
|
|
element:resize(1600, 1200) -- 4% of 1200px = 48px, should stay at 20px
|
|
luaunit.assertEquals(element.textSize, 20)
|
|
end
|
|
|
|
function TestTextScaling.testBothMinMaxConstraints()
|
|
-- Create element with both min and max constraints
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 200,
|
|
height = 100,
|
|
textSize = "3vh", -- 3% of 600px = 18px (within bounds)
|
|
minTextSize = 12,
|
|
maxTextSize = 24,
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Should be within bounds
|
|
luaunit.assertEquals(element.textSize, 18.0)
|
|
|
|
-- Test small viewport (should hit min)
|
|
element:resize(400, 300) -- 3% of 300px = 9px, should be clamped to 12px
|
|
luaunit.assertEquals(element.textSize, 12)
|
|
|
|
-- Test large viewport (should hit max)
|
|
element:resize(1600, 1200) -- 3% of 1200px = 36px, should be clamped to 24px
|
|
luaunit.assertEquals(element.textSize, 24)
|
|
end
|
|
|
|
function TestTextScaling.testConstraintsWithElementUnits()
|
|
-- Test constraints with element-relative units
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 100,
|
|
height = 50,
|
|
textSize = "20ew", -- 20% of 100px = 20px
|
|
minTextSize = 8,
|
|
maxTextSize = 15,
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Should be clamped to maximum
|
|
luaunit.assertEquals(element.textSize, 15)
|
|
|
|
-- Change width to trigger minimum
|
|
element.width = 30 -- 20% of 30px = 6px, should be clamped to 8px
|
|
element:resize(800, 600)
|
|
luaunit.assertEquals(element.textSize, 8)
|
|
end
|
|
|
|
function TestTextScaling.testConstraintsWithFixedTextSize()
|
|
-- Test that constraints work with fixed pixel textSize too
|
|
local element = Gui.new({
|
|
id = "testElement",
|
|
width = 200,
|
|
height = 100,
|
|
textSize = 25, -- Fixed 25px
|
|
minTextSize = 12,
|
|
maxTextSize = 20,
|
|
text = "Hello World",
|
|
})
|
|
|
|
-- Should be clamped to maximum even for fixed sizes
|
|
luaunit.assertEquals(element.textSize, 20)
|
|
end
|
|
|
|
luaunit.LuaUnit.run()
|