115 lines
3.4 KiB
Text
115 lines
3.4 KiB
Text
-- Lua's io library against a file that exists only inside a .game. Singe hands those out as its
|
|
-- own file object, which reads the database row where it lies rather than unpacking it to a copy,
|
|
-- so everything below has to behave exactly as it would on a loose file.
|
|
--
|
|
-- It has to be run packed, with no loose copy beside the container -- a loose file shadows the
|
|
-- packed one and the whole test then proves nothing -- so from a directory holding this folder:
|
|
--
|
|
-- Singe -P packedIo packedIo.game
|
|
-- rm -rf packedIo
|
|
-- Singe -w -C 720x480 packedIo.game
|
|
--
|
|
-- It prints one line: IOTEST pass=N fail=0. Every failure prints what it wanted first.
|
|
dofile("Singe/Framework.singe")
|
|
|
|
local pass = 0
|
|
local fail = 0
|
|
|
|
|
|
local function check(what, got, want)
|
|
if got == want then
|
|
pass = pass + 1
|
|
else
|
|
fail = fail + 1
|
|
debugPrint(string.format("FAIL %s: got %s, wanted %s", what, tostring(got), tostring(want)))
|
|
end
|
|
end
|
|
|
|
|
|
-- Reading, seeking, and what each format answers at the end of the file.
|
|
local f = io.open("packedIo/lines.txt", "rb")
|
|
|
|
check("io.type", io.type(f), "file")
|
|
check("read a", f:read("a"), "alpha\nbeta\ngamma\n")
|
|
check("read a at end", f:read("a"), "")
|
|
check("seek set", f:seek("set", 0), 0)
|
|
check("read l", f:read("l"), "alpha")
|
|
check("read L", f:read("L"), "beta\n")
|
|
check("read 3", f:read(3), "gam")
|
|
check("read l rest", f:read("l"), "ma")
|
|
check("read l at end", f:read("l"), nil)
|
|
check("seek end", f:seek("end", 0), 17)
|
|
check("seek cur back", f:seek("cur", -6), 11)
|
|
check("read after seek", f:read("l"), "gamma")
|
|
f:close()
|
|
check("io.type closed", io.type(f), "closed file")
|
|
|
|
-- Iterating, both ways round. io.lines closes at the end; f:lines leaves the file alone.
|
|
local seen = {}
|
|
|
|
for line in io.lines("packedIo/lines.txt") do
|
|
seen[#seen + 1] = line
|
|
end
|
|
check("io.lines count", #seen, 3)
|
|
check("io.lines last", seen[3], "gamma")
|
|
|
|
local g = io.open("packedIo/lines.txt")
|
|
local count = 0
|
|
|
|
for _ in g:lines("L") do
|
|
count = count + 1
|
|
end
|
|
check("f:lines count", count, 3)
|
|
check("f:lines leaves it open", io.type(g), "file")
|
|
g:close()
|
|
|
|
-- Numbers, and the default input.
|
|
local n = io.open("packedIo/numbers.txt")
|
|
|
|
check("read n", n:read("n"), 12)
|
|
check("read n again", n:read("n"), 34.5)
|
|
check("read n hex", n:read("n"), 16)
|
|
n:close()
|
|
|
|
io.input("packedIo/numbers.txt")
|
|
check("io.read after io.input", io.read("l"), "12 34.5 0x10")
|
|
check("io.input() answers", io.type(io.input()), "file")
|
|
io.close()
|
|
|
|
-- A last line with no ending on it.
|
|
local t = io.open("packedIo/tail.txt")
|
|
|
|
check("read l unterminated", t:read("l"), "no newline at the end")
|
|
check("read l past it", t:read("l"), nil)
|
|
t:close()
|
|
|
|
-- A packed asset is read only, and a name that is not there answers the way Lua does.
|
|
local w = io.open("packedIo/lines.txt")
|
|
|
|
check("write refused", pcall(function() w:write("x") end), false)
|
|
w:close()
|
|
|
|
local missing, message = io.open("packedIo/nothere.txt")
|
|
|
|
check("missing is nil", missing, nil)
|
|
check("missing has a message", type(message), "string")
|
|
|
|
-- And a real file in the data directory still behaves as it always did.
|
|
local loose = io.open(singeGetDataPath() .. "loose.txt", "w")
|
|
|
|
loose:write("written\n")
|
|
loose:close()
|
|
|
|
local back = io.open(singeGetDataPath() .. "loose.txt")
|
|
|
|
check("loose round trip", back:read("l"), "written")
|
|
check("loose is a file", io.type(back), "file")
|
|
back:close()
|
|
|
|
debugPrint(string.format("IOTEST pass=%d fail=%d", pass, fail))
|
|
singeQuit()
|
|
|
|
|
|
function onOverlayUpdate()
|
|
return OVERLAY_NOT_UPDATED
|
|
end
|