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

fixes to run individual

Browse Source
This commit is contained in:
Michael Freno
2025-12-12 20:46:16 -05:00
parent 1d6ad6018f
commit e9b532b8f8
28 changed files with 508 additions and 951 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
testing/__tests__/animation_test.lua
View File

@@ -1,29 +1,18 @@
-- Comprehensive test suite for Animation.lua
-- Consolidates all animation testing including core functionality, easing, properties, and keyframes
package.path = package.path .. ";./?.lua;./modules/?.lua"
require("testing.loveStub")
local luaunit = require("testing.luaunit")
local ErrorHandler = require("modules.ErrorHandler")
-- Initialize ErrorHandler
ErrorHandler.init({})
-- Setup package loader to map FlexLove.modules.X to modules/X
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function() return require("modules." .. moduleName) end
return function()
return require("modules." .. moduleName)
end
end
end)
-- Load FlexLove which properly initializes all dependencies
require("testing.loveStub")
local luaunit = require("testing.luaunit")
local FlexLove = require("FlexLove")
-- Initialize FlexLove
FlexLove.init()
local Animation = FlexLove.Animation

97
testing/__tests__/blur_test.lua
View File

@@ -1,15 +1,22 @@
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
require("testing.loveStub")
local luaunit = require("testing.luaunit")
-- only going to load blur (and ErrorHandler as its a required dependency for blur to work properly)
local Blur = require("modules.Blur")
local ErrorHandler = require("modules.ErrorHandler")
-- Initialize ErrorHandler
ErrorHandler.init({})
Blur.init({ ErrorHandler = ErrorHandler })
TestBlur = {}
function TestBlur:setUp()
@@ -23,42 +30,42 @@ end
function TestBlur:testNewWithNilQuality()
-- Should default to quality 5
local blur = Blur.new({quality = nil})
local blur = Blur.new({ quality = nil })
luaunit.assertNotNil(blur)
luaunit.assertEquals(blur.quality, 5)
end
function TestBlur:testNewWithZeroQuality()
-- Should clamp to minimum quality 1
local blur = Blur.new({quality = 0})
local blur = Blur.new({ quality = 0 })
luaunit.assertNotNil(blur)
luaunit.assertEquals(blur.quality, 1)
end
function TestBlur:testNewWithNegativeQuality()
-- Should clamp to minimum quality 1
local blur = Blur.new({quality = -5})
local blur = Blur.new({ quality = -5 })
luaunit.assertNotNil(blur)
luaunit.assertEquals(blur.quality, 1)
end
function TestBlur:testNewWithVeryHighQuality()
-- Should clamp to maximum quality 10
local blur = Blur.new({quality = 100})
local blur = Blur.new({ quality = 100 })
luaunit.assertNotNil(blur)
luaunit.assertEquals(blur.quality, 10)
end
function TestBlur:testNewWithQuality11()
-- Should clamp to maximum quality 10
local blur = Blur.new({quality = 11})
local blur = Blur.new({ quality = 11 })
luaunit.assertNotNil(blur)
luaunit.assertEquals(blur.quality, 10)
end
function TestBlur:testNewWithFractionalQuality()
-- Should work with fractional quality
local blur = Blur.new({quality = 5.5})
local blur = Blur.new({ quality = 5.5 })
luaunit.assertNotNil(blur)
luaunit.assertTrue(blur.quality >= 5 and blur.quality <= 6)
end
@@ -66,7 +73,7 @@ end
function TestBlur:testNewEnsuresOddTaps()
-- Taps must be odd for shader
for quality = 1, 10 do
local blur = Blur.new({quality = quality})
local blur = Blur.new({ quality = quality })
luaunit.assertTrue(blur.taps % 2 == 1, string.format("Quality %d produced even taps: %d", quality, blur.taps))
end
end
@@ -87,16 +94,16 @@ end
function TestBlur:testNewCreatesUniqueShaders()
-- Blur instances with same quality should share cached shaders (optimization)
local blur1 = Blur.new({quality = 5})
local blur2 = Blur.new({quality = 5})
local blur1 = Blur.new({ quality = 5 })
local blur2 = Blur.new({ quality = 5 })
luaunit.assertNotNil(blur1.shader)
luaunit.assertNotNil(blur2.shader)
-- Shaders should be the same object when quality matches (cached)
luaunit.assertEquals(blur1.shader, blur2.shader)
-- Different quality should result in different shaders
local blur3 = Blur.new({quality = 7})
local blur3 = Blur.new({ quality = 7 })
luaunit.assertNotEquals(blur1.shader, blur3.shader)
end
@@ -105,7 +112,7 @@ end
-- ============================================================================
function TestBlur:testApplyToRegionWithZeroRadius()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local called = false
local drawFunc = function()
called = true
@@ -117,7 +124,7 @@ function TestBlur:testApplyToRegionWithZeroRadius()
end
function TestBlur:testApplyToRegionWithNegativeRadius()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local called = false
local drawFunc = function()
called = true
@@ -129,7 +136,7 @@ function TestBlur:testApplyToRegionWithNegativeRadius()
end
function TestBlur:testApplyToRegionWithZeroWidth()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local called = false
local drawFunc = function()
called = true
@@ -141,7 +148,7 @@ function TestBlur:testApplyToRegionWithZeroWidth()
end
function TestBlur:testApplyToRegionWithZeroHeight()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local called = false
local drawFunc = function()
called = true
@@ -153,7 +160,7 @@ function TestBlur:testApplyToRegionWithZeroHeight()
end
function TestBlur:testApplyToRegionWithNegativeWidth()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local called = false
local drawFunc = function()
called = true
@@ -165,7 +172,7 @@ function TestBlur:testApplyToRegionWithNegativeWidth()
end
function TestBlur:testApplyToRegionWithNegativeHeight()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local called = false
local drawFunc = function()
called = true
@@ -177,7 +184,7 @@ function TestBlur:testApplyToRegionWithNegativeHeight()
end
function TestBlur:testApplyToRegionWithLargeRadius()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local called = false
local drawFunc = function()
called = true
@@ -189,7 +196,7 @@ function TestBlur:testApplyToRegionWithLargeRadius()
end
function TestBlur:testApplyToRegionWithNonFunctionDrawFunc()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
-- Should not error but warn through ErrorHandler
blur:applyToRegion(50, 0, 0, 100, 100, "not a function")
@@ -197,7 +204,7 @@ function TestBlur:testApplyToRegionWithNonFunctionDrawFunc()
end
function TestBlur:testApplyToRegionWithNilDrawFunc()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
-- Should not error but warn through ErrorHandler
blur:applyToRegion(50, 0, 0, 100, 100, nil)
@@ -205,7 +212,7 @@ function TestBlur:testApplyToRegionWithNilDrawFunc()
end
function TestBlur:testApplyToRegionWithNegativeCoordinates()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local called = false
local drawFunc = function()
called = true
@@ -217,7 +224,7 @@ function TestBlur:testApplyToRegionWithNegativeCoordinates()
end
function TestBlur:testApplyToRegionWithVerySmallDimensions()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local called = false
local drawFunc = function()
called = true
@@ -229,7 +236,7 @@ function TestBlur:testApplyToRegionWithVerySmallDimensions()
end
function TestBlur:testApplyToRegionWithVeryLargeDimensions()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local called = false
local drawFunc = function()
called = true
@@ -241,7 +248,7 @@ function TestBlur:testApplyToRegionWithVeryLargeDimensions()
end
function TestBlur:testApplyToRegionRadiusValues()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local called = false
local drawFunc = function()
called = true
@@ -251,22 +258,22 @@ function TestBlur:testApplyToRegionRadiusValues()
-- Small radius
blur:applyToRegion(5, 0, 0, 100, 100, drawFunc)
luaunit.assertTrue(called)
called = false
-- Medium radius
blur:applyToRegion(10, 0, 0, 100, 100, drawFunc)
luaunit.assertTrue(called)
called = false
-- Large radius
blur:applyToRegion(20, 0, 0, 100, 100, drawFunc)
luaunit.assertTrue(called)
called = false
-- Very large radius
blur:applyToRegion(50, 0, 0, 100, 100, drawFunc)
luaunit.assertTrue(called)
called = false
-- Fractional radius
blur:applyToRegion(2.5, 0, 0, 100, 100, drawFunc)
@@ -278,7 +285,7 @@ end
-- ============================================================================
function TestBlur:testApplyBackdropWithZeroRadius()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local mockCanvas = {
getDimensions = function()
return 100, 100
@@ -291,7 +298,7 @@ function TestBlur:testApplyBackdropWithZeroRadius()
end
function TestBlur:testApplyBackdropWithNegativeRadius()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local mockCanvas = {
getDimensions = function()
return 100, 100
@@ -304,7 +311,7 @@ function TestBlur:testApplyBackdropWithNegativeRadius()
end
function TestBlur:testApplyBackdropWithZeroWidth()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local mockCanvas = {
getDimensions = function()
return 100, 100
@@ -317,7 +324,7 @@ function TestBlur:testApplyBackdropWithZeroWidth()
end
function TestBlur:testApplyBackdropWithZeroHeight()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local mockCanvas = {
getDimensions = function()
return 100, 100
@@ -330,7 +337,7 @@ function TestBlur:testApplyBackdropWithZeroHeight()
end
function TestBlur:testApplyBackdropWithNilCanvas()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
-- Should not error but warn through ErrorHandler
blur:applyBackdrop(50, 0, 0, 100, 100, nil)
@@ -338,7 +345,7 @@ function TestBlur:testApplyBackdropWithNilCanvas()
end
function TestBlur:testApplyBackdropWithLargeRadius()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local mockCanvas = {
getDimensions = function()
return 100, 100
@@ -351,7 +358,7 @@ function TestBlur:testApplyBackdropWithLargeRadius()
end
function TestBlur:testApplyBackdropWithInvalidCanvas()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local invalidCanvas = "not a canvas"
-- Should error when trying to call getDimensions
@@ -361,7 +368,7 @@ function TestBlur:testApplyBackdropWithInvalidCanvas()
end
function TestBlur:testApplyBackdropRegionBeyondCanvas()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local mockCanvas = {
getDimensions = function()
return 100, 100
@@ -374,7 +381,7 @@ function TestBlur:testApplyBackdropRegionBeyondCanvas()
end
function TestBlur:testApplyBackdropWithNegativeCoordinates()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
local mockCanvas = {
getDimensions = function()
return 100, 100
@@ -391,12 +398,12 @@ end
-- ============================================================================
function TestBlur:testGetQuality()
local blur = Blur.new({quality = 7})
local blur = Blur.new({ quality = 7 })
luaunit.assertEquals(blur:getQuality(), 7)
end
function TestBlur:testGetTaps()
local blur = Blur.new({quality = 5})
local blur = Blur.new({ quality = 5 })
luaunit.assertIsNumber(blur:getTaps())
luaunit.assertTrue(blur:getTaps() > 0)
luaunit.assertTrue(blur:getTaps() % 2 == 1) -- Must be odd
@@ -408,8 +415,8 @@ end
function TestBlur:testClearCacheDoesNotError()
-- Create some blur instances to populate cache
local blur1 = Blur.new({quality = 5})
local blur2 = Blur.new({quality = 8})
Blur.new({ quality = 5 })
Blur.new({ quality = 8 })
-- Should not error
Blur.clearCache()

327
testing/__tests__/calc_test.lua
View File

@@ -1,22 +1,19 @@
---@diagnostic disable: undefined-global, undefined-field
local lu = require("testing.luaunit")
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
-- Mock love globals for testing environment
_G.love = _G.love or {}
_G.love.graphics = _G.love.graphics or {}
_G.love.graphics.getDimensions = function()
return 1920, 1080
end
_G.love.window = _G.love.window or {}
_G.love.window.getMode = function()
return 1920, 1080
end
-- Load Calc module directly
require("testing.loveStub")
local luaunit = require("testing.luaunit")
-- only going to load calc (and ErrorHandler as its a required dependency for calc to work properly)
local Calc = require("modules.Calc")
local ErrorHandler = require("modules.ErrorHandler")
-- Initialize with error handler
ErrorHandler.init({})
Calc.init({ ErrorHandler = ErrorHandler })
@@ -34,188 +31,188 @@ end
--- Test basic arithmetic: addition
function TestCalc:testBasicAddition()
local calcObj = Calc.new("100px + 50px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 150)
luaunit.assertEquals(result, 150)
end
--- Test basic arithmetic: subtraction
function TestCalc:testBasicSubtraction()
local calcObj = Calc.new("100px - 30px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 70)
luaunit.assertEquals(result, 70)
end
--- Test basic arithmetic: multiplication
function TestCalc:testBasicMultiplication()
local calcObj = Calc.new("10px * 5")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 50)
luaunit.assertEquals(result, 50)
end
--- Test basic arithmetic: division
function TestCalc:testBasicDivision()
local calcObj = Calc.new("100px / 4")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 25)
luaunit.assertEquals(result, 25)
end
--- Test negative numbers
function TestCalc:testNegativeNumbers()
local calcObj = Calc.new("-50px + 100px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 50)
luaunit.assertEquals(result, 50)
end
--- Test decimal numbers
function TestCalc:testDecimalNumbers()
local calcObj = Calc.new("10.5px + 5.5px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 16)
luaunit.assertEquals(result, 16)
end
--- Test percentage units
function TestCalc:testPercentageUnits()
local calcObj = Calc.new("50% + 25%")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, 1000, nil, nil) -- parent size = 1000
lu.assertEquals(result, 750) -- 50% of 1000 + 25% of 1000 = 500 + 250
luaunit.assertEquals(result, 750) -- 50% of 1000 + 25% of 1000 = 500 + 250
end
--- Test viewport width units (vw)
function TestCalc:testViewportWidthUnits()
local calcObj = Calc.new("50vw - 10vw")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 768) -- 40% of 1920 = 768
luaunit.assertEquals(result, 768) -- 40% of 1920 = 768
end
--- Test viewport height units (vh)
function TestCalc:testViewportHeightUnits()
local calcObj = Calc.new("50vh + 10vh")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 648) -- 60% of 1080 = 648
luaunit.assertEquals(result, 648) -- 60% of 1080 = 648
end
--- Test mixed units
function TestCalc:testMixedUnits()
local calcObj = Calc.new("50% - 10vw")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, 1000, nil, nil)
lu.assertEquals(result, 308) -- 50% of 1000 - 10% of 1920 = 500 - 192 = 308
luaunit.assertEquals(result, 308) -- 50% of 1000 - 10% of 1920 = 500 - 192 = 308
end
--- Test complex expression with multiple operations
function TestCalc:testComplexExpression()
local calcObj = Calc.new("100px + 50px - 20px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 130)
luaunit.assertEquals(result, 130)
end
--- Test parentheses for precedence
function TestCalc:testParentheses()
local calcObj = Calc.new("(100px + 50px) * 2")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 300)
luaunit.assertEquals(result, 300)
end
--- Test nested parentheses
function TestCalc:testNestedParentheses()
local calcObj = Calc.new("((100px + 50px) / 3) * 2")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 100) -- (150 / 3) * 2 = 50 * 2 = 100
luaunit.assertEquals(result, 100) -- (150 / 3) * 2 = 50 * 2 = 100
end
--- Test operator precedence (multiplication before addition)
function TestCalc:testOperatorPrecedence()
local calcObj = Calc.new("100px + 50px * 2")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 200) -- 100 + (50 * 2) = 100 + 100 = 200
luaunit.assertEquals(result, 200) -- 100 + (50 * 2) = 100 + 100 = 200
end
--- Test centering use case (50% - 10vw)
function TestCalc:testCenteringUseCase()
local calcObj = Calc.new("50% - 10vw")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- Assuming element width is 20vw (384px) and parent width is 1920px
-- 50% of parent - 10vw should center it
local result = Calc.resolve(calcObj, 1920, 1080, 1920, nil, nil)
lu.assertEquals(result, 768) -- 50% of 1920 - 10% of 1920 = 960 - 192 = 768
luaunit.assertEquals(result, 768) -- 50% of 1920 - 10% of 1920 = 960 - 192 = 768
end
--- Test element width units (ew)
function TestCalc:testElementWidthUnits()
local calcObj = Calc.new("100ew - 20ew")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, 500, nil) -- element width = 500
lu.assertEquals(result, 400) -- 80% of 500 = 400
luaunit.assertEquals(result, 400) -- 80% of 500 = 400
end
--- Test element height units (eh)
function TestCalc:testElementHeightUnits()
local calcObj = Calc.new("50eh + 25eh")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, 300) -- element height = 300
lu.assertEquals(result, 225) -- 75% of 300 = 225
luaunit.assertEquals(result, 225) -- 75% of 300 = 225
end
--- Test whitespace handling
function TestCalc:testWhitespaceHandling()
local calcObj = Calc.new(" 100px + 50px ")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 150)
luaunit.assertEquals(result, 150)
end
--- Test zero value
function TestCalc:testZeroValue()
--- Test zero valuaunite
function TestCalc:testZeroValuaunite()
local calcObj = Calc.new("100px - 100px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0)
luaunit.assertEquals(result, 0)
end
--- Test single value (no operation)
function TestCalc:testSingleValue()
--- Test single valuaunite (no operation)
function TestCalc:testSingleValuaunite()
local calcObj = Calc.new("100px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 100)
luaunit.assertEquals(result, 100)
end
--- Test isCalc function with non-calc values
function TestCalc:testIsCalcWithNonCalcValues()
lu.assertFalse(Calc.isCalc("100px"))
lu.assertFalse(Calc.isCalc(100))
lu.assertFalse(Calc.isCalc(nil))
lu.assertFalse(Calc.isCalc({}))
--- Test isCalc function with non-calc valuaunites
function TestCalc:testIsCalcWithNonCalcValuaunites()
luaunit.assertFalse(Calc.isCalc("100px"))
luaunit.assertFalse(Calc.isCalc(100))
luaunit.assertFalse(Calc.isCalc(nil))
luaunit.assertFalse(Calc.isCalc({}))
end
--- Test division by zero error handling
function TestCalc:testDivisionByZeroHandling()
local calcObj = Calc.new("100px / 0")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0) -- Should return 0 on division by zero error
luaunit.assertEquals(result, 0) -- Should return 0 on division by zero error
end
--- Test invalid expression error handling
function TestCalc:testInvalidExpressionHandling()
local calcObj = Calc.new("100px +") -- Incomplete expression
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- Should return 0 for invalid expressions
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0)
luaunit.assertEquals(result, 0)
end
--- Test complex real-world centering scenario
@@ -224,7 +221,7 @@ function TestCalc:testRealWorldCentering()
local xCalc = Calc.new("50% - 10vw")
local result = Calc.resolve(xCalc, 1920, 1080, 1920, nil, nil)
-- Expected: 50% of 1920 - 10% of 1920 = 960 - 192 = 768
lu.assertEquals(result, 768)
luaunit.assertEquals(result, 768)
end
-- ============================================================================
@@ -234,314 +231,314 @@ end
--- Test deeply nested parentheses (3 levels)
function TestCalc:testDeeplyNested3Levels()
local calcObj = Calc.new("(((100px + 50px) * 2) - 100px) / 2")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- (((150) * 2) - 100) / 2 = (300 - 100) / 2 = 200 / 2 = 100
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 100)
luaunit.assertEquals(result, 100)
end
--- Test deeply nested parentheses (5 levels)
function TestCalc:testDeeplyNested5Levels()
local calcObj = Calc.new("(((((10px + 5px) * 2) + 10px) * 2) - 20px) / 2")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- (((((15) * 2) + 10) * 2) - 20) / 2
-- ((((30) + 10) * 2) - 20) / 2
-- (((40) * 2) - 20) / 2
-- ((80) - 20) / 2
-- (60) / 2 = 30
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 30)
luaunit.assertEquals(result, 30)
end
--- Test deeply nested parentheses (10 levels)
function TestCalc:testDeeplyNested10Levels()
local calcObj = Calc.new("((((((((((2px * 2) * 2) * 2) * 2) * 2) * 2) * 2) * 2) * 2) * 2)")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- 2 * 2^10 = 2 * 1024 = 2048
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 2048)
luaunit.assertEquals(result, 2048)
end
--- Test complex multi-operation expression with all operators
function TestCalc:testComplexMultiOperationAllOperators()
local calcObj = Calc.new("100px + 50px - 20px * 2 / 4 + 30px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- Precedence: 20 * 2 = 40, 40 / 4 = 10
-- Then: 100 + 50 - 10 + 30 = 170
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 170)
luaunit.assertEquals(result, 170)
end
--- Test complex expression with mixed units and all operators
function TestCalc:testComplexMixedUnitsAllOperators()
local calcObj = Calc.new("50% + 10vw - 5vh * 2 / 4")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- 50% = 500 (parent 1000), 10vw = 192, 5vh = 54, 54 * 2 = 108, 108 / 4 = 27
-- 500 + 192 - 27 = 665
local result = Calc.resolve(calcObj, 1920, 1080, 1000, nil, nil)
lu.assertEquals(result, 665)
luaunit.assertEquals(result, 665)
end
--- Test nested parentheses with mixed operations
function TestCalc:testNestedParenthesesMixedOperations()
local calcObj = Calc.new("((100px + 50px) * (200px - 100px)) / 50px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- (150 * 100) / 50 = 15000 / 50 = 300
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 300)
luaunit.assertEquals(result, 300)
end
--- Test extremely long expression with many operations
function TestCalc:testExtremelyLongExpression()
local calcObj = Calc.new("10px + 20px + 30px + 40px + 50px - 5px - 10px - 15px * 2 / 3 + 100px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- 15 * 2 / 3 = 30 / 3 = 10
-- 10 + 20 + 30 + 40 + 50 - 5 - 10 - 10 + 100 = 225
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 225)
luaunit.assertEquals(result, 225)
end
--- Test alternating operations with parentheses
function TestCalc:testAlternatingOperationsWithParentheses()
local calcObj = Calc.new("(50px + 50px) * (100px - 50px) / (25px + 25px)")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- (100) * (50) / (50) = 5000 / 50 = 100
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 100)
luaunit.assertEquals(result, 100)
end
--- Test very large numbers
function TestCalc:testVeryLargeNumbers()
local calcObj = Calc.new("10000px + 50000px * 2")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- 50000 * 2 = 100000, 10000 + 100000 = 110000
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 110000)
luaunit.assertEquals(result, 110000)
end
--- Test very small decimal numbers
function TestCalc:testVerySmallDecimals()
local calcObj = Calc.new("0.1px + 0.2px + 0.3px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertAlmostEquals(result, 0.6, 0.0001)
luaunit.assertAlmostEquals(result, 0.6, 0.0001)
end
--- Test negative numbers in complex expression
function TestCalc:testNegativeNumbersInComplexExpression()
local calcObj = Calc.new("(-50px + 100px) * (-2px + 5px)")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- (50) * (3) = 150
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 150)
luaunit.assertEquals(result, 150)
end
--- Test multiple negative numbers
function TestCalc:testMultipleNegativeNumbers()
local calcObj = Calc.new("-50px - 30px - 20px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- -50 - 30 - 20 = -100
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, -100)
luaunit.assertEquals(result, -100)
end
--- Test negative result from subtraction
function TestCalc:testNegativeResultFromSubtraction()
local calcObj = Calc.new("50px - 100px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, -50)
luaunit.assertEquals(result, -50)
end
--- Test all unit types in single expression
function TestCalc:testAllUnitTypesInSingleExpression()
function TestCalc:testAlluaunitnitTypesInSingleExpression()
local calcObj = Calc.new("100px + 10% + 5vw + 5vh + 10ew + 10eh")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- 100 + 100 (10% of 1000) + 96 (5% of 1920) + 54 (5% of 1080) + 50 (10% of 500) + 30 (10% of 300)
-- = 100 + 100 + 96 + 54 + 50 + 30 = 430
local result = Calc.resolve(calcObj, 1920, 1080, 1000, 500, 300)
lu.assertEquals(result, 430)
luaunit.assertEquals(result, 430)
end
--- Test precedence with multiple levels
function TestCalc:testPrecedenceWithMultipleLevels()
local calcObj = Calc.new("100px + 50px * 2 - 30px / 3")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- 50 * 2 = 100, 30 / 3 = 10
-- 100 + 100 - 10 = 190
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 190)
luaunit.assertEquals(result, 190)
end
--- Test parentheses overriding precedence in complex way
function TestCalc:testParenthesesOverridingPrecedenceComplex()
local calcObj = Calc.new("(100px + 50px) * (2px + 3px) - (30px + 20px) / (5px - 3px)")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- (150) * (5) - (50) / (2) = 750 - 25 = 725
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 725)
luaunit.assertEquals(result, 725)
end
--- Test percentage calculations with zero parent
function TestCalc:testPercentageWithZeroParent()
local calcObj = Calc.new("50% + 100px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- 50% of 0 = 0, 0 + 100 = 100
local result = Calc.resolve(calcObj, 1920, 1080, 0, nil, nil)
lu.assertEquals(result, 100)
luaunit.assertEquals(result, 100)
end
--- Test element units without element dimensions
function TestCalc:testElementUnitsWithoutDimensions()
local calcObj = Calc.new("100ew + 50eh")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- Should return 0 + 0 = 0 due to missing dimensions
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0)
luaunit.assertEquals(result, 0)
end
--- Test mixed parentheses and operations at different levels
function TestCalc:testMixedParenthesesDifferentLevels()
local calcObj = Calc.new("((100px + 50px) * 2) + (200px / (10px + 10px))")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- ((150) * 2) + (200 / (20)) = 300 + 10 = 310
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 310)
luaunit.assertEquals(result, 310)
end
--- Test chain multiplication
function TestCalc:testChainMultiplication()
local calcObj = Calc.new("2px * 3 * 4 * 5")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- 2 * 3 * 4 * 5 = 120
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 120)
luaunit.assertEquals(result, 120)
end
--- Test chain division
function TestCalc:testChainDivision()
local calcObj = Calc.new("1000px / 2 / 5 / 10")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- 1000 / 2 / 5 / 10 = 500 / 5 / 10 = 100 / 10 = 10
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 10)
luaunit.assertEquals(result, 10)
end
--- Test fractional results
function TestCalc:testFractionalResults()
local calcObj = Calc.new("100px / 3")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertAlmostEquals(result, 33.333333333, 0.0001)
luaunit.assertAlmostEquals(result, 33.333333333, 0.0001)
end
--- Test complex viewport-based layout calculation
function TestCalc:testComplexViewportBasedLayout()
-- Simulate: margin-left = (100vw - element_width) / 2, where element is 30vw
local calcObj = Calc.new("(100vw - 30vw) / 2")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- (1920 - 576) / 2 = 1344 / 2 = 672
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 672)
luaunit.assertEquals(result, 672)
end
--- Test complex responsive sizing calculation
function TestCalc:testComplexResponsiveSizing()
-- Simulate: width = 100% - 20px padding on each side - 10vw margin
local calcObj = Calc.new("100% - 40px - 10vw")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- 100% of 1000 - 40 - 10% of 1920 = 1000 - 40 - 192 = 768
local result = Calc.resolve(calcObj, 1920, 1080, 1000, nil, nil)
lu.assertEquals(result, 768)
luaunit.assertEquals(result, 768)
end
--- Test expression with leading negative in parentheses
function TestCalc:testLeadingNegativeInParentheses()
local calcObj = Calc.new("100px + (-50px * 2)")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- 100 + (-100) = 0
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0)
luaunit.assertEquals(result, 0)
end
--- Test multiple parentheses groups at same level
function TestCalc:testMultipleParenthesesGroupsSameLevel()
local calcObj = Calc.new("(100px + 50px) + (200px - 100px) + (300px / 3)")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- 150 + 100 + 100 = 350
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 350)
luaunit.assertEquals(result, 350)
end
--- Test near-zero division result
function TestCalc:testNearZeroDivisionResult()
local calcObj = Calc.new("1px / 1000")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertAlmostEquals(result, 0.001, 0.0001)
luaunit.assertAlmostEquals(result, 0.001, 0.0001)
end
--- Test expression with only multiplication and division
function TestCalc:testOnlyMultiplicationAndDivision()
local calcObj = Calc.new("100px * 2 / 4 * 3 / 5")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- 100 * 2 / 4 * 3 / 5 = 200 / 4 * 3 / 5 = 50 * 3 / 5 = 150 / 5 = 30
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 30)
luaunit.assertEquals(result, 30)
end
--- Test expression with decimal percentages
function TestCalc:testDecimalPercentages()
local calcObj = Calc.new("12.5% + 37.5%")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- 12.5% + 37.5% = 50% of 1000 = 500
local result = Calc.resolve(calcObj, 1920, 1080, 1000, nil, nil)
lu.assertEquals(result, 500)
luaunit.assertEquals(result, 500)
end
--- Test unitless numbers in multiplication/division
function TestCalc:testUnitlessNumbersInMultDiv()
local calcObj = Calc.new("100px * 2.5 / 0.5")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- 100 * 2.5 / 0.5 = 250 / 0.5 = 500
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 500)
luaunit.assertEquals(result, 500)
end
--- Test deeply nested with negative numbers
function TestCalc:testDeeplyNestedWithNegatives()
local calcObj = Calc.new("((-100px + 200px) * (-2px + 5px)) / (10px - 5px)")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- ((100) * (3)) / (5) = 300 / 5 = 60
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 60)
luaunit.assertEquals(result, 60)
end
--- Test asymmetric nested parentheses
function TestCalc:testAsymmetricNestedParentheses()
local calcObj = Calc.new("((100px + 50px) * 2) + 200px / 4")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- (150 * 2) + (200 / 4) = 300 + 50 = 350
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 350)
luaunit.assertEquals(result, 350)
end
--- Test maximum nesting with all operations
function TestCalc:testMaximumNestingAllOperations()
local calcObj = Calc.new("((((100px + 50px) - 30px) * 2) / 4)")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- ((((150) - 30) * 2) / 4) = (((120) * 2) / 4) = ((240) / 4) = 60
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 60)
luaunit.assertEquals(result, 60)
end
--- Test whitespace in complex expressions
function TestCalc:testWhitespaceInComplexExpression()
local calcObj = Calc.new(" ( 100px + 50px ) * ( 2px + 3px ) ")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- (150) * (5) = 750
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 750)
luaunit.assertEquals(result, 750)
end
-- ============================================================================
@@ -551,111 +548,111 @@ end
--- Test mismatched parentheses (missing closing)
function TestCalc:testMismatchedParenthesesMissingClosing()
local calcObj = Calc.new("((100px + 50px) * 2")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- Should handle gracefully and return 0
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0)
luaunit.assertEquals(result, 0)
end
--- Test mismatched parentheses (missing opening)
function TestCalc:testMismatchedParenthesesMissingOpening()
local calcObj = Calc.new("100px + 50px) * 2")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- Should handle gracefully and return 0
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0)
luaunit.assertEquals(result, 0)
end
--- Test empty parentheses
function TestCalc:testEmptyParentheses()
local calcObj = Calc.new("100px + ()")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- Should handle gracefully and return 0
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0)
luaunit.assertEquals(result, 0)
end
--- Test consecutive operators
function TestCalc:testConsecutiveOperators()
local calcObj = Calc.new("100px ++ 50px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- Should handle gracefully and return 0
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0)
luaunit.assertEquals(result, 0)
end
--- Test trailing operator
function TestCalc:testTrailingOperator()
local calcObj = Calc.new("100px + 50px *")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- Should handle gracefully and return 0
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0)
luaunit.assertEquals(result, 0)
end
--- Test leading operator (non-negative)
function TestCalc:testLeadingOperatorNonNegative()
local calcObj = Calc.new("+ 100px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- Should handle gracefully and return 0
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0)
luaunit.assertEquals(result, 0)
end
--- Test invalid unit
function TestCalc:testInvalidUnit()
local calcObj = Calc.new("100xyz + 50px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- Should handle gracefully and return 0
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0)
luaunit.assertEquals(result, 0)
end
--- Test mixed invalid syntax
function TestCalc:testMixedInvalidSyntax()
local calcObj = Calc.new("100px + * 50px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- Should handle gracefully and return 0
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0)
luaunit.assertEquals(result, 0)
end
--- Test special characters
function TestCalc:testSpecialCharacters()
local calcObj = Calc.new("100px + 50px @ 20px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- Should handle gracefully and return 0
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0)
luaunit.assertEquals(result, 0)
end
--- Test extremely long invalid expression
function TestCalc:testExtremelyLongInvalidExpression()
local calcObj = Calc.new("100px + + + + + + + + + + 50px")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- Should handle gracefully and return 0
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0)
luaunit.assertEquals(result, 0)
end
--- Test division by calculated zero
function TestCalc:testDivisionByCalculatedZero()
local calcObj = Calc.new("100px / (50px - 50px)")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- Should handle division by zero and return 0
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0)
luaunit.assertEquals(result, 0)
end
--- Test nested division by zero
function TestCalc:testNestedDivisionByZero()
local calcObj = Calc.new("((100px + 50px) / 0) * 2")
lu.assertTrue(Calc.isCalc(calcObj))
luaunit.assertTrue(Calc.isCalc(calcObj))
-- Should handle division by zero and return 0
local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
lu.assertEquals(result, 0)
luaunit.assertEquals(result, 0)
end
if not _G.RUNNING_ALL_TESTS then
os.exit(lu.LuaUnit.run())
os.exit(luaunit.LuaUnit.run())
end

