355 lines
13 KiB
Lua
355 lines
13 KiB
Lua
-- tests the quickfort ecosystem end-to-end via:
|
|
-- .csv -> quickfort/buildingplan/dig-now -> blueprint -> .csv
|
|
--
|
|
-- test cases are sets of .csv files in the
|
|
-- blueprints/library/test/ecosystem/in directory
|
|
--
|
|
-- test metadata is stored in an associated #notes blueprint:
|
|
-- description (required)
|
|
-- width (required)
|
|
-- height (required)
|
|
-- depth (default is 1)
|
|
-- start (cursor offset for input blueprints, default is 1,1)
|
|
--
|
|
-- depends on blueprint, buildingplan, and dig-now plugins (as well as the
|
|
-- quickfort script, of course)
|
|
--
|
|
-- note that this test harness cannot (yet) test #query blueprints that define
|
|
-- rooms since furniture is not actually built during the test. It also cannot
|
|
-- test blueprints that #build flooring and then #build a workshop on top, again
|
|
-- since the flooring is never actually built. We can support these features
|
|
-- once we figure out how to programmatically deconstruct buildlings without
|
|
-- crashing the game.
|
|
|
|
config.mode = 'fortress'
|
|
|
|
local argparse = require('argparse')
|
|
local blueprint = require('plugins.blueprint')
|
|
local quickfort_list = reqscript('internal/quickfort/list')
|
|
local quickfort_command = reqscript('internal/quickfort/command')
|
|
local utils = require('utils')
|
|
|
|
local blueprints_dir = 'blueprints/'
|
|
local input_dir = 'library/test/ecosystem/in/'
|
|
local golden_dir = 'library/test/ecosystem/golden/'
|
|
local output_dir = 'library/test/ecosystem/out/'
|
|
|
|
local phase_names = utils.invert(blueprint.valid_phases)
|
|
|
|
-- clear the output dir before each test run (but not after -- to allow
|
|
-- inspection of failed results)
|
|
local function test_wrapper(test_fn)
|
|
local outdir = blueprints_dir .. output_dir
|
|
if dfhack.filesystem.exists(outdir) then
|
|
for _, v in ipairs(dfhack.filesystem.listdir_recursive(outdir)) do
|
|
if not v.isdir then
|
|
os.remove(v.path)
|
|
end
|
|
end
|
|
end
|
|
test_fn()
|
|
end
|
|
config.wrapper = test_wrapper
|
|
|
|
local function bad_spec(expected, varname, basename, bad_value)
|
|
qerror(('expected %s for %s in "%s" test spec; got "%s"'):
|
|
format(expected, varname, basename, bad_value))
|
|
end
|
|
|
|
local function get_positive_int(numstr, varname, basename)
|
|
local num = tonumber(numstr)
|
|
if not num or num <= 0 or num ~= math.floor(num) then
|
|
bad_spec('positive integer', varname, basename, numstr)
|
|
end
|
|
return num
|
|
end
|
|
|
|
local function os_exists(path)
|
|
return os.rename(path, path) and true or false
|
|
end
|
|
|
|
local function get_blueprint_sets()
|
|
-- find test blueprints with `quickfort list`
|
|
local mock_print = mock.func()
|
|
mock.patch(quickfort_list, 'print', mock_print,
|
|
function()
|
|
dfhack.run_script('quickfort', 'list', '-l', input_dir)
|
|
end)
|
|
|
|
-- group blueprint sets
|
|
local sets = {}
|
|
for _,args in ipairs(mock_print.call_args) do
|
|
local line = args[1]
|
|
-- phase is the label or, if the label doesn't exist, the mode
|
|
local _,_,listnum,fname,phase = line:find('(%d+)%) (%S+).-[/(]([^ )]+)')
|
|
if listnum then
|
|
local _,_,file_part = fname:find('/([^/]+)$')
|
|
local _,_,basename = file_part:find('^([^-.]+)')
|
|
if not sets[basename] then sets[basename] = {spec={}, phases={}} end
|
|
local golden_path = blueprints_dir..golden_dir..file_part
|
|
if not os_exists(golden_path) then
|
|
golden_path = blueprints_dir..fname
|
|
end
|
|
sets[basename].phases[phase] = {
|
|
listnum=listnum,
|
|
golden_filepath=golden_path,
|
|
output_filepath=blueprints_dir..output_dir..file_part}
|
|
end
|
|
end
|
|
|
|
-- load test specs
|
|
for basename,set in pairs(sets) do
|
|
local spec, notes = set.spec, set.phases.notes
|
|
|
|
-- set defaults
|
|
spec.depth = '1'
|
|
|
|
-- read spec
|
|
mock.patch(quickfort_command, 'print',
|
|
function(text)
|
|
for line in text:gmatch('[^\n]*') do
|
|
local _,_,var,val = line:find('%*?%s*([^=]+)=(.*)')
|
|
if var then spec[var] = val end
|
|
end
|
|
end,
|
|
function()
|
|
dfhack.run_script('quickfort', 'run', '-q', notes.listnum)
|
|
end)
|
|
|
|
-- validate spec and convert number strings to numeric vars
|
|
if not spec.description or spec.description == '' then
|
|
qerror(('missing description in test spec for "%s"'):
|
|
format(basename))
|
|
end
|
|
spec.width = get_positive_int(spec.width, 'width', basename)
|
|
spec.height = get_positive_int(spec.height, 'height', basename)
|
|
spec.depth = get_positive_int(spec.depth, 'depth', basename)
|
|
if spec.start then
|
|
local start_spec = argparse.numberList(spec.start, basename, 2)
|
|
spec.start = {x=get_positive_int(start_spec[1], 'startx', basename),
|
|
y=get_positive_int(start_spec[2], 'starty', basename)}
|
|
end
|
|
end
|
|
|
|
return sets
|
|
end
|
|
|
|
local function is_usable_test_tile(pos)
|
|
local tiletype = dfhack.maps.getTileType(pos)
|
|
local tileattrs = df.tiletype.attrs[tiletype]
|
|
local good_material = tileattrs.material == df.tiletype_material.STONE or
|
|
tileattrs.material == df.tiletype_material.FEATURE or
|
|
tileattrs.material == df.tiletype_material.MINERAL
|
|
local good_shape = tileattrs.shape == df.tiletype_shape.WALL
|
|
return good_material and good_shape
|
|
end
|
|
|
|
local function get_test_area(area, spec)
|
|
-- return with success if our current area meets or exceeds requirements
|
|
if area.width >= spec.width and area.height >= spec.height and
|
|
area.depth >= spec.depth then
|
|
return true
|
|
end
|
|
|
|
-- return with failure if the test requirements cannot ever be satisfied by
|
|
-- the current map
|
|
if spec.width > df.global.world.map.x_count - 2 or
|
|
spec.height > df.global.world.map.y_count - 2 or
|
|
spec.depth > df.global.world.map.z_count then
|
|
print('map too small to accomodate test')
|
|
return false
|
|
end
|
|
|
|
-- keep this simple for now. just go down the layers and check the region
|
|
-- starting at the upper left corner of each level.
|
|
local startz = area.pos and area.pos.z or df.global.world.map.z_count-1
|
|
for z_start = startz,0,-1 do
|
|
local z_end = z_start - spec.depth + 1
|
|
if z_end < 1 then return false end
|
|
for z = z_start,z_end,-1 do
|
|
for y = 1,spec.height do
|
|
for x = 1,spec.width do
|
|
if not is_usable_test_tile(xyz2pos(x, y, z)) then
|
|
-- next check should start on the z-level below this one
|
|
z_start = z
|
|
goto continue
|
|
end
|
|
end
|
|
end
|
|
end
|
|
do
|
|
area.width, area.height, area.depth =
|
|
spec.width, spec.height, spec.depth
|
|
area.pos = {x=1, y=1, z=z_start}
|
|
area.endpos = {x=area.width, y=area.height, z=z_start-area.depth+1}
|
|
return true
|
|
end
|
|
::continue::
|
|
end
|
|
end
|
|
|
|
local function get_cursor_arg(pos, start)
|
|
start = start or {x=1, y=1}
|
|
return ('--cursor=%d,%d,%d'):format(pos.x+start.x-1, pos.y+start.y-1, pos.z)
|
|
end
|
|
|
|
local function quickfort_cmd(cmd, listnum, pos, start)
|
|
dfhack.run_script('quickfort', cmd, '-q', listnum,
|
|
get_cursor_arg(pos, start))
|
|
end
|
|
|
|
local function quickfort_run(listnum, pos, start)
|
|
quickfort_cmd('run', listnum, pos, start)
|
|
end
|
|
|
|
local function quickfort_undo(listnum, pos, start)
|
|
quickfort_cmd('undo', listnum, pos, start)
|
|
end
|
|
|
|
local function designate_area(pos, spec)
|
|
local endx, endy, endz = pos.x + spec.width - 1, pos.y + spec.height - 1,
|
|
pos.z - spec.depth + 1
|
|
for z = pos.z,endz,-1 do for y = pos.y,endy do for x = pos.x,endx do
|
|
dfhack.maps.getTileFlags(xyz2pos(x, y, z)).dig =
|
|
df.tile_dig_designation.Default
|
|
end end end
|
|
end
|
|
|
|
local function format_pos(pos)
|
|
return ('%s,%s,%s'):format(pos.x, pos.y, pos.z)
|
|
end
|
|
|
|
local function run_dig_now(area)
|
|
dfhack.run_command('dig-now', format_pos(area.pos),
|
|
format_pos(area.endpos), '--clean')
|
|
end
|
|
|
|
local function run_blueprint(basename, set, pos)
|
|
blueprint.run(tostring(set.spec.width), tostring(set.spec.height),
|
|
tostring(-set.spec.depth), output_dir..basename,
|
|
get_cursor_arg(pos), '-tphase')
|
|
end
|
|
|
|
local function reset_area(area, spec)
|
|
-- include the area border tiles that can get unhidden
|
|
local width, height, depth = spec.width+2, spec.height+2, spec.depth
|
|
local commands = {
|
|
'f', 'any', ';',
|
|
'p', 'any', ';',
|
|
'p', 's', 'wall', ';',
|
|
'p', 'sp', 'normal', ';',
|
|
'p', 'h', '1', ';',
|
|
'r', tostring(width), tostring(height), tostring(depth)}
|
|
dfhack.run_command('tiletypes-command', table.unpack(commands))
|
|
|
|
local pos = copyall(area.pos)
|
|
-- include the border tiles
|
|
pos.x = pos.x - 1
|
|
pos.y = pos.y - 1
|
|
-- tiletypes goes up z's, so adjust starting zlevel accordingly
|
|
pos.z = pos.z - spec.depth + 1
|
|
|
|
dfhack.run_command('tiletypes-here', '--quiet', get_cursor_arg(pos))
|
|
|
|
-- patch up tiles where the material couldn't be automatically determined
|
|
-- we don't just set all tiles to 'stone' so we don't obliterate veins
|
|
commands = {
|
|
'f', 's', 'empty', ';',
|
|
'p', 'm', 'stone'}
|
|
dfhack.run_command('tiletypes-command', table.unpack(commands))
|
|
dfhack.run_command('tiletypes-here', '--quiet', get_cursor_arg(pos))
|
|
|
|
commands = {'f', 's', 'ramp_top'}
|
|
dfhack.run_command('tiletypes-command', table.unpack(commands))
|
|
dfhack.run_command('tiletypes-here', '--quiet', get_cursor_arg(pos))
|
|
end
|
|
|
|
local function do_phase(phase_data, area, spec)
|
|
quickfort_run(phase_data.listnum, area.pos, spec.start)
|
|
end
|
|
|
|
-- run a #dig blueprint (or just designate the whole block if there is no data)
|
|
-- and then run dig-now to materialize the designations
|
|
local function do_dig_phase(phase_data, area, spec)
|
|
if phase_data then
|
|
do_phase(phase_data, area, spec)
|
|
else
|
|
designate_area(area.pos, spec)
|
|
end
|
|
|
|
-- run dig-now to dig out designated tiles
|
|
run_dig_now(area)
|
|
end
|
|
|
|
function test.end_to_end()
|
|
-- read in test plan
|
|
local sets = get_blueprint_sets()
|
|
|
|
local area = {width=0, height=0, depth=0}
|
|
for basename,set in pairs(sets) do
|
|
local spec = set.spec
|
|
|
|
print(('running quickfort ecosystem test: "%s": %s'):
|
|
format(basename, spec.description))
|
|
|
|
-- find an unused area of the map that meets requirements, else skip
|
|
if not get_test_area(area, spec) then
|
|
print(('cannot find unused map area to test set "%s"; skipping'):
|
|
format(basename))
|
|
goto continue
|
|
end
|
|
|
|
local phases = set.phases
|
|
do_dig_phase(phases.dig, area, spec)
|
|
if phases.smooth then do_dig_phase(phases.smooth, area, spec) end
|
|
if phases.carve then do_dig_phase(phases.carve, area, spec) end
|
|
if phases.build then do_phase(phases.build, area, spec) end
|
|
if phases.place then do_phase(phases.place, area, spec) end
|
|
if phases.zone then do_phase(phases.zone, area, spec) end
|
|
if phases.query then do_phase(phases.query, area, spec) end
|
|
|
|
-- run blueprint to generate files in output dir
|
|
run_blueprint(basename, set, area.pos)
|
|
|
|
-- quickfort undo blueprints
|
|
for _,phase_name in ipairs(phase_names) do
|
|
if phases[phase_name] then
|
|
quickfort_undo(phases[phase_name].listnum, area.pos, spec.start)
|
|
end
|
|
end
|
|
|
|
-- run tiletypes to reset tiles in area to hidden walls
|
|
reset_area(area, set.spec)
|
|
|
|
-- compare md5sum of input and output files
|
|
local md5File = dfhack.internal.md5File
|
|
for phase,phase_data in pairs(phases) do
|
|
if phase == 'notes' then goto continue end
|
|
print((' verifying phase: %s'):format(phase))
|
|
local golden_filepath = phase_data.golden_filepath
|
|
local output_filepath = phase_data.output_filepath
|
|
local input_hash, input_size = md5File(golden_filepath)
|
|
local output_hash, output_size = md5File(output_filepath)
|
|
expect.eq(input_hash, output_hash,
|
|
'compare blueprint contents to input: '..output_filepath)
|
|
expect.eq(input_size, output_size,
|
|
'compare blueprint length to input: '..output_filepath)
|
|
if not output_hash then goto continue end
|
|
if input_hash ~= output_hash or input_size ~= output_size then
|
|
-- show diff
|
|
local input, output =
|
|
io.open(golden_filepath, 'r'), io.open(output_filepath, 'r')
|
|
local input_lines, output_lines = {}, {}
|
|
for l in input:lines() do table.insert(input_lines, l) end
|
|
for l in output:lines() do table.insert(output_lines, l) end
|
|
input:close()
|
|
output:close()
|
|
expect.table_eq(input_lines, output_lines)
|
|
end
|
|
::continue::
|
|
end
|
|
|
|
::continue::
|
|
end
|
|
end
|