336 lines
14 KiB
Lua
336 lines
14 KiB
Lua
expose("module", function()
|
|
require("kiwi")
|
|
end)
|
|
|
|
describe("solver", function()
|
|
local kiwi = require("kiwi")
|
|
---@type kiwi.Solver
|
|
local solver
|
|
|
|
before_each(function()
|
|
solver = kiwi.Solver()
|
|
end)
|
|
|
|
it("should create a solver", function()
|
|
assert.True(kiwi.is_solver(solver))
|
|
assert.False(kiwi.is_solver(kiwi.Term(kiwi.Var("v1"))))
|
|
end)
|
|
|
|
describe("edit variables", function()
|
|
local v1, v2, v3
|
|
before_each(function()
|
|
v1 = kiwi.Var("foo")
|
|
v2 = kiwi.Var("bar")
|
|
v3 = kiwi.Var("baz")
|
|
end)
|
|
|
|
describe("add_edit_var", function()
|
|
it("should add a variable", function()
|
|
solver:add_edit_var(v1, kiwi.strength.STRONG)
|
|
assert.True(solver:has_edit_var(v1))
|
|
end)
|
|
|
|
it("should return the argument", function()
|
|
assert.equal(v1, solver:add_edit_var(v1, kiwi.strength.STRONG))
|
|
end)
|
|
|
|
it("should error on incorrect type", function()
|
|
assert.error(function()
|
|
solver:add_edit_var("", kiwi.strength.STRONG) ---@diagnostic disable-line: param-type-mismatch
|
|
end)
|
|
assert.error(function()
|
|
solver:add_edit_var(v1, "") ---@diagnostic disable-line: param-type-mismatch
|
|
end)
|
|
end)
|
|
|
|
it("should require a strength argument", function()
|
|
assert.error(function()
|
|
solver:add_edit_var(v1) ---@diagnostic disable-line: missing-parameter
|
|
end)
|
|
end)
|
|
|
|
it("should error on duplicate variable", function()
|
|
solver:add_edit_var(v1, kiwi.strength.STRONG)
|
|
local _, err = pcall(function()
|
|
return solver:add_edit_var(v1, kiwi.strength.STRONG)
|
|
end)
|
|
assert.True(kiwi.is_error(err))
|
|
assert.True(kiwi.is_solver(err.solver))
|
|
assert.equal(v1, err.item)
|
|
assert.equal("KiwiErrDuplicateEditVariable", err.kind)
|
|
assert.equal("The edit variable has already been added to the solver.", err.message)
|
|
end)
|
|
|
|
it("should error on invalid strength", function()
|
|
local _, err = pcall(function()
|
|
return solver:add_edit_var(v1, kiwi.strength.REQUIRED)
|
|
end)
|
|
assert.True(kiwi.is_error(err))
|
|
assert.True(kiwi.is_solver(err.solver))
|
|
assert.equal(v1, err.item)
|
|
assert.equal("KiwiErrBadRequiredStrength", err.kind)
|
|
assert.equal("A required strength cannot be used in this context.", err.message)
|
|
end)
|
|
|
|
it("should return errors for duplicate variables", function()
|
|
solver:set_error_mask({ "KiwiErrDuplicateEditVariable", "KiwiErrBadRequiredStrength" })
|
|
local ret, err = solver:add_edit_var(v1, kiwi.strength.STRONG)
|
|
assert.Nil(err)
|
|
|
|
ret, err = solver:add_edit_var(v1, kiwi.strength.STRONG)
|
|
|
|
assert.equal(v1, ret)
|
|
assert.True(kiwi.is_error(err))
|
|
---@diagnostic disable: need-check-nil
|
|
assert.True(kiwi.is_solver(err.solver))
|
|
assert.equal(v1, err.item)
|
|
assert.equal("KiwiErrDuplicateEditVariable", err.kind)
|
|
assert.equal("The edit variable has already been added to the solver.", err.message)
|
|
---@diagnostic enable: need-check-nil
|
|
end)
|
|
|
|
it("should return errors for invalid strength", function()
|
|
solver:set_error_mask({ "KiwiErrDuplicateEditVariable", "KiwiErrBadRequiredStrength" })
|
|
|
|
---@diagnostic disable: need-check-nil
|
|
local ret, err = solver:add_edit_var(v2, kiwi.strength.REQUIRED)
|
|
assert.equal(v2, ret)
|
|
assert.True(kiwi.is_error(err))
|
|
assert.True(kiwi.is_solver(err.solver))
|
|
assert.equal(v2, err.item)
|
|
assert.equal("KiwiErrBadRequiredStrength", err.kind)
|
|
assert.equal("A required strength cannot be used in this context.", err.message)
|
|
---@diagnostic enable: need-check-nil
|
|
end)
|
|
|
|
it("tolerates a nil self", function()
|
|
assert.error(function()
|
|
kiwi.Solver.add_edit_var(nil, v1, kiwi.strength.STRONG) ---@diagnostic disable-line: param-type-mismatch
|
|
end)
|
|
end)
|
|
|
|
it("tolerates a nil var", function()
|
|
assert.error(function()
|
|
solver:add_edit_var(nil, kiwi.strength.STRONG) ---@diagnostic disable-line: param-type-mismatch
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe("add_edit_vars", function()
|
|
it("should add variables", function()
|
|
solver:add_edit_vars({ v1, v2 }, kiwi.strength.STRONG)
|
|
assert.True(solver:has_edit_var(v1))
|
|
assert.True(solver:has_edit_var(v2))
|
|
assert.False(solver:has_edit_var(v3))
|
|
end)
|
|
|
|
it("should return the argument", function()
|
|
local arg = { v1, v2, v3 }
|
|
assert.equal(arg, solver:add_edit_vars(arg, kiwi.strength.STRONG))
|
|
end)
|
|
|
|
it("should error on incorrect type", function()
|
|
assert.error(function()
|
|
solver:add_edit_vars(v1, kiwi.strength.STRONG) ---@diagnostic disable-line: param-type-mismatch
|
|
end)
|
|
assert.error(function()
|
|
solver:add_edit_vars("", kiwi.strength.STRONG) ---@diagnostic disable-line: param-type-mismatch
|
|
end)
|
|
assert.error(function()
|
|
solver:add_edit_vars(v1, "") ---@diagnostic disable-line: param-type-mismatch
|
|
end)
|
|
end)
|
|
|
|
it("should require a strength argument", function()
|
|
assert.error(function()
|
|
solver:add_edit_vars({ v1, v2 }) ---@diagnostic disable-line: missing-parameter
|
|
end)
|
|
end)
|
|
|
|
it("should error on duplicate variable", function()
|
|
local _, err = pcall(function()
|
|
return solver:add_edit_vars({ v1, v2, v3, v2, v3 }, kiwi.strength.STRONG)
|
|
end)
|
|
assert.True(kiwi.is_error(err))
|
|
assert.True(kiwi.is_solver(err.solver))
|
|
assert.equal(v2, err.item)
|
|
assert.equal("KiwiErrDuplicateEditVariable", err.kind)
|
|
assert.equal("The edit variable has already been added to the solver.", err.message)
|
|
end)
|
|
|
|
it("should error on invalid strength", function()
|
|
local _, err = pcall(function()
|
|
return solver:add_edit_vars({ v1, v2 }, kiwi.strength.REQUIRED)
|
|
end)
|
|
assert.True(kiwi.is_error(err))
|
|
assert.True(kiwi.is_solver(err.solver))
|
|
assert.equal(v1, err.item)
|
|
assert.equal("KiwiErrBadRequiredStrength", err.kind)
|
|
assert.equal("A required strength cannot be used in this context.", err.message)
|
|
end)
|
|
|
|
it("should return errors for duplicate variables", function()
|
|
solver:set_error_mask({ "KiwiErrDuplicateEditVariable", "KiwiErrBadRequiredStrength" })
|
|
local ret, err = solver:add_edit_vars({ v1, v2, v3 }, kiwi.strength.STRONG)
|
|
assert.Nil(err)
|
|
|
|
local arg = { v1, v2, v3 }
|
|
ret, err = solver:add_edit_vars(arg, kiwi.strength.STRONG)
|
|
assert.equal(arg, ret)
|
|
assert.True(kiwi.is_error(err))
|
|
---@diagnostic disable: need-check-nil
|
|
assert.True(kiwi.is_solver(err.solver))
|
|
assert.equal(v1, err.item)
|
|
assert.equal("KiwiErrDuplicateEditVariable", err.kind)
|
|
assert.equal("The edit variable has already been added to the solver.", err.message)
|
|
---@diagnostic enable: need-check-nil
|
|
end)
|
|
|
|
it("should return errors for invalid strength", function()
|
|
solver:set_error_mask({ "KiwiErrDuplicateEditVariable", "KiwiErrBadRequiredStrength" })
|
|
arg = { v2, v3 }
|
|
local ret, err = solver:add_edit_vars(arg, kiwi.strength.REQUIRED)
|
|
assert.equal(arg, ret)
|
|
assert.True(kiwi.is_error(err))
|
|
---@diagnostic disable: need-check-nil
|
|
assert.True(kiwi.is_solver(err.solver))
|
|
assert.equal(v2, err.item)
|
|
assert.equal("KiwiErrBadRequiredStrength", err.kind)
|
|
assert.equal("A required strength cannot be used in this context.", err.message)
|
|
---@diagnostic enable: need-check-nil
|
|
end)
|
|
|
|
it("tolerates a nil self", function()
|
|
assert.has_error(function()
|
|
kiwi.Solver.add_edit_vars(nil, { v1, v2 }, kiwi.strength.STRONG) ---@diagnostic disable-line: param-type-mismatch
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe("remove_edit_var", function()
|
|
it("should remove a variable", function()
|
|
solver:add_edit_vars({ v1, v2, v3 }, kiwi.strength.STRONG)
|
|
assert.True(solver:has_edit_var(v2))
|
|
solver:remove_edit_var(v2)
|
|
assert.True(solver:has_edit_var(v1))
|
|
assert.False(solver:has_edit_var(v2))
|
|
assert.True(solver:has_edit_var(v3))
|
|
end)
|
|
|
|
it("should return the argument", function()
|
|
solver:add_edit_var(v1, kiwi.strength.STRONG)
|
|
assert.equal(v1, solver:remove_edit_var(v1))
|
|
end)
|
|
|
|
it("should error on incorrect type", function()
|
|
assert.error(function()
|
|
solver:remove_edit_var("") ---@diagnostic disable-line: param-type-mismatch
|
|
end)
|
|
assert.error(function()
|
|
solver:remove_edit_var({ v1 }) ---@diagnostic disable-line: param-type-mismatch
|
|
end)
|
|
end)
|
|
|
|
it("should error on unknown variable", function()
|
|
solver:add_edit_var(v1, kiwi.strength.STRONG)
|
|
local _, err = pcall(function()
|
|
return solver:remove_edit_var(v2)
|
|
end)
|
|
assert.True(kiwi.is_error(err))
|
|
assert.True(kiwi.is_solver(err.solver))
|
|
assert.equal(v2, err.item)
|
|
assert.equal("KiwiErrUnknownEditVariable", err.kind)
|
|
assert.equal("The edit variable has not been added to the solver.", err.message)
|
|
end)
|
|
|
|
it("should return errors if requested", function()
|
|
solver:set_error_mask({ "KiwiErrDuplicateEditVariable", "KiwiErrUnknownEditVariable" })
|
|
|
|
local ret, err = solver:remove_edit_var(v1)
|
|
|
|
assert.equal(v1, ret)
|
|
assert.True(kiwi.is_error(err))
|
|
---@diagnostic disable: need-check-nil
|
|
assert.True(kiwi.is_solver(err.solver))
|
|
assert.equal(v1, err.item)
|
|
assert.equal("KiwiErrUnknownEditVariable", err.kind)
|
|
assert.equal("The edit variable has not been added to the solver.", err.message)
|
|
---@diagnostic enable: need-check-nil
|
|
end)
|
|
|
|
it("tolerates a nil self", function()
|
|
assert.has_error(function()
|
|
kiwi.Solver.remove_edit_var(nil, v1) ---@diagnostic disable-line: param-type-mismatch
|
|
end)
|
|
end)
|
|
|
|
it("tolerates a nil var", function()
|
|
assert.has_error(function()
|
|
solver:remove_edit_var(nil) ---@diagnostic disable-line: param-type-mismatch
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe("remove_edit_vars", function()
|
|
it("should remove variables", function()
|
|
solver:add_edit_vars({ v1, v2, v3 }, kiwi.strength.STRONG)
|
|
assert.True(solver:has_edit_var(v2))
|
|
assert.True(solver:has_edit_var(v3))
|
|
|
|
solver:remove_edit_vars({ v2, v3 })
|
|
assert.False(solver:has_edit_var(v2))
|
|
assert.False(solver:has_edit_var(v3))
|
|
end)
|
|
|
|
it("should return the argument", function()
|
|
local arg = { v1, v2, v3 }
|
|
solver:add_edit_vars(arg, kiwi.strength.STRONG)
|
|
assert.equal(arg, solver:remove_edit_vars(arg))
|
|
end)
|
|
|
|
it("should error on incorrect type", function()
|
|
assert.error(function()
|
|
solver:remove_edit_vars(v1) ---@diagnostic disable-line: param-type-mismatch
|
|
end)
|
|
assert.error(function()
|
|
solver:remove_edit_vars("") ---@diagnostic disable-line: param-type-mismatch
|
|
end)
|
|
end)
|
|
|
|
it("should error on unknown variables", function()
|
|
local _, err = pcall(function()
|
|
return solver:remove_edit_vars({ v2, v1 })
|
|
end)
|
|
assert.True(kiwi.is_error(err))
|
|
assert.True(kiwi.is_solver(err.solver))
|
|
assert.equal(v2, err.item)
|
|
assert.equal("KiwiErrUnknownEditVariable", err.kind)
|
|
assert.equal("The edit variable has not been added to the solver.", err.message)
|
|
end)
|
|
|
|
it("should return errors for unknown variables", function()
|
|
solver:set_error_mask({ "KiwiErrDuplicateEditVariable", "KiwiErrUnknownEditVariable" })
|
|
local ret, err = solver:add_edit_vars({ v1, v2 }, kiwi.strength.STRONG)
|
|
assert.Nil(err)
|
|
|
|
local arg = { v1, v2, v3 }
|
|
ret, err = solver:remove_edit_vars(arg)
|
|
assert.equal(arg, ret)
|
|
assert.True(kiwi.is_error(err))
|
|
---@diagnostic disable: need-check-nil
|
|
assert.True(kiwi.is_solver(err.solver))
|
|
assert.equal(v3, err.item)
|
|
assert.equal("KiwiErrUnknownEditVariable", err.kind)
|
|
assert.equal("The edit variable has not been added to the solver.", err.message)
|
|
---@diagnostic enable: need-check-nil
|
|
end)
|
|
|
|
it("tolerates a nil self", function()
|
|
assert.has_error(function()
|
|
kiwi.Solver.remove_edit_vars(nil, { v1, v2 }) ---@diagnostic disable-line: param-type-mismatch
|
|
end)
|
|
end)
|
|
end)
|
|
end)
|
|
end)
|