Aegisub/vendor/luabins/test/test.lua
2014-04-24 23:00:41 +02:00

813 lines
20 KiB
Lua

-- ----------------------------------------------------------------------------
-- test.lua
-- Luabins test suite
-- See copyright notice in luabins.h
-- ----------------------------------------------------------------------------
package.cpath = "./?.so;"..package.cpath
local randomseed = 1235134892
--local randomseed = os.time()
print("===== BEGIN LUABINS TEST SUITE (seed " .. randomseed .. ") =====")
math.randomseed(randomseed)
-- ----------------------------------------------------------------------------
-- Utility functions
-- ----------------------------------------------------------------------------
local invariant = function(v)
return function()
return v
end
end
local escape_string = function(str)
return str:gsub(
"[^0-9A-Za-z_%- :]",
function(c)
return ("%%%02X"):format(c:byte())
end
)
end
local ensure_equals = function(msg, actual, expected)
if actual ~= expected then
error(
msg..":\n actual: `"..escape_string(tostring(actual))
.."`\nexpected: `"..escape_string(tostring(expected)).."'"
)
end
end
local ensure_equals_permute
do
-- Based on MIT-licensed
-- http://snippets.luacode.org/sputnik.lua?p=snippets/ \
-- Iterator_over_Permutations_of_a_Table_62
-- Which is based on PiL
local function permgen(a, n, fn)
if n == 0 then
fn(a)
else
for i = 1, n do
-- put i-th element as the last one
a[n], a[i] = a[i], a[n]
-- generate all permutations of the other elements
permgen(a, n - 1, fn)
-- restore i-th element
a[n], a[i] = a[i], a[n]
end
end
end
--- an iterator over all permutations of the elements of a list.
-- Please note that the same list is returned each time,
-- so do not keep references!
-- @param a list-like table
-- @return an iterator which provides the next permutation as a list
local function permute_iter(a, n)
local n = n or #a
local co = coroutine.create(function() permgen(a, n, coroutine.yield) end)
return function() -- iterator
local code, res = coroutine.resume(co)
return res
end
end
ensure_equals_permute = function(
msg,
actual,
expected_prefix,
expected_body,
expected_suffix,
expected_body_size
)
expected_body_size = expected_body_size or #expected_body
local expected
for t in permute_iter(expected_body, expected_body_size) do
expected = expected_prefix .. table.concat(t) .. expected_suffix
if actual == expected then
return actual
end
end
error(
msg..":\nactual: `"..escape_string(tostring(actual))
.."`\nexpected one of permutations: `"
..escape_string(tostring(expected)).."'"
)
end
end
local function deepequals(lhs, rhs)
if type(lhs) ~= "table" or type(rhs) ~= "table" then
return lhs == rhs
end
local checked_keys = {}
for k, v in pairs(lhs) do
checked_keys[k] = true
if not deepequals(v, rhs[k]) then
return false
end
end
for k, v in pairs(rhs) do
if not checked_keys[k] then
return false -- extra key
end
end
return true
end
local nargs = function(...)
return select("#", ...), ...
end
local pack = function(...)
return select("#", ...), { ... }
end
local eat_true = function(t, ...)
if t == nil then
error("failed: " .. (...))
end
return ...
end
-- ----------------------------------------------------------------------------
-- Test helper functions
-- ----------------------------------------------------------------------------
local luabins_local = require 'luabins'
assert(luabins_local == luabins)
assert(type(luabins.save) == "function")
assert(type(luabins.load) == "function")
local check_load_fn_ok = function(eq, saved, ...)
local expected = { nargs(...) }
local loaded = { nargs(eat_true(luabins.load(saved))) }
ensure_equals("num arguments match", loaded[1], expected[1])
for i = 2, expected[1] do
assert(eq(loaded[i], expected[i]))
end
return saved
end
local check_load_ok = function(saved, ...)
return check_load_fn_ok(deepequals, saved, ...)
end
local check_fn_ok = function(eq, ...)
local saved = assert(luabins.save(...))
assert(type(saved) == "string")
print("saved length", #saved, "(display truncated to 70 chars)")
print(escape_string(saved):sub(1, 70))
return check_load_fn_ok(eq, saved, ...)
end
local check_ok = function(...)
print("check_ok")
return check_fn_ok(deepequals, ...)
end
local check_fail_save = function(msg, ...)
print("check_fail_save")
local res, err = luabins.save(...)
ensure_equals("result", res, nil)
ensure_equals("error message", err, msg)
-- print("/check_fail_save")
end
local check_fail_load = function(msg, v)
print("check_fail_load")
local res, err = luabins.load(v)
ensure_equals("result", res, nil)
ensure_equals("error message", err, msg)
-- print("/check_fail_load")
end
print("===== BEGIN LARGE DATA OK =====")
-- Based on actual bug.
-- This dataset triggered Lua C data stack overflow.
-- (Note that bug is not triggered if check_ok is used)
-- Update data with
-- $ lua etc/toluabins.lua test/large_data.lua>test/large_data.luabins
-- WARNING: Keep this test above other tests, so Lua stack is small.
assert(
luabins.load(
assert(io.open("test/large_data.luabins", "r"):read("*a"))
)
)
print("===== LARGE DATA OK =====")
-- ----------------------------------------------------------------------------
-- Basic tests
-- ----------------------------------------------------------------------------
print("===== BEGIN BASIC TESTS =====")
print("---> basic corrupt data tests")
check_fail_load("can't load: corrupt data", "")
check_fail_load("can't load: corrupt data", "bad data")
print("---> basic extra data tests")
do
local s
s = check_ok()
check_fail_load("can't load: extra data at end", s .. "-")
s = check_ok(nil)
check_fail_load("can't load: extra data at end", s .. "-")
s = check_ok(true)
check_fail_load("can't load: extra data at end", s .. "-")
s = check_ok(false)
check_fail_load("can't load: extra data at end", s .. "-")
s = check_ok(42)
check_fail_load("can't load: extra data at end", s .. "-")
s = check_ok(math.pi)
check_fail_load("can't load: extra data at end", s .. "-")
s = check_ok(1/0)
check_fail_load("can't load: extra data at end", s .. "-")
s = check_ok(-1/0)
check_fail_load("can't load: extra data at end", s .. "-")
s = check_ok("Luabins")
check_fail_load("can't load: extra data at end", s .. "-")
s = check_ok({ })
check_fail_load("can't load: extra data at end", s .. "-")
s = check_ok({ a = 1, 2 })
check_fail_load("can't load: extra data at end", s .. "-")
end
print("---> basic type tests")
-- This is the way to detect NaN
check_fn_ok(function(lhs, rhs) return lhs ~= lhs and rhs ~= rhs end, 0/0)
check_ok("")
check_ok("Embedded\0Zero")
check_ok(("longstring"):rep(1024000))
check_fail_save("can't save: unsupported type detected", function() end)
check_fail_save(
"can't save: unsupported type detected",
coroutine.create(function() end)
)
check_fail_save("can't save: unsupported type detected", newproxy())
print("---> basic table tests")
check_ok({ 1 })
check_ok({ a = 1 })
check_ok({ a = 1, 2, [42] = true, [math.pi] = math.huge })
check_ok({ { } })
check_ok({ a = {}, b = { c = 7 } })
check_ok({ 1, 2, 3 })
check_ok({ [1] = 1, [1.5] = 2, [2] = 3 })
check_ok({ 1, nil, 3 })
check_ok({ 1, nil, 3, [{ 1, nil, 3 }] = { 1, nil, 3 } })
print("---> basic tuple tests")
check_ok(nil, nil)
do
local s = check_ok(nil, false, true, 42, "Embedded\0Zero", { { [{3}] = 54 } })
check_fail_load("can't load: extra data at end", s .. "-")
check_ok(check_ok(s)) -- Save data string couple of times more
end
print("---> basic table tuple tests")
check_ok({ a = {}, b = { c = 7 } }, nil, { { } }, 42)
check_ok({ ["1"] = "str", [1] = "num" })
check_ok({ [true] = true })
check_ok({ [true] = true, [false] = false, 1 })
print("---> basic fail save tests")
check_fail_save(
"can't save: unsupported type detected",
{ { function() end } }
)
check_fail_save(
"can't save: unsupported type detected",
nil, false, true, 42, "Embedded\0Zero", function() end,
{ { [{3}] = 54 } }
)
print("---> recursive table test")
local t = {}; t[1] = t
check_fail_save("can't save: nesting is too deep", t)
print("---> metatable test")
check_ok(setmetatable({}, {__index = function(t, k) return k end}))
print("===== BASIC TESTS OK =====")
print("===== BEGIN FORMAT SANITY TESTS =====")
-- Format sanity checks for LJ2 compatibility tests.
-- These tests are intended to help debugging actual problems
-- of test suite, and are not feature complete.
-- What is not checked here, checked in the rest of suite.
do
do
local saved = check_ok(1)
local expected =
"\001".."N"
.. "\000\000\000\000\000\000\240\063" -- Note number is a double
ensure_equals(
"1 as number",
expected,
saved
)
end
do
local saved = check_ok({ [true] = 1 })
local expected =
"\001".."T"
.. "\000\000\000\000".."\001\000\000\000"
.. "1"
.. "N\000\000\000\000\000\000\240\063" -- Note number is a double
ensure_equals(
"1 as value",
expected,
saved
)
end
do
local saved = check_ok({ [1] = true })
local expected =
"\001".."T"
.. "\001\000\000\000".."\000\000\000\000"
.. "N\000\000\000\000\000\000\240\063" -- Note number is a double
.. "1"
ensure_equals(
"1 as key",
expected,
saved
)
end
end
print("===== FORMAT SANITY TESTS OK =====")
print("===== BEGIN AUTOCOLLAPSE TESTS =====")
-- Note: those are ad-hoc tests, tuned for old implementation
-- which generated save data on Lua stack.
-- These tests are kept here for performance comparisons.
local LUABINS_CONCATTHRESHOLD = 1024
local gen_t = function(size)
-- two per numeric entry, three per string entry,
-- two entries per key-value pair
local actual_size = math.ceil(size / (2 + 3))
print("generating table of "..actual_size.." pairs")
local t = {}
for i = 1, actual_size do
t[i] = "a"..i
end
return t
end
-- Test table value autocollapse
check_ok(gen_t(LUABINS_CONCATTHRESHOLD - 100)) -- underflow, no autocollapse
check_ok(gen_t(LUABINS_CONCATTHRESHOLD)) -- autocollapse, no extra elements
check_ok(gen_t(LUABINS_CONCATTHRESHOLD + 100)) -- autocollapse, extra elements
-- Test table key autocollapse
check_ok({ [gen_t(LUABINS_CONCATTHRESHOLD - 4)] = true })
-- Test multiarg autocollapse
check_ok(
1,
gen_t(LUABINS_CONCATTHRESHOLD - 5),
2,
gen_t(LUABINS_CONCATTHRESHOLD - 5),
3
)
print("===== AUTOCOLLAPSE TESTS OK =====")
print("===== BEGIN MIN TABLE SIZE TESTS =====")
do
-- one small key
do
local data = { [true] = true }
local saved = check_ok(data)
ensure_equals(
"format sanity check",
"\001".."T".."\000\000\000\000".."\001\000\000\000".."11",
saved
)
check_fail_load(
"can't load: corrupt data, bad size",
saved:sub(1, #saved - 1)
)
-- As long as array and hash size sum is correct
-- (and both are within limits), load is successful.
-- If values are swapped, we get some performance hit.
check_load_ok(
"\001".."T".."\001\000\000\000".."\000\000\000\000".."11",
data
)
check_fail_load(
"can't load: corrupt data, bad size",
"\001".."T".."\001\000\000\000".."\001\000\000\000".."11"
)
check_fail_load(
"can't load: corrupt data, bad size",
"\001".."T".."\000\000\000\000".."\002\000\000\000".."11"
)
check_fail_load(
"can't load: extra data at end",
"\001".."T".."\000\000\000\000".."\000\000\000\000".."11"
)
check_fail_load(
"can't load: corrupt data, bad size",
"\001".."T".."\255\255\255\255".."\255\255\255\255".."11"
)
check_fail_load(
"can't load: corrupt data, bad size",
"\001".."T".."\000\255\255\255".."\000\255\255\255".."11"
)
check_fail_load(
"can't load: corrupt data, bad size",
"\255".."T".."\000\000\000\000".."\000\000\000\000"
)
end
-- two small keys
do
local data = { [true] = true, [false] = false }
local saved = check_ok({ [true] = true, [false] = false })
ensure_equals_permute(
"format sanity check",
saved,
"\001" .. "T" .. "\000\000\000\000" .. "\002\000\000\000",
{
"0" .. "0";
"1" .. "1";
},
""
)
check_fail_load(
"can't load: corrupt data, bad size",
saved:sub(1, #saved - 1)
)
-- See above about swapped array and hash sizes
check_load_ok(
"\001".."T".."\001\000\000\000".."\001\000\000\000".."1100",
data
)
check_fail_load(
"can't load: corrupt data, bad size",
"\001".."T".."\000\000\000\000".."\003\000\000\000".."0011"
)
end
-- two small and one large key
do
local saved = check_ok({ [true] = true, [false] = false, [1] = true })
ensure_equals_permute(
"format sanity check",
saved,
"\001" .. "T" .. "\001\000\000\000" .. "\002\000\000\000",
{
"0" .. "0";
"1" .. "1";
-- Note number is a double
"N\000\000\000\000\000\000\240\063" .. "1";
},
""
)
check_fail_load(
"can't load: corrupt data",
saved:sub(1, #saved - 1)
)
check_fail_load(
"can't load: corrupt data, bad size",
"\001".."T"
.. "\002\000\000\000".."\002\000\000\000"
.. "0011"
.. "N\000\000\000\000\000\000\240\063"
.. "1"
)
check_fail_load(
"can't load: corrupt data, bad size",
"\001".."T"
.. "\001\000\000\000".."\003\000\000\000"
.. "0011"
.. "N\000\000\000\000\000\000\240\063"
.. "1"
)
end
-- two small and two large keys
do
local saved = check_ok(
{ [true] = true, [false] = false, [1] = true, [42] = true }
)
local expected =
"\001".."T"
.. "\001\000\000\000".."\003\000\000\000"
.. "0011"
ensure_equals_permute(
"format sanity check",
saved,
"\001" .. "T" .. "\001\000\000\000" .. "\003\000\000\000",
{
"0" .. "0";
"1" .. "1";
"N\000\000\000\000\000\000\069\064" .. "1";
"N\000\000\000\000\000\000\240\063" .. "1";
},
""
)
check_fail_load(
"can't load: corrupt data",
saved:sub(1, #saved - 1)
)
check_fail_load(
"can't load: corrupt data, bad size",
"\001".."T"
.. "\001\000\000\000".."\005\000\000\000"
.. "0011"
.. "N\000\000\000\000\000\000\069\064"
.. "1"
.. "N\000\000\000\000\000\000\240\063"
.. "1"
)
check_fail_load(
"can't load: corrupt data, bad size",
"\001".."T"
.. "\003\000\000\000".."\003\000\000\000"
.. "0011"
.. "N\000\000\000\000\000\000\069\064"
.. "1"
.. "N\000\000\000\000\000\000\240\063"
.. "1"
)
end
end
print("===== MIN TABLE SIZE TESTS OK =====")
print("===== BEGIN LOAD TRUNCATION TESTS =====")
local function gen_random_dataset(num, nesting)
num = num or math.random(0, 128)
nesting = nesting or 1
local gen_str = function()
local t = {}
local n = math.random(0, 1024)
for i = 1, n do
t[i] = string.char(math.random(0, 255))
end
return table.concat(t)
end
local gen_bool = function() return math.random() >= 0.5 end
local gen_nil = function() return nil end
local generators =
{
gen_nil;
gen_nil;
gen_nil;
gen_bool;
gen_bool;
gen_bool;
function() return math.random() end;
function() return math.random(-10000, 10000) end;
function() return math.random() * math.random(-10000, 10000) end;
gen_str;
gen_str;
gen_str;
function()
if nesting >= 24 then
return nil
end
local t = {}
local n = math.random(0, 24 - nesting)
for i = 1, n do
local k = gen_random_dataset(1, nesting + 1)
if k == nil then
k = "(nil)"
end
t[ k ] = gen_random_dataset(
1,
nesting + 1
)
end
return t
end;
}
local t = {}
for i = 1, num do
local n = math.random(1, #generators)
t[i] = generators[n]()
end
return unpack(t, 0, num)
end
local random_dataset_num, random_dataset_data = pack(gen_random_dataset())
local random_dataset_saved = check_ok(
unpack(random_dataset_data, 0, random_dataset_num)
)
local num_tries = 100
local errors = {}
for i = 1, num_tries do
local to = math.random(1, #random_dataset_saved - 1)
local new_data = random_dataset_saved:sub(1, to)
local res, err = luabins.load(new_data)
ensure_equals("truncated data must not be loaded", res, nil)
errors[err] = (errors[err] or 0) + 1
end
print("truncation errors encountered:")
for err, n in pairs(errors) do
print(err, n)
end
print("===== BASIC LOAD TRUNCATION OK =====")
print("===== BEGIN LOAD MUTATION TESTS =====")
local function mutate_string(str, num, override)
num = num or math.random(1, 8)
if num < 1 then
return str
end
local mutators =
{
-- truncate at end
function(str)
local pos = math.random(1, #str)
return str:sub(1, pos)
end;
-- truncate at beginning
function(str)
local pos = math.random(1, #str)
return str:sub(-pos)
end;
-- cut out the middle
function(str)
local from = math.random(1, #str)
local to = math.random(from, #str)
return str:sub(1, from) .. str:sub(to)
end;
-- swap two halves
function(str)
local pos = math.random(1, #str)
return str:sub(pos + 1, #str) .. str:sub(1, pos)
end;
-- swap two characters
function(str)
local pa, pb = math.random(1, #str), math.random(1, #str)
local a, b = str:sub(pa, pa), str:sub(pb, pb)
return
str:sub(1, pa - 1) ..
a ..
str:sub(pa + 1, pb - 1) ..
b ..
str:sub(pb + 1, #str)
end;
-- replace one character
function(str)
local pos = math.random(1, #str)
return
str:sub(1, pos - 1) ..
string.char(math.random(0, 255)) ..
str:sub(pos + 1, #str)
end;
-- increase one character
function(str)
local pos = math.random(1, #str)
local b = str:byte(pos, pos) + 1
if b > 255 then
b = 0
end
return
str:sub(1, pos - 1) ..
string.char(b) ..
str:sub(pos + 1, #str)
end;
-- decrease one character
function(str)
local pos = math.random(1, #str)
local b = str:byte(pos, pos) - 1
if b < 0 then
b = 255
end
return
str:sub(1, pos - 1) ..
string.char(b) ..
str:sub(pos + 1, #str)
end;
}
local n = override or math.random(1, #mutators)
str = mutators[n](str)
return mutate_string(str, num - 1, override)
end
local num_tries = 100000
local num_successes = 0
local errors = {}
for i = 1, num_tries do
local new_data = mutate_string(random_dataset_saved)
local res, err = luabins.load(new_data)
if res == nil then
errors[err] = (errors[err] or 0) + 1
else
num_successes = num_successes + 1
end
end
if num_successes == 0 then
print("no mutated strings loaded successfully")
else
-- This is ok, since we may corrupt data, not format.
-- If it is an issue for user, he must append checksum to data,
-- as usual.
print("mutated strings loaded successfully: "..num_successes)
end
print("mutation errors encountered:")
for err, n in pairs(errors) do
print(err, n)
end
print("===== BASIC LOAD MUTATION OK =====")
print("OK")