12
testing/__tests__/critical_failures_test.lua
View File

@@ -1,6 +1,16 @@
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
require("testing.loveStub")
local luaunit = require("testing.luaunit")
local ErrorHandler = require("modules.ErrorHandler") -- Load FlexLove
local FlexLove = require("FlexLove")
TestCriticalFailures = {}

48
testing/__tests__/element_mode_override_test.lua
View File

@@ -1,17 +1,4 @@
-- Test suite for Element mode override functionality
package.path = package.path .. ";./?.lua;./modules/?.lua"
-- Load love stub before anything else
require("testing.loveStub")
local luaunit = require("testing.luaunit")
local ErrorHandler = require("modules.ErrorHandler")
-- Initialize ErrorHandler
ErrorHandler.init({})
-- Setup package loader to map FlexLove.modules.X to modules/X
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
@@ -22,7 +9,8 @@ table.insert(originalSearchers, 2, function(modname)
end
end)
-- Load FlexLove which properly initializes all dependencies
require("testing.loveStub")
local luaunit = require("testing.luaunit")
local FlexLove = require("FlexLove")
local StateManager = require("modules.StateManager")
@@ -85,24 +73,6 @@ function TestElementModeOverride:test_modeResolution_nilUsesGlobalRetained()
luaunit.assertEquals(element._elementMode, "retained")
end
-- Test 05: ID auto-generation only for immediate mode
function TestElementModeOverride:test_idGeneration_onlyForImmediate()
-- Immediate element without ID should get auto-generated ID
local immediateEl = FlexLove.new({
mode = "immediate",
text = "Immediate",
})
luaunit.assertNotNil(immediateEl.id)
luaunit.assertNotEquals(immediateEl.id, "")
-- Retained element without ID should have empty ID
local retainedEl = FlexLove.new({
mode = "retained",
text = "Retained",
})
luaunit.assertEquals(retainedEl.id, "")
end
-- Test 06: Immediate override in retained context
function TestElementModeOverride:test_immediateOverrideInRetainedContext()
FlexLove.setMode("retained")
@@ -117,20 +87,6 @@ function TestElementModeOverride:test_immediateOverrideInRetainedContext()
luaunit.assertEquals(element.id, "test-immediate")
end
-- Test 07: Retained override in immediate context
function TestElementModeOverride:test_retainedOverrideInImmediateContext()
FlexLove.setMode("immediate")
FlexLove.beginFrame()
local element = FlexLove.new({
mode = "retained",
text = "Retained in immediate context",
})
luaunit.assertEquals(element._elementMode, "retained")
luaunit.assertEquals(element.id, "") -- Should not auto-generate ID
end
-- Test 08: Mixed-mode parent-child (immediate parent, retained child)
function TestElementModeOverride:test_mixedMode_immediateParent_retainedChild()
FlexLove.setMode("immediate")

