calc module

testing/__tests__/calc_test.lua

@@ -0,0 +1,232 @@
+---@diagnostic disable: undefined-global, undefined-field
+local lu = require("testing.luaunit")
+
+-- 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
+local Calc = require("modules.Calc")
+local ErrorHandler = require("modules.ErrorHandler")
+
+-- Initialize with error handler
+ErrorHandler.init({})
+Calc.init({ ErrorHandler = ErrorHandler })
+
+---@class TestCalc
+TestCalc = {}
+
+function TestCalc:setUp()
+  -- Fresh initialization for each test
+end
+
+function TestCalc:tearDown()
+  -- Cleanup after each test
+end
+
+--- Test basic arithmetic: addition
+function TestCalc:testBasicAddition()
+  local calcObj = Calc.new("100px + 50px")
+  lu.assertTrue(Calc.isCalc(calcObj))
+  local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
+  lu.assertEquals(result, 150)
+end
+
+--- Test basic arithmetic: subtraction
+function TestCalc:testBasicSubtraction()
+  local calcObj = Calc.new("100px - 30px")
+  lu.assertTrue(Calc.isCalc(calcObj))
+  local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
+  lu.assertEquals(result, 70)
+end
+
+--- Test basic arithmetic: multiplication
+function TestCalc:testBasicMultiplication()
+  local calcObj = Calc.new("10px * 5")
+  lu.assertTrue(Calc.isCalc(calcObj))
+  local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
+  lu.assertEquals(result, 50)
+end
+
+--- Test basic arithmetic: division
+function TestCalc:testBasicDivision()
+  local calcObj = Calc.new("100px / 4")
+  lu.assertTrue(Calc.isCalc(calcObj))
+  local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
+  lu.assertEquals(result, 25)
+end
+
+--- Test negative numbers
+function TestCalc:testNegativeNumbers()
+  local calcObj = Calc.new("-50px + 100px")
+  lu.assertTrue(Calc.isCalc(calcObj))
+  local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
+  lu.assertEquals(result, 50)
+end
+
+--- Test decimal numbers
+function TestCalc:testDecimalNumbers()
+  local calcObj = Calc.new("10.5px + 5.5px")
+  lu.assertTrue(Calc.isCalc(calcObj))
+  local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
+  lu.assertEquals(result, 16)
+end
+
+--- Test percentage units
+function TestCalc:testPercentageUnits()
+  local calcObj = Calc.new("50% + 25%")
+  lu.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
+end
+
+--- Test viewport width units (vw)
+function TestCalc:testViewportWidthUnits()
+  local calcObj = Calc.new("50vw - 10vw")
+  lu.assertTrue(Calc.isCalc(calcObj))
+  local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
+  lu.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))
+  local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
+  lu.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))
+  local result = Calc.resolve(calcObj, 1920, 1080, 1000, nil, nil)
+  lu.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))
+  local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
+  lu.assertEquals(result, 130)
+end
+
+--- Test parentheses for precedence
+function TestCalc:testParentheses()
+  local calcObj = Calc.new("(100px + 50px) * 2")
+  lu.assertTrue(Calc.isCalc(calcObj))
+  local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
+  lu.assertEquals(result, 300)
+end
+
+--- Test nested parentheses
+function TestCalc:testNestedParentheses()
+  local calcObj = Calc.new("((100px + 50px) / 3) * 2")
+  lu.assertTrue(Calc.isCalc(calcObj))
+  local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
+  lu.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))
+  local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
+  lu.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))
+  -- 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
+end
+
+--- Test element width units (ew)
+function TestCalc:testElementWidthUnits()
+  local calcObj = Calc.new("100ew - 20ew")
+  lu.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
+end
+
+--- Test element height units (eh)
+function TestCalc:testElementHeightUnits()
+  local calcObj = Calc.new("50eh + 25eh")
+  lu.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
+end
+
+--- Test whitespace handling
+function TestCalc:testWhitespaceHandling()
+  local calcObj = Calc.new("  100px  +  50px  ")
+  lu.assertTrue(Calc.isCalc(calcObj))
+  local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
+  lu.assertEquals(result, 150)
+end
+
+--- Test zero value
+function TestCalc:testZeroValue()
+  local calcObj = Calc.new("100px - 100px")
+  lu.assertTrue(Calc.isCalc(calcObj))
+  local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
+  lu.assertEquals(result, 0)
+end
+
+--- Test single value (no operation)
+function TestCalc:testSingleValue()
+  local calcObj = Calc.new("100px")
+  lu.assertTrue(Calc.isCalc(calcObj))
+  local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
+  lu.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({}))
+end
+
+--- Test division by zero error handling
+function TestCalc:testDivisionByZeroHandling()
+  local calcObj = Calc.new("100px / 0")
+  lu.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
+end
+
+--- Test invalid expression error handling
+function TestCalc:testInvalidExpressionHandling()
+  local calcObj = Calc.new("100px +") -- Incomplete expression
+  lu.assertTrue(Calc.isCalc(calcObj))
+  -- Should return 0 for invalid expressions
+  local result = Calc.resolve(calcObj, 1920, 1080, nil, nil, nil)
+  lu.assertEquals(result, 0)
+end
+
+--- Test complex real-world centering scenario
+function TestCalc:testRealWorldCentering()
+  -- Button with 20vw width, centered at 50% - 10vw
+  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)
+end
+
+if not _G.RUNNING_ALL_TESTS then
+  os.exit(lu.LuaUnit.run())
+end