1
0
pretty/test/test_pretty.lua

363 lines
7.8 KiB
Lua
Raw Normal View History

2016-12-28 23:51:07 +00:00
local SUITE = require('TestSuite').new('pretty')
SUITE:setEnviroment{
format = require('pretty')
}
local ASSERT_ERROR_APPROX = [[
Approximate strings not similar enough:
Should match: %s
Gotten: %s
]]
2016-12-28 23:51:07 +00:00
--------------------------------------------------------------------------------
local HAS_ADV_GETLOCAL = not not debug.getinfo(1, 'u').nparams -- Lua 5.1 compat
if not loadstring then loadstring = load end -- Lua 5.3 compat
2016-12-28 23:51:07 +00:00
local function format_test (t)
if t.longterm then return end
if t.adv_getlocal and not HAS_ADV_GETLOCAL then return end
2017-04-12 13:15:03 +00:00
SUITE:addTest(t.name or t.expect:gsub('[ \n\t]+', ' '), function ()
local actual_result = format(t.input, t.options)
if not t.approx or type(actual_result) ~= 'string' then
2017-04-12 13:15:03 +00:00
assert_equal(t.expect, actual_result)
else
2017-04-12 13:15:03 +00:00
if not actual_result:match(t.expect) then
error(ASSERT_ERROR_APPROX:format(t.expect, actual_result))
end
end
2017-04-12 13:15:03 +00:00
end, { line = debug.getinfo(2).currentline })
2016-12-28 23:51:07 +00:00
end
--------------------------------------------------------------------------------
-- Strings
format_test {
input = 'Hello World',
expect = '\'Hello World\'',
}
format_test {
input = 'Hello \'World\'',
expect = '\"Hello \'World\'\"',
}
format_test {
input = 'Hello \"World\"',
expect = '\'Hello \"World\"\'',
}
format_test {
input = 'Hello [[World]]',
expect = '\'Hello [[World]]\'',
}
format_test {
input = '\'Hello\' [[World]]',
expect = '\"\'Hello\' [[World]]\"',
}
format_test {
input = '\'Hello\' \"there\" [[World]]',
expect = '[=[\'Hello\' \"there\" [[World]]]=]',
}
format_test {
input = '\'Hello\' \"there\" [=[World]=]',
expect = '[[\'Hello\' \"there\" [=[World]=]]]',
}
format_test {
input = '\nHello World',
expect = '\'\\nHello World\'',
}
format_test {
input = '\'\"\n',
expect = '[[\n\'\"\n]]',
}
format_test {
input = '\n',
expect = '\'\\n\'',
}
format_test {
input = '\\',
expect = '\'\\\\\'',
}
format_test {
input = '\000',
expect = '\'\\000\'',
}
format_test {
input = '\a\b\v\r\f',
expect = '\'\\a\\b\\v\\r\\f\'',
}
format_test {
input = 'ø',
expect = '\'ø\'',
}
--------------------------------------------------------------------------------
-- Primitive types
format_test {
input = nil,
expect = 'nil',
}
format_test {
input = true,
expect = 'true',
}
format_test {
input = false,
expect = 'false',
}
--------------------------------------------------------------------------------
-- Userdata printing
2017-04-14 11:24:29 +00:00
-- TODO: Figure out a way to print userdata.
-- Maybe look into using the one available debug.getupvalue(pairs, 1)
--------------------------------------------------------------------------------
-- Thread printing
do
local suspended_coroutine = coroutine.create(function () end)
format_test {
input = suspended_coroutine,
approx = true,
expect = 'suspended coroutine: 0x%x+',
}
end
do
local dead_coroutine = coroutine.create(function () end)
coroutine.resume(dead_coroutine)
format_test {
input = dead_coroutine,
approx = true,
expect = 'dead coroutine: 0x%x+',
}
end
2016-12-28 23:51:07 +00:00
--------------------------------------------------------------------------------
-- Single-line tables
format_test {
input = {},
expect = '{}',
}
format_test {
input = {1, 2, 3},
expect = '{ 1, 2, 3 }',
}
format_test {
input = { 'Hello', 'World' },
expect = '{ \'Hello\', \'World\' }',
}
format_test {
input = { a = 1, b = 2 },
expect = '{ a = 1, b = 2 }',
}
format_test {
input = { __hello = true },
expect = '{ __hello = true }',
}
format_test {
input = { [']]'] = true },
expect = '{ [\']]\'] = true }',
}
format_test {
input = { ['and'] = true },
expect = '{ [\'and\'] = true }',
}
format_test {
input = { [false] = false, [true] = true },
expect = '{ [false] = false, [true] = true }',
}
format_test { -- Order does not matter
input = { b = 1, a = 2 },
expect = '{ a = 2, b = 1 }',
}
format_test { -- Can include empty tables
input = { {}, {}, {} },
expect = '{ {}, {}, {} }',
}
format_test { -- Can include very small tables
input = { {1}, {2}, {3} },
expect = '{ { 1 }, { 2 }, { 3 } }',
}
--------------------------------------------------------------------------------
-- Multi-line tables
format_test {
input = { {1, 2, 3}, {4, 5, 6} },
expect = '{ { 1, 2, 3 }, { 4, 5, 6 } }',
2016-12-28 23:51:07 +00:00
}
format_test {
input = { a = {1, 2, 3}, b = {4, 5, 6} },
expect = '{ a = { 1, 2, 3 }, b = { 4, 5, 6 } }',
2016-12-28 23:51:07 +00:00
}
format_test {
input = { [100] = 'Hi', [300] = 'Hello' },
expect = '{ [100] = \'Hi\', [300] = \'Hello\' }',
}
2016-12-28 23:51:07 +00:00
format_test {
input = { 'Hi', [300] = 'Hello' },
expect = '{ [1] = \'Hi\', [300] = \'Hello\' }',
2016-12-28 23:51:07 +00:00
}
format_test {
input = { { {} } },
expect = '{ { {} } }',
2016-12-28 23:51:07 +00:00
}
format_test {
input = { [{ 1, 2 }] = { 2, 1 } },
expect = '{ [{ 1, 2 }] = { 2, 1 } }',
2016-12-28 23:51:07 +00:00
}
format_test {
input = { { {1, 2}, {3, 4} }, {5, 6} },
expect = '{ { { 1, 2 }, { 3, 4 } }, { 5, 6 } }',
2016-12-28 23:51:07 +00:00
}
format_test {
input = { { {1, 2}, {3, 4} }, {5, 6} },
options = { max_depth = 0 },
expect = '{...}',
}
format_test {
input = { { {1, 2}, {3, 4} }, {5, 6} },
options = { max_depth = 1 },
expect = '{ {...}, {...} }',
2016-12-28 23:51:07 +00:00
}
format_test {
input = { { {1, 2}, {3, 4} }, {5, 6} },
options = { max_depth = 2 },
expect = '{ { {...}, {...} }, { 5, 6 } }',
2016-12-28 23:51:07 +00:00
}
format_test {
input = { { {1, 2}, {3, 4} }, {5, 6} },
options = { max_depth = 3 },
expect = '{ { { 1, 2 }, { 3, 4 } }, { 5, 6 } }',
2016-12-28 23:51:07 +00:00
}
format_test {
input = { [{ {1,2}, {3,4} }] = 'Hello World' },
expect = '{ [{...}] = \'Hello World\' }',
2016-12-28 23:51:07 +00:00
}
format_test {
input = { a = {1,2}, bcdefg = {3,4} },
expect = '{ a = { 1, 2 }, bcdefg = { 3, 4 } }',
}
format_test {
input = { [true] = 1, [1] = false },
expect = '{ [1] = false, [true] = 1 }',
}
2016-12-29 11:11:48 +00:00
format_test {
2017-01-05 13:28:31 +00:00
-- Proper indent
2016-12-29 11:11:48 +00:00
input = { [1] = 1, ['whatever'] = false },
expect = '{ [1] = 1, [\'whatever\'] = false }',
2016-12-29 11:11:48 +00:00
}
2017-01-05 13:28:31 +00:00
format_test {
-- Table view, with indent.
input = { { a = 'hello', b = 'hi' }, { a = 'hi', b = 'hello' } },
expect = '{\n { a = \'hello\', b = \'hi\' },\n { a = \'hi\', b = \'hello\' }\n}',
2017-01-05 13:28:31 +00:00
}
2017-01-16 15:22:46 +00:00
--------------------------------------------------------------------------------
-- Table recursion
do
local recursive = {}
recursive[1] = recursive
format_test {
input = recursive,
options = { max_depth = 5 },
expect = '{ {...} }',
}
format_test {
input = recursive,
options = { max_depth = 5, recursion = 'ignore' },
expect = '{ {...} }',
}
format_test {
input = recursive,
options = { max_depth = 5, recursion = 'marked' },
expect = '<1>{ <1>{...} }',
}
end
2017-04-12 13:15:03 +00:00
do
local a = {}
local b = { a }
a[1] = b
local rec = { a = a, b = b }
format_test {
name = 'Top layers should be expanded, rather than lower layers.',
input = rec,
options = { max_depth = 5 },
expect = '{\n a = { {...} },\n b = { {...} }\n}',
2017-04-12 13:15:03 +00:00
}
end
--------------------------------------------------------------------------------
-- CDATA
-- TODO: Add more advanced understanding of cdata.
if type(jit) == 'table' then
local ffi = require('ffi')
ffi.cdef[[
int poll(struct pollfd *fds, unsigned long nfds, int timeout);
]]
format_test {
input = ffi.C.poll,
approx = true,
expect = 'cdata<.+>: 0x%x+',
}
format_test {
input = ffi.new('int[10]'),
approx = true,
expect = 'cdata<.+>: 0x%x+',
}
end
2016-12-28 23:51:07 +00:00
--------------------------------------------------------------------------------
return SUITE