44
testing/__tests__/element_test.lua
View File

@@ -1,32 +1,17 @@
-- Comprehensive test suite for Element.lua
-- Tests element creation, size calculations, positioning, layout, scroll, styling, and edge cases
package.path = package.path .. ";./?.lua;./modules/?.lua"
-- Load love stub before anything else
require("testing.loveStub")
local luaunit = require("testing.luaunit")
local ErrorHandler = require("modules.ErrorHandler")
-- Initialize ErrorHandler
ErrorHandler.init({})
-- Setup package loader to map FlexLove.modules.X to modules/X
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function() return require("modules." .. moduleName) end
return function()
return require("modules." .. moduleName)
end
end
end)
-- Load FlexLove which properly initializes all dependencies
require("testing.loveStub")
local luaunit = require("testing.luaunit")
local FlexLove = require("FlexLove")
local Element = require("modules.Element")
local Color = require("modules.Color")
-- Initialize FlexLove
FlexLove.init()
-- ============================================================================
@@ -37,7 +22,7 @@ local function createBasicElement(props)
props = props or {}
props.width = props.width or 100
props.height = props.height or 100
return Element.new(props)
return FlexLove.new(props)
end
-- ============================================================================
@@ -47,7 +32,7 @@ end
TestElementCreation = {}
function TestElementCreation:setUp()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
end
function TestElementCreation:tearDown()
@@ -92,7 +77,7 @@ function TestElementCreation:test_element_with_backgroundColor()
y = 0,
width = 100,
height = 100,
backgroundColor = { 1, 0, 0, 1 },
backgroundColor = FlexLove.Color.new(1, 0, 0, 1),
})
luaunit.assertNotNil(element)
@@ -195,7 +180,7 @@ end
TestElementSizing = {}
function TestElementSizing:setUp()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
end
function TestElementSizing:tearDown()
@@ -607,7 +592,7 @@ end
TestElementFlex = {}
function TestElementFlex:setUp()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
end
function TestElementFlex:tearDown()
@@ -761,12 +746,13 @@ end
TestElementStyling = {}
function TestElementStyling:setUp()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
end
function TestElementStyling:tearDown()
FlexLove.endFrame()
end
local Color = FlexLove.Color
function TestElementStyling:test_element_with_border()
local element = FlexLove.new({
@@ -886,7 +872,7 @@ function TestElementStyling:test_element_with_corner_radius_table()
luaunit.assertNotNil(element.cornerRadius)
luaunit.assertEquals(type(element.cornerRadius), "number")
luaunit.assertEquals(element.cornerRadius, 10)
-- Test non-uniform radius (should be stored as table)
local element2 = FlexLove.new({
id = "test2",
@@ -896,7 +882,7 @@ function TestElementStyling:test_element_with_corner_radius_table()
height = 100,
cornerRadius = { topLeft = 5, topRight = 10, bottomLeft = 15, bottomRight = 20 },
})
luaunit.assertNotNil(element2.cornerRadius)
luaunit.assertEquals(type(element2.cornerRadius), "table")
luaunit.assertEquals(element2.cornerRadius.topLeft, 5)
@@ -929,7 +915,7 @@ end
TestElementMethods = {}
function TestElementMethods:setUp()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
end
function TestElementMethods:tearDown()

14
testing/__tests__/event_handler_test.lua
View File

@@ -1,5 +1,13 @@
-- Test suite for EventHandler module
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
require("testing.loveStub")
local luaunit = require("testing.luaunit")
@@ -184,7 +192,7 @@ end
-- Test: processMouseEvents() returns early if no element
-- function TestEventHandler:test_processMouseEvents_no_element()
-- local handler = createEventHandler()
--
--
-- -- Should not error
-- handler:processMouseEvents(element, 50, 50, true, true)
-- end
@@ -500,7 +508,7 @@ end
-- Test: processTouchEvents() returns early if no element
-- function TestEventHandler:test_processTouchEvents_no_element()
-- local handler = createEventHandler()
--
--
-- -- Should not error
-- handler:processTouchEvents(element)
-- end

18
testing/__tests__/flexlove_test.lua
View File

@@ -1,15 +1,25 @@
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
local luaunit = require("testing.luaunit")
local ErrorHandler = require("modules.ErrorHandler")
require("testing.loveStub")
local FlexLove = require("FlexLove")
local Color = require("modules.Color")
local Theme = require("modules.Theme")
ErrorHandler.init({})
local Color = FlexLove.Color
local Theme = FlexLove.Theme
TestFlexLove = {}
function TestFlexLove:setUp()
FlexLove.destroy()
FlexLove.init()
FlexLove.setMode("retained")
end

42
testing/__tests__/grid_test.lua
View File

@@ -1,25 +1,23 @@
-- Test suite for Grid layout functionality
-- Grid layout has 0% test coverage despite being integrated into the system
package.path = package.path .. ";./?.lua;./modules/?.lua"
require("testing.loveStub")
local luaunit = require("testing.luaunit")
-- Setup package loader to map FlexLove.modules.X to modules/X
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function() return require("modules." .. moduleName) end
return function()
return require("modules." .. moduleName)
end
end
end)
require("testing.loveStub")
local luaunit = require("testing.luaunit")
local FlexLove = require("FlexLove")
TestGridLayout = {}
function TestGridLayout:setUp()
FlexLove.beginFrame(1920, 1080)
FlexLove.init()
FlexLove.beginFrame()
end
function TestGridLayout:tearDown()
@@ -46,7 +44,7 @@ function TestGridLayout:test_default_grid_single_child()
})
FlexLove.endFrame()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
-- Child should be stretched to fill the entire grid cell
luaunit.assertEquals(child.x, 0, "Child should be at x=0")
@@ -79,7 +77,7 @@ function TestGridLayout:test_2x2_grid_four_children()
end
FlexLove.endFrame()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
-- Each cell should be 200x200
-- Child 1: top-left (0, 0)
@@ -127,7 +125,7 @@ function TestGridLayout:test_grid_with_gaps()
end
FlexLove.endFrame()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
-- Cell size: (420 - 20) / 2 = 200, (320 - 20) / 2 = 150
luaunit.assertEquals(children[1].width, 200, "Cell width should be 200")
@@ -167,7 +165,7 @@ function TestGridLayout:test_grid_overflow_children()
end
FlexLove.endFrame()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
-- First 4 children should be positioned
luaunit.assertNotNil(children[1].x, "Child 1 should be positioned")
@@ -199,7 +197,7 @@ function TestGridLayout:test_grid_align_center()
})
FlexLove.endFrame()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
-- Cell is 200x200, child is 100x100, should be centered
-- Center position: (200 - 100) / 2 = 50
@@ -231,7 +229,7 @@ function TestGridLayout:test_grid_align_flex_start()
})
FlexLove.endFrame()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
-- Child should be at top-left of cell
luaunit.assertEquals(child.x, 0, "Child should be at left of cell")
@@ -262,7 +260,7 @@ function TestGridLayout:test_grid_align_flex_end()
})
FlexLove.endFrame()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
-- Cell is 200x200, child is 100x100, should be at bottom-right
luaunit.assertEquals(child.x, 100, "Child should be at right of cell (200 - 100)")
@@ -293,7 +291,7 @@ function TestGridLayout:test_grid_with_padding()
})
FlexLove.endFrame()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
-- Available space: 500 - 50 - 50 = 400
-- Cell size: 400 / 2 = 200
@@ -345,7 +343,7 @@ function TestGridLayout:test_grid_with_absolute_child()
})
FlexLove.endFrame()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
-- child1 should be in first grid cell (0, 0)
luaunit.assertEquals(child1.x, 0, "Child 1 should be at x=0")
@@ -375,7 +373,7 @@ function TestGridLayout:test_empty_grid()
})
FlexLove.endFrame()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
-- Should not crash
luaunit.assertEquals(#container.children, 0, "Grid should have no children")
@@ -403,7 +401,7 @@ function TestGridLayout:test_grid_zero_dimensions()
-- This might cause division by zero or other errors
FlexLove.endFrame()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
-- Test passes if it doesn't crash
luaunit.assertTrue(true, "Grid with 0 dimensions should not crash")
@@ -444,7 +442,7 @@ function TestGridLayout:test_nested_grids()
end
FlexLove.endFrame()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
-- Inner grid should be positioned in first cell of outer grid
luaunit.assertEquals(innerGrid.x, 0, "Inner grid should be at x=0")
@@ -485,7 +483,7 @@ function TestGridLayout:test_grid_with_reserved_space()
})
FlexLove.endFrame()
FlexLove.beginFrame(1920, 1080)
FlexLove.beginFrame()
-- Grid should account for reserved space
-- Available width: 400 - 50 (reserved left) = 350

