256 lines
6.9 KiB
Lua
256 lines
6.9 KiB
Lua
local bright = string.char(27).."[1m"
|
|
local dim = string.char(27).."[2m"
|
|
local underscore = string.char(27).."[4m"
|
|
local red = string.char(27).."[31m"
|
|
local green = string.char(27).."[32m"
|
|
local reset = string.char(27).."[0m"
|
|
print(bright..underscore.."\nTesting with ".._VERSION..":"..reset)
|
|
repr = function(t)
|
|
local buff = tostring(t)
|
|
if type(t) == 'table' then
|
|
buff = "{"..buff.." "
|
|
for k, v in pairs(t) do
|
|
buff = buff..("%s = %s, "):format(k,v)
|
|
end
|
|
buff = buff.."}"
|
|
end
|
|
return buff
|
|
end
|
|
|
|
local num_errors = 0
|
|
local test_number = 0
|
|
local function test(description, fn)
|
|
test_number = test_number + 1
|
|
description = (bright.."% 3d. "..reset.."%s"):format(test_number, description)
|
|
io.write(description)
|
|
io.write(red)
|
|
local ok, err = pcall(fn)
|
|
if not ok then
|
|
io.write(reset..dim.."\r....................................")
|
|
io.write(reset.."["..bright..red.."FAILED"..reset.."]\r")
|
|
io.write("\r"..description.."\n"..reset)
|
|
print(reset..red..(err or "")..reset)
|
|
num_errors = num_errors + 1
|
|
else
|
|
io.write(reset..dim.."\r....................................")
|
|
io.write(reset.."["..green.."PASSED"..reset.."]\r")
|
|
io.write(description.."\n")
|
|
end
|
|
end
|
|
|
|
test("Loading module", function()
|
|
immutable = require"immutable"
|
|
end)
|
|
|
|
test("Creating class", function()
|
|
Vec = immutable({"x","y"}, {
|
|
len2=function(self)
|
|
return self.x*self.x + self.y*self.y
|
|
end,
|
|
__add=function(self, other)
|
|
local cls = getmetatable(self)
|
|
return cls(self.x+other.x, self.y+other.y)
|
|
end,
|
|
__tostring=function(self)
|
|
return "Vec("..tostring(self.x)..", "..tostring(self.y)..")"
|
|
end,
|
|
})
|
|
end)
|
|
|
|
test("Instantiating class", function()
|
|
v = assert(Vec(1,3))
|
|
end)
|
|
|
|
test("Testing indexing", function()
|
|
assert(v.x == 1)
|
|
end)
|
|
|
|
test("Testing # operator", function()
|
|
assert(#v == 2)
|
|
end)
|
|
|
|
test("Testing method", function()
|
|
assert(v:len2() == 10)
|
|
end)
|
|
|
|
test("Testing tostring", function()
|
|
assert(tostring(v) == "Vec(1, 3)")
|
|
end)
|
|
|
|
test("Testing from_table", function()
|
|
assert(Vec:from_table(setmetatable({y=3}, {__index={x=1}})) == v)
|
|
assert(Vec:from_table({x=1}) == Vec(1, nil))
|
|
end)
|
|
|
|
test("Testing equality", function()
|
|
also_v = Vec(1,3)
|
|
assert(v == also_v)
|
|
assert(tostring(v) == tostring(also_v))
|
|
-- Hash collision in the current implementation
|
|
not_v = Vec(true,3)
|
|
assert(v ~= not_v)
|
|
assert(tostring(not_v) == "Vec(true, 3)")
|
|
also_not_v = Vec(true,3)
|
|
assert(not_v == also_not_v)
|
|
end)
|
|
|
|
test("Testing singletons", function()
|
|
local T1 = immutable()
|
|
local T2 = immutable()
|
|
assert(T1() == T1())
|
|
assert(T1() ~= T2())
|
|
end)
|
|
|
|
test("Testing extra args", function()
|
|
assert(not pcall(function() Vec(1,2,3) end))
|
|
end)
|
|
|
|
test("Testing __add metamethod", function()
|
|
assert(v + Vec(5,6) == Vec(6,9))
|
|
end)
|
|
collectgarbage()
|
|
test("Testing string members", function()
|
|
Vec("hello", "world")
|
|
end)
|
|
test("Testing table members", function()
|
|
Vec({}, {})
|
|
end)
|
|
test("Testing function members", function()
|
|
Vec(function() end, function() end)
|
|
end)
|
|
test("Testing immutable members", function()
|
|
Vec(v, v)
|
|
end)
|
|
collectgarbage()
|
|
collectgarbage()
|
|
|
|
test("Testing garbage collection", function()
|
|
local Foo = immutable({"x"})
|
|
local function countFoos()
|
|
collectgarbage()
|
|
collectgarbage()
|
|
local n = 0
|
|
local buckets = 0
|
|
for h,bucket in pairs(Foo.__instances) do
|
|
buckets = buckets + 1
|
|
for _ in pairs(bucket) do
|
|
n = n + 1
|
|
end
|
|
end
|
|
collectgarbage()
|
|
collectgarbage()
|
|
return n, buckets
|
|
end
|
|
local f1, f2, also_f2 = Foo(1), Foo(2), Foo(2)
|
|
local foos, buckets = countFoos()
|
|
assert(foos == 2, "WTF? "..tostring(foos))
|
|
f1, f2 = nil, nil
|
|
foos, buckets = countFoos()
|
|
assert(foos == 1)
|
|
also_f2 = nil
|
|
foos, buckets = countFoos()
|
|
assert(foos == 0, "Leaking instances")
|
|
assert(buckets == 0, "Leaking hash buckets")
|
|
assert(next(Foo.__instances) == nil)
|
|
end)
|
|
|
|
test("Testing stupid metamethods", function()
|
|
local Five = immutable({"x"}, {__index=function() return 5 end, derp = 99})
|
|
local f = Five(99)
|
|
assert(f.x == 5 and f.asdf == 5 and f.derp == 5)
|
|
end)
|
|
|
|
test("Testing similar class", function()
|
|
FooVec = immutable({"x","y"}, {
|
|
len2=function(self)
|
|
return self.x*self.x + self.y*self.y
|
|
end,
|
|
__add=function(self, other)
|
|
local cls = getmetatable(self)
|
|
return cls(self.x+other.x, self.y+other.y)
|
|
end,
|
|
__tostring=function(self)
|
|
return "Vec("..tostring(self.x)..", "..tostring(self.y)..")"
|
|
end,
|
|
})
|
|
assert(FooVec(1,1) ~= Vec(1,1))
|
|
end)
|
|
|
|
test("Testing is_instance", function()
|
|
fv = FooVec(1,2)
|
|
assert(FooVec:is_instance(fv))
|
|
assert(not FooVec:is_instance(v))
|
|
assert(not FooVec:is_instance("asdf"))
|
|
assert(not FooVec:is_instance({}))
|
|
assert(not FooVec:is_instance(5))
|
|
end)
|
|
|
|
test("Testing spoofing", function()
|
|
local t = {99,100}
|
|
setmetatable(t, Vec)
|
|
assert(not pcall(function() return t.x end))
|
|
assert(not pcall(function() return Vec.__index(88, 9) end))
|
|
assert(not pcall(function() return Vec.__tostring(t) end))
|
|
end)
|
|
|
|
if _VERSION == "Lua 5.3" then
|
|
test("Testing unpacking", function()
|
|
if table.unpack then
|
|
local a, b = table.unpack(Vec(5,6))
|
|
assert(a == 5 and b == 6)
|
|
end
|
|
end)
|
|
|
|
test("Testing pairs()", function()
|
|
local copy = {}
|
|
for k,v in pairs(Vec(3,4)) do
|
|
copy[k] = v
|
|
end
|
|
assert(copy.x == 3 and copy.y == 4)
|
|
end)
|
|
|
|
test("Testing ipairs()", function()
|
|
local copy = {}
|
|
for k,v in ipairs(Vec(3,4)) do
|
|
copy[k] = v
|
|
end
|
|
assert(copy[1] == 3 and copy[2] == 4)
|
|
end)
|
|
end
|
|
|
|
test("Testing immutable(n)", function()
|
|
local Tup3 = immutable(nil, {name="Tuple"})
|
|
assert(tostring(Tup3(1,2,3)) == "Tuple(1, 2, 3)")
|
|
end)
|
|
|
|
test("Testing tostring(class)", function()
|
|
local C1 = immutable(nil, {name="MYNAME"})
|
|
assert(tostring(C1) == "MYNAME")
|
|
local C2 = immutable()
|
|
assert(tostring(C2):match("immutable type: 0x.*"))
|
|
end)
|
|
|
|
test("Testing tuple tostring", function()
|
|
local tup3 = immutable(nil)
|
|
assert(tostring(tup3(1,2,3)) == "(1, 2, 3)")
|
|
assert(tostring(tup3(1,tup3(2,3,4),5)) == "(1, (2, 3, 4), 5)")
|
|
end)
|
|
|
|
test("Testing giant immutable table", function()
|
|
local keys = {}
|
|
local N = 10000
|
|
for i=1,N do keys[i] = "key_"..tostring(i) end
|
|
local T = immutable(keys)
|
|
local values = {}
|
|
for i,key in ipairs(keys) do values[key] = i*i end
|
|
pcall(function() T:from_table(values) end)
|
|
end)
|
|
|
|
if num_errors == 0 then
|
|
print(green.."All tests passed!"..reset)
|
|
else
|
|
print(bright..red.."*** "..tostring(num_errors).." test"..(num_errors > 1 and "s" or "").." failed! ***"..reset)
|
|
io.write(reset)
|
|
error()
|
|
end
|