11
testing/__tests__/image_cache_test.lua
View File

@@ -1,6 +1,15 @@
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
local luaunit = require("testing.luaunit")
require("testing.loveStub")
local ImageCache = require("modules.ImageCache")
TestImageCache = {}

80
testing/__tests__/image_renderer_test.lua
View File

@@ -1,18 +1,21 @@
-- ImageRenderer Comprehensive Test Suite
-- Tests for ImageRenderer functionality including fit modes, positioning, tiling, and edge cases
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
local luaunit = require("testing.luaunit")
local ErrorHandler = require("modules.ErrorHandler")
-- Initialize ErrorHandler
ErrorHandler.init({})
require("testing.loveStub")
local ImageRenderer = require("modules.ImageRenderer")
local Color = require("modules.Color")
local utils = require("modules.utils")
-- Initialize ImageRenderer with dependencies
ImageRenderer.init({ ErrorHandler = ErrorHandler, utils = utils })
-- ============================================================================
@@ -512,72 +515,37 @@ end
TestImageRendererElementIntegration = {}
function TestImageRendererElementIntegration:setUp()
local Element = require("modules.Element")
local Units = require("modules.Units")
local LayoutEngine = require("modules.LayoutEngine")
local Renderer = require("modules.Renderer")
local EventHandler = require("modules.EventHandler")
local ImageCache = require("modules.ImageCache")
local Context = require("modules.Context")
local StateManager = require("modules.StateManager")
local InputEvent = require("modules.InputEvent")
local Theme = require("modules.Theme")
local TextEditor = require("modules.TextEditor")
local ScrollManager = require("modules.ScrollManager")
local RoundedRect = require("modules.RoundedRect")
self.deps = {
utils = utils,
Color = Color,
Units = Units,
LayoutEngine = LayoutEngine,
Renderer = Renderer,
EventHandler = EventHandler,
ImageCache = ImageCache,
ImageRenderer = ImageRenderer,
ErrorHandler = ErrorHandler,
Context = Context,
StateManager = StateManager,
InputEvent = InputEvent,
Theme = Theme,
TextEditor = TextEditor,
ScrollManager = ScrollManager,
RoundedRect = RoundedRect,
}
-- Initialize Element with dependencies
Element.init(self.deps)
self.Element = Element
self.Flexlove = require("FlexLove")
self.Flexlove.init({})
end
function TestImageRendererElementIntegration:testElementImageRepeatProperty()
-- Test that Element accepts imageRepeat property
local element = self.Element.new({
local element = self.Flexlove.new({
width = 200,
height = 200,
imageRepeat = "repeat",
}, self.deps)
})
luaunit.assertEquals(element.imageRepeat, "repeat")
end
function TestImageRendererElementIntegration:testElementImageRepeatDefault()
-- Test that imageRepeat defaults to "no-repeat"
local element = self.Element.new({
local element = self.Flexlove.new({
width = 200,
height = 200,
}, self.deps)
})
luaunit.assertEquals(element.imageRepeat, "no-repeat")
end
function TestImageRendererElementIntegration:testElementSetImageRepeat()
-- Test setImageRepeat method
local element = self.Element.new({
local element = self.Flexlove.new({
width = 200,
height = 200,
}, self.deps)
})
element:setImageRepeat("repeat-x")
luaunit.assertEquals(element.imageRepeat, "repeat-x")
@@ -587,21 +555,21 @@ function TestImageRendererElementIntegration:testElementImageTintProperty()
-- Test that Element accepts imageTint property
local redTint = Color.new(1, 0, 0, 1)
local element = self.Element.new({
local element = self.Flexlove.new({
width = 200,
height = 200,
imageTint = redTint,
}, self.deps)
})
luaunit.assertEquals(element.imageTint, redTint)
end
function TestImageRendererElementIntegration:testElementSetImageTint()
-- Test setImageTint method
local element = self.Element.new({
local element = self.Flexlove.new({
width = 200,
height = 200,
}, self.deps)
})
local blueTint = Color.new(0, 0, 1, 1)
element:setImageTint(blueTint)
@@ -610,10 +578,10 @@ end
function TestImageRendererElementIntegration:testElementSetImageOpacity()
-- Test setImageOpacity method
local element = self.Element.new({
local element = self.Flexlove.new({
width = 200,
height = 200,
}, self.deps)
})
element:setImageOpacity(0.7)
luaunit.assertEquals(element.imageOpacity, 0.7)

13
testing/__tests__/image_scaler_test.lua
View File

@@ -1,13 +1,22 @@
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
local luaunit = require("testing.luaunit")
local ErrorHandler = require("modules.ErrorHandler")
-- Initialize ErrorHandler
ErrorHandler.init({})
require("testing.loveStub")
local ImageScaler = require("modules.ImageScaler")
-- Initialize ImageScaler with ErrorHandler
ImageScaler.init({ ErrorHandler = ErrorHandler })
TestImageScaler = {}

28
testing/__tests__/layout_engine_test.lua
View File

@@ -1,10 +1,14 @@
-- Comprehensive test suite for LayoutEngine.lua module
-- Consolidated from layout_engine_test.lua, layout_edge_cases_test.lua,
-- overflow_test.lua, and transform_test.lua
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
-- Load love stub before anything else
require("testing.loveStub")
local luaunit = require("testing.luaunit")
@@ -13,16 +17,6 @@ local Units = require("modules.Units")
local utils = require("modules.utils")
local ErrorHandler = require("modules.ErrorHandler")
local Animation = require("modules.Animation")
-- Setup package loader to map FlexLove.modules.X to modules/X
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function() return require("modules." .. moduleName) end
end
end)
local FlexLove = require("FlexLove")
local Transform = Animation.Transform
@@ -695,6 +689,7 @@ end
TestLayoutEdgeCases = {}
function TestLayoutEdgeCases:setUp()
FlexLove.init()
FlexLove.setMode("immediate")
FlexLove.beginFrame()
-- Capture warnings
@@ -1067,7 +1062,8 @@ end
TestOverflowDetection = {}
function TestOverflowDetection:setUp()
FlexLove.beginFrame(1920, 1080)
FlexLove.init()
FlexLove.beginFrame()
end
function TestOverflowDetection:tearDown()

11
testing/__tests__/mixed_mode_children_test.lua
View File

@@ -1,9 +1,16 @@
-- Test retained children persisting when immediate parents recreate
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
-- Load love stub before anything else
require("testing.loveStub")
local luaunit = require("testing.luaunit")
local FlexLove = require("FlexLove")

13
testing/__tests__/mixed_mode_events_test.lua
View File

@@ -1,10 +1,15 @@
-- Test event handling for immediate children of retained parents
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
-- Load love stub before anything else
require("testing.loveStub")
local luaunit = require("testing.luaunit")
local ErrorHandler = require("modules.ErrorHandler")

76
testing/__tests__/module_loader_test.lua
View File

@@ -1,8 +1,16 @@
local lu = require("testing.luaunit")
local loveStub = require("testing.loveStub")
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
-- Set up love stub globally
_G.love = loveStub
local luaunit = require("testing.luaunit")
require("testing.loveStub")
-- Load modules
local function req(name)
@@ -37,24 +45,24 @@ function TestModuleLoader:test_safeRequire_loads_existing_module()
-- Test loading an existing required module
local utils = ModuleLoader.safeRequire(modulePath .. "modules.utils", false)
lu.assertNotNil(utils)
lu.assertIsTable(utils)
lu.assertIsNil(utils._isStub)
luaunit.assertNotNil(utils)
luaunit.assertIsTable(utils)
luaunit.assertIsNil(utils._isStub)
end
function TestModuleLoader:test_safeRequire_returns_stub_for_missing_optional_module()
-- Test loading a non-existent optional module
local fakeModule = ModuleLoader.safeRequire(modulePath .. "modules.NonExistentModule", true)
lu.assertNotNil(fakeModule)
lu.assertIsTable(fakeModule)
lu.assertTrue(fakeModule._isStub)
lu.assertEquals(fakeModule._moduleName, modulePath .. "modules.NonExistentModule")
luaunit.assertNotNil(fakeModule)
luaunit.assertIsTable(fakeModule)
luaunit.assertTrue(fakeModule._isStub)
luaunit.assertEquals(fakeModule._moduleName, modulePath .. "modules.NonExistentModule")
end
function TestModuleLoader:test_safeRequire_throws_error_for_missing_required_module()
-- Test loading a non-existent required module should throw error
lu.assertErrorMsgContains("Required module", function()
luaunit.assertErrorMsgContains("Required module", function()
ModuleLoader.safeRequire(modulePath .. "modules.NonExistentModule", false)
end)
end
@@ -62,23 +70,23 @@ end
function TestModuleLoader:test_stub_has_safe_init_method()
local stub = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
lu.assertIsFunction(stub.init)
luaunit.assertIsFunction(stub.init)
local result = stub.init()
lu.assertEquals(result, stub)
luaunit.assertEquals(result, stub)
end
function TestModuleLoader:test_stub_has_safe_new_method()
local stub = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
lu.assertIsFunction(stub.new)
luaunit.assertIsFunction(stub.new)
local result = stub.new()
lu.assertEquals(result, stub)
luaunit.assertEquals(result, stub)
end
function TestModuleLoader:test_stub_has_safe_draw_method()
local stub = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
lu.assertIsFunction(stub.draw)
luaunit.assertIsFunction(stub.draw)
-- Should not throw error
stub.draw()
end
@@ -86,7 +94,7 @@ end
function TestModuleLoader:test_stub_has_safe_update_method()
local stub = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
lu.assertIsFunction(stub.update)
luaunit.assertIsFunction(stub.update)
-- Should not throw error
stub.update()
end
@@ -94,7 +102,7 @@ end
function TestModuleLoader:test_stub_has_safe_clear_method()
local stub = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
lu.assertIsFunction(stub.clear)
luaunit.assertIsFunction(stub.clear)
-- Should not throw error
stub.clear()
end
@@ -102,17 +110,17 @@ end
function TestModuleLoader:test_stub_has_safe_clearCache_method()
local stub = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
lu.assertIsFunction(stub.clearCache)
luaunit.assertIsFunction(stub.clearCache)
local result = stub.clearCache()
lu.assertIsTable(result)
luaunit.assertIsTable(result)
end
function TestModuleLoader:test_stub_returns_function_for_unknown_properties()
local stub = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
-- Unknown properties should return no-op functions for safe method calls
lu.assertIsFunction(stub.unknownProperty)
lu.assertIsFunction(stub.anotherUnknownProperty)
luaunit.assertIsFunction(stub.unknownProperty)
luaunit.assertIsFunction(stub.anotherUnknownProperty)
-- Calling unknown methods should not error
stub:unknownMethod()
@@ -123,23 +131,23 @@ function TestModuleLoader:test_stub_callable_returns_itself()
local stub = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
local result = stub()
lu.assertEquals(result, stub)
luaunit.assertEquals(result, stub)
end
function TestModuleLoader:test_isModuleLoaded_returns_true_for_loaded_module()
ModuleLoader.safeRequire(modulePath .. "modules.utils", false)
lu.assertTrue(ModuleLoader.isModuleLoaded(modulePath .. "modules.utils"))
luaunit.assertTrue(ModuleLoader.isModuleLoaded(modulePath .. "modules.utils"))
end
function TestModuleLoader:test_isModuleLoaded_returns_false_for_stub_module()
ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
lu.assertFalse(ModuleLoader.isModuleLoaded(modulePath .. "modules.FakeModule"))
luaunit.assertFalse(ModuleLoader.isModuleLoaded(modulePath .. "modules.FakeModule"))
end
function TestModuleLoader:test_isModuleLoaded_returns_false_for_unloaded_module()
lu.assertFalse(ModuleLoader.isModuleLoaded(modulePath .. "modules.NeverLoaded"))
luaunit.assertFalse(ModuleLoader.isModuleLoaded(modulePath .. "modules.NeverLoaded"))
end
function TestModuleLoader:test_getLoadedModules_returns_only_real_modules()
@@ -149,7 +157,7 @@ function TestModuleLoader:test_getLoadedModules_returns_only_real_modules()
local loaded = ModuleLoader.getLoadedModules()
lu.assertIsTable(loaded)
luaunit.assertIsTable(loaded)
-- Should only contain utils (real module)
local hasUtils = false
for _, path in ipairs(loaded) do
@@ -157,7 +165,7 @@ function TestModuleLoader:test_getLoadedModules_returns_only_real_modules()
hasUtils = true
end
end
lu.assertTrue(hasUtils)
luaunit.assertTrue(hasUtils)
end
function TestModuleLoader:test_getStubModules_returns_only_stubs()
@@ -167,9 +175,9 @@ function TestModuleLoader:test_getStubModules_returns_only_stubs()
local stubs = ModuleLoader.getStubModules()
lu.assertIsTable(stubs)
luaunit.assertIsTable(stubs)
-- Should contain 2 stubs
lu.assertEquals(#stubs, 2)
luaunit.assertEquals(#stubs, 2)
end
function TestModuleLoader:test_safeRequire_caches_modules()
@@ -178,7 +186,7 @@ function TestModuleLoader:test_safeRequire_caches_modules()
local module2 = ModuleLoader.safeRequire(modulePath .. "modules.utils", false)
-- Should return same instance
lu.assertEquals(module1, module2)
luaunit.assertEquals(module1, module2)
end
function TestModuleLoader:test_safeRequire_caches_stubs()
@@ -187,10 +195,10 @@ function TestModuleLoader:test_safeRequire_caches_stubs()
local stub2 = ModuleLoader.safeRequire(modulePath .. "modules.FakeModule", true)
-- Should return same instance
lu.assertEquals(stub1, stub2)
luaunit.assertEquals(stub1, stub2)
end
-- Run tests if executed directly
if not _G.RUNNING_ALL_TESTS then
os.exit(lu.LuaUnit.run())
os.exit(luaunit.LuaUnit.run())
end

12
testing/__tests__/ninepatch_test.lua
View File

@@ -1,6 +1,16 @@
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
local luaunit = require("testing.luaunit")
require("testing.loveStub")
local NinePatch = require("modules.NinePatch")
-- =============================================================================

18
testing/__tests__/performance_test.lua
View File

@@ -1,26 +1,20 @@
-- Test Performance Module (Consolidated)
package.path = package.path .. ";./?.lua;./modules/?.lua"
local luaunit = require("testing.luaunit")
local loveStub = require("testing.loveStub")
-- Set up stub before requiring modules
_G.love = loveStub
-- Setup package loader to map FlexLove.modules.X to modules/X
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function() return require("modules." .. moduleName) end
return function()
return require("modules." .. moduleName)
end
end
end)
local luaunit = require("testing.luaunit")
require("testing.loveStub")
local FlexLove = require("FlexLove")
local Performance = require("modules.Performance")
local Element = require('modules.Element')
local Element = require("modules.Element")
-- Initialize FlexLove to ensure all modules are properly set up
FlexLove.init()
-- ============================================================================

34
testing/__tests__/renderer_test.lua
View File

@@ -1,3 +1,14 @@
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
local luaunit = require("testing.luaunit")
require("testing.loveStub")
@@ -10,23 +21,8 @@ local ImageCache = require("modules.ImageCache")
local Theme = require("modules.Theme")
local Blur = require("modules.Blur")
local utils = require("modules.utils")
local ErrorHandler = require("modules.ErrorHandler")
-- Setup package loader to map FlexLove.modules.X to modules/X
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function() return require("modules." .. moduleName) end
end
end)
local FlexLove = require("FlexLove")
-- Initialize ErrorHandler
ErrorHandler.init({})
-- Initialize FlexLove
FlexLove.init()
-- ============================================================================
@@ -502,7 +498,6 @@ function TestRendererMethods:testGetFont()
local renderer = Renderer.new({}, createDeps())
local mockElement = createMockElement()
mockElement.fontSize = 16
local font = renderer:getFont(mockElement)
luaunit.assertNotNil(font)
@@ -520,7 +515,6 @@ function TestRendererDrawing:testDrawBasic()
}, createDeps())
local mockElement = createMockElement()
-- Should not error when drawing
renderer:draw(mockElement)
@@ -530,7 +524,6 @@ end
function TestRendererDrawing:testDrawWithNilBackdrop()
local renderer = Renderer.new({}, createDeps())
local mockElement = createMockElement()
renderer:draw(mockElement, nil)
luaunit.assertTrue(true)
@@ -539,7 +532,6 @@ end
function TestRendererDrawing:testDrawPressedState()
local renderer = Renderer.new({}, createDeps())
local mockElement = createMockElement()
-- Should not error
renderer:drawPressedState(0, 0, 100, 100)
@@ -553,7 +545,6 @@ function TestRendererDrawing:testDrawScrollbars()
mockElement.scrollbarWidth = 8
mockElement.scrollbarPadding = 2
mockElement.scrollbarColor = Color.new(0.5, 0.5, 0.5, 1)
local dims = {
scrollX = 0,
@@ -589,7 +580,6 @@ function TestRendererText:testDrawText()
mockElement.text = "Hello World"
mockElement.fontSize = 14
mockElement.textAlign = "left"
-- Should not error
renderer:drawText(mockElement)
@@ -600,7 +590,6 @@ function TestRendererText:testDrawTextWithNilText()
local renderer = Renderer.new({}, createDeps())
local mockElement = createMockElement()
mockElement.text = nil
-- Should handle nil text gracefully
renderer:drawText(mockElement)
@@ -611,7 +600,6 @@ function TestRendererText:testDrawTextWithEmptyString()
local renderer = Renderer.new({}, createDeps())
local mockElement = createMockElement()
mockElement.text = ""
renderer:drawText(mockElement)
luaunit.assertTrue(true)

18
testing/__tests__/retained_in_immediate_test.lua
View File

@@ -1,11 +1,13 @@
--[[
Test: Retained Elements in Immediate Mode (No Duplication)
This test verifies that retained-mode elements don't get recreated
when the overall application is in immediate mode.
]]
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
require("testing.loveStub")
@@ -21,7 +23,7 @@ function TestRetainedInImmediateMode:setUp()
end
function TestRetainedInImmediateMode:tearDown()
if FlexLove.getMode() == "immediate" then
if FlexLove.getMode() == "immediate" and FlexLove._frameStarted then
FlexLove.endFrame()
end
FlexLove.init({ immediateMode = false })

18
testing/__tests__/retained_prop_stability_test.lua
View File

@@ -1,14 +1,14 @@
--[[
Test: Retained Elements with Varying Props (ID Stability)
This test verifies that retained-mode elements return the same instance
across frames even when props vary slightly (e.g., different Color instances).
]]
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
require("testing.loveStub")
local luaunit = require("testing.luaunit")
local FlexLove = require("FlexLove")
local Color = require("modules.Color")

1
testing/__tests__/roundedrect_test.lua
View File

@@ -1,3 +1,4 @@
package.path = package.path .. ";./?.lua;./modules/?.lua"
local luaunit = require("testing.luaunit")
require("testing.loveStub")

1
testing/__tests__/scroll_manager_test.lua
View File

@@ -1,4 +1,3 @@
-- Edge case and unhappy path tests for ScrollManager module
package.path = package.path .. ";./?.lua;./modules/?.lua"
require("testing.loveStub")

16
testing/__tests__/theme_test.lua
View File

@@ -1,9 +1,13 @@
-- Test suite for Theme.lua core functionality
-- Tests theme creation, registration, and retrieval functions
package.path = package.path .. ";./?.lua;./modules/?.lua"
-- Load love stub before anything else
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
require("testing.loveStub")
local luaunit = require("testing.luaunit")
@@ -11,8 +15,6 @@ local Theme = require("modules.Theme")
local Color = require("modules.Color")
local ErrorHandler = require("modules.ErrorHandler")
local utils = require("modules.utils")
-- Initialize ErrorHandler and Theme module
ErrorHandler.init({})
Theme.init({ ErrorHandler = ErrorHandler, Color = Color, utils = utils })

73
testing/__tests__/touch_events_test.lua
View File

@@ -1,8 +1,15 @@
package.path = package.path .. ";./?.lua;./modules/?.lua"
local originalSearchers = package.searchers or package.loaders
table.insert(originalSearchers, 2, function(modname)
if modname:match("^FlexLove%.modules%.") then
local moduleName = modname:gsub("^FlexLove%.modules%.", "")
return function()
return require("modules." .. moduleName)
end
end
end)
require("testing.loveStub")
local lu = require("testing.luaunit")
local ErrorHandler = require("modules.ErrorHandler") -- Load FlexLove
local luaunit = require("testing.luaunit")
local FlexLove = require("FlexLove")
-- Initialize FlexLove to ensure all modules are properly set up
@@ -17,13 +24,13 @@ function TestTouchEvents:testInputEvent_FromTouch()
local touchId = "touch1"
local event = InputEvent.fromTouch(touchId, 100, 200, "began", 0.8)
lu.assertEquals(event.type, "touchpress")
lu.assertEquals(event.x, 100)
lu.assertEquals(event.y, 200)
lu.assertEquals(event.touchId, "touch1")
lu.assertEquals(event.pressure, 0.8)
lu.assertEquals(event.phase, "began")
lu.assertEquals(event.button, 1) -- Treat as left button
luaunit.assertEquals(event.type, "touchpress")
luaunit.assertEquals(event.x, 100)
luaunit.assertEquals(event.y, 200)
luaunit.assertEquals(event.touchId, "touch1")
luaunit.assertEquals(event.pressure, 0.8)
luaunit.assertEquals(event.phase, "began")
luaunit.assertEquals(event.button, 1) -- Treat as left button
end
-- Test: Touch event with moved phase
@@ -32,8 +39,8 @@ function TestTouchEvents:testInputEvent_FromTouch_Moved()
local event = InputEvent.fromTouch("touch1", 150, 250, "moved", 1.0)
lu.assertEquals(event.type, "touchmove")
lu.assertEquals(event.phase, "moved")
luaunit.assertEquals(event.type, "touchmove")
luaunit.assertEquals(event.phase, "moved")
end
-- Test: Touch event with ended phase
@@ -42,8 +49,8 @@ function TestTouchEvents:testInputEvent_FromTouch_Ended()
local event = InputEvent.fromTouch("touch1", 150, 250, "ended", 1.0)
lu.assertEquals(event.type, "touchrelease")
lu.assertEquals(event.phase, "ended")
luaunit.assertEquals(event.type, "touchrelease")
luaunit.assertEquals(event.phase, "ended")
end
-- Test: Touch event with cancelled phase
@@ -52,8 +59,8 @@ function TestTouchEvents:testInputEvent_FromTouch_Cancelled()
local event = InputEvent.fromTouch("touch1", 150, 250, "cancelled", 1.0)
lu.assertEquals(event.type, "touchcancel")
lu.assertEquals(event.phase, "cancelled")
luaunit.assertEquals(event.type, "touchcancel")
luaunit.assertEquals(event.phase, "cancelled")
end
-- Test: EventHandler tracks touch began
@@ -97,9 +104,9 @@ function TestTouchEvents:testEventHandler_TouchBegan()
-- Should have received at least one touchpress event
-- Note: May receive multiple events due to test state/frame processing
lu.assertTrue(#filteredEvents >= 1, "Should receive at least 1 touch event, got " .. #filteredEvents)
lu.assertEquals(filteredEvents[1].type, "touchpress")
lu.assertEquals(filteredEvents[1].touchId, "touch1")
luaunit.assertTrue(#filteredEvents >= 1, "Should receive at least 1 touch event, got " .. #filteredEvents)
luaunit.assertEquals(filteredEvents[1].type, "touchpress")
luaunit.assertEquals(filteredEvents[1].touchId, "touch1")
end
-- Test: EventHandler tracks touch moved
@@ -154,11 +161,11 @@ function TestTouchEvents:testEventHandler_TouchMoved()
end
-- Should have received touchpress and touchmove events
lu.assertEquals(#filteredEvents, 2)
lu.assertEquals(filteredEvents[1].type, "touchpress")
lu.assertEquals(filteredEvents[2].type, "touchmove")
lu.assertEquals(filteredEvents[2].dx, 50)
lu.assertEquals(filteredEvents[2].dy, 50)
luaunit.assertEquals(#filteredEvents, 2)
luaunit.assertEquals(filteredEvents[1].type, "touchpress")
luaunit.assertEquals(filteredEvents[2].type, "touchmove")
luaunit.assertEquals(filteredEvents[2].dx, 50)
luaunit.assertEquals(filteredEvents[2].dy, 50)
end
-- Test: EventHandler tracks touch ended
@@ -210,9 +217,9 @@ function TestTouchEvents:testEventHandler_TouchEnded()
end
-- Should have received touchpress and touchrelease events
lu.assertEquals(#filteredEvents, 2)
lu.assertEquals(filteredEvents[1].type, "touchpress")
lu.assertEquals(filteredEvents[2].type, "touchrelease")
luaunit.assertEquals(#filteredEvents, 2)
luaunit.assertEquals(filteredEvents[1].type, "touchpress")
luaunit.assertEquals(filteredEvents[2].type, "touchrelease")
end
-- Test: EventHandler tracks multiple simultaneous touches
@@ -257,12 +264,12 @@ function TestTouchEvents:testEventHandler_MultiTouch()
end
-- Should have received two touchpress events (one for each touch)
lu.assertEquals(#filteredEvents, 2)
lu.assertEquals(filteredEvents[1].type, "touchpress")
lu.assertEquals(filteredEvents[2].type, "touchpress")
luaunit.assertEquals(#filteredEvents, 2)
luaunit.assertEquals(filteredEvents[1].type, "touchpress")
luaunit.assertEquals(filteredEvents[2].type, "touchpress")
-- Different touch IDs
lu.assertNotEquals(touchEvents[1].touchId, touchEvents[2].touchId)
luaunit.assertNotEquals(touchEvents[1].touchId, touchEvents[2].touchId)
end
-- Test: GestureRecognizer detects tap
@@ -287,9 +294,9 @@ function TestTouchEvents:testGestureRecognizer_Tap()
-- Note: The gesture detection returns from internal methods,
-- needs to be captured from the event processing
-- This is a basic structural test
lu.assertNotNil(recognizer)
luaunit.assertNotNil(recognizer)
end
if not _G.RUNNING_ALL_TESTS then
os.exit(lu.LuaUnit.run())
os.exit(luaunit.LuaUnit.run())
end