847 lines
30 KiB
Python
Executable file
847 lines
30 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
|
|
'''
|
|
Test script for record/replay. Only tested on Unix.
|
|
|
|
E.g.:
|
|
|
|
./flightgear/scripts/python/recordreplay.py -f run_fgfs.sh
|
|
|
|
Args:
|
|
--all
|
|
Run all tests (this is default).
|
|
--continuous BOOLS
|
|
--extra-properties BOOLS
|
|
--it-max <it>
|
|
Set min iteration (inclusive) to run; useful when fixing tests and
|
|
retrying.
|
|
--it-min <it>
|
|
Set max iteration (exclusive) to run; useful when fixing tests and
|
|
retrying.
|
|
--main-view BOOLS
|
|
--multiplayer
|
|
-f <fgfs>
|
|
The fgfs executable to use. Default assumes the Walk build system.
|
|
--f-old <fgfs-old>
|
|
A second fgfs executable. If specified we run all tests twice, first
|
|
using <fgfs-old> to create the recording and <fgfs> to replay it,
|
|
second the other way round.
|
|
--test-motion
|
|
Checks that speed of aircraft on replay is not affected by frame rate.
|
|
|
|
We deliberately change frame rate while recording UFO moving at
|
|
constant speed.
|
|
|
|
--test-motion-mp
|
|
Checks that speed of MP on replay is not affected by frame rate.
|
|
|
|
We deliberately change frame rate while recording UFO moving at
|
|
constant speed.
|
|
|
|
BOOLS is comma-sparated list of 0 or 1, with 1 activating the particular
|
|
feature. So for example '--continuous 0' tests normal recording/replay',
|
|
'--continuous 1' tests continuous recording/replay, and continuous 0,1'
|
|
tests both.
|
|
|
|
We test all combinations of continuous, extra-properties, main-view and
|
|
multiplayer recordings. For each test we check that we can create a
|
|
recording, and replay it in a new fgfs instance. When replaying we check
|
|
a small number of basic things such as the recording length, and whether
|
|
extra-properties are replayed.
|
|
'''
|
|
|
|
import os
|
|
import signal
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
|
|
try:
|
|
import resource
|
|
except Exception:
|
|
# We don't mind if 'resource' module is not available, e.g. on Windows.
|
|
resource = None
|
|
|
|
import FlightGear
|
|
|
|
def log(text):
|
|
print(text, file=sys.stderr)
|
|
sys.stderr.flush()
|
|
|
|
g_cleanup = []
|
|
g_tapedir = './recordreplay.py.tapes'
|
|
|
|
|
|
def remove(path):
|
|
'''
|
|
Removes file, ignoring any error.
|
|
'''
|
|
log(f'Removing: {path}')
|
|
try:
|
|
os.remove(path)
|
|
except Exception as e:
|
|
log(f'Failed to remove {path}: {e}')
|
|
|
|
|
|
def readlink(path):
|
|
'''
|
|
Returns absolute path destination of link.
|
|
'''
|
|
ret = os.readlink(path)
|
|
if not os.path.isabs(ret):
|
|
ret = os.path.join(os.path.dirname(path), ret)
|
|
return ret
|
|
|
|
|
|
class Fg:
|
|
'''
|
|
Runs flightgear, with support for setting/getting properties etc.
|
|
|
|
self.fg is a FlightGear.FlightGear instance, which uses telnet to
|
|
communicate with Flightgear.
|
|
'''
|
|
def __init__(self, aircraft, args, env=None, telnet_port=None, telnet_hz=None, out=None, screensaver_suspend=True):
|
|
'''
|
|
aircraft:
|
|
Specified as: --aircraft={aircraft}. This is separate from <args>
|
|
because we need to know the name of recording files.
|
|
args:
|
|
Miscellenous args either space-separated name=value strings or a
|
|
dict.
|
|
env:
|
|
Environment to set. If DISPLAY is not in <env> we add 'DISPLAY=:0'.
|
|
telnet_port:
|
|
telnet_hz:
|
|
.
|
|
'''
|
|
self.child = None
|
|
self.aircraft = aircraft
|
|
if aircraft:
|
|
args += f' --aircraft={aircraft}'
|
|
|
|
if telnet_port is None:
|
|
telnet_port = 5500
|
|
if telnet_hz is None:
|
|
args += f' --telnet={telnet_port}'
|
|
else:
|
|
args += f' --telnet=_,_,{telnet_hz},_,{telnet_port},_'
|
|
args += f' --prop:/sim/replay/tape-directory={g_tapedir}'
|
|
args += f' --prop:bool:/sim/startup/screensaver-suspend={"true" if screensaver_suspend else "false"}'
|
|
|
|
args2 = args.split()
|
|
|
|
environ = os.environ.copy()
|
|
if isinstance(env, str):
|
|
for nv in env.split():
|
|
n, v = nv.split('=', 1)
|
|
environ[n] = v
|
|
if 'DISPLAY' not in environ:
|
|
environ['DISPLAY'] = ':0'
|
|
|
|
# Run flightgear in new process, telling it to open telnet server.
|
|
#
|
|
# We run not in a shell, otherwise self.child.terminate() doesn't
|
|
# work - it would kill the shell but leave fgfs running (there are
|
|
# workarounds for this, such as prefixing the command with 'exec').
|
|
#
|
|
log(f'Command is: {args}')
|
|
log(f'Running: {args2}')
|
|
if resource:
|
|
def preexec():
|
|
try:
|
|
resource.setrlimit(resource.RLIMIT_CORE, (resource.RLIM_INFINITY, resource.RLIM_INFINITY))
|
|
except Exception as e:
|
|
log(f'*** preexec failed with e={e}')
|
|
raise
|
|
else:
|
|
preexec = None
|
|
if out:
|
|
out = open(out, 'w')
|
|
self.child = subprocess.Popen(
|
|
args2,
|
|
env=environ,
|
|
preexec_fn=preexec,
|
|
stdout=out,
|
|
stderr=subprocess.STDOUT,
|
|
)
|
|
|
|
# Connect to flightgear's telnet server.
|
|
timeout = 15
|
|
t0 = time.time()
|
|
while 1:
|
|
time.sleep(1)
|
|
dt = time.time() - t0
|
|
if dt > timeout:
|
|
text = f'Timeout trying to connect. timeout={timeout}'
|
|
log(text)
|
|
raise Exception(text)
|
|
try:
|
|
log('Connecting... ')
|
|
self.fg = FlightGear.FlightGear('localhost', telnet_port)
|
|
log(f'Connected. timeout={timeout} dt={dt:.1f}')
|
|
return
|
|
except Exception as e:
|
|
log(f'Failed to connect timeout={timeout} dt={dt:.1f}: {e}')
|
|
|
|
def waitfor(self, name, value, timeout=30):
|
|
'''
|
|
Waits for specified property to be <value>. Returns time taken.
|
|
'''
|
|
t0 = time.time()
|
|
while 1:
|
|
time.sleep(1)
|
|
dt = time.time() - t0
|
|
try:
|
|
v = self.fg[name]
|
|
log(f'Waiting for {name}={value} current value: {v}. timeout={timeout} dt={dt:.1f}')
|
|
except Exception as e:
|
|
log(f'Failed to get value of property {name}: {e}. timeout={timeout} dt={dt:.1f}')
|
|
v = None
|
|
if v == value:
|
|
return dt
|
|
if dt > timeout:
|
|
raise Exception(f'Timeout waiting for {name}={value}; current value: {v}. timeout={timeout}')
|
|
|
|
def run_command(self, command):
|
|
self.fg.telnet._putcmd(command)
|
|
ret = self.fg.telnet._getresp()
|
|
log(f'command={command!r} ret: {ret}')
|
|
return ret
|
|
|
|
def close(self):
|
|
assert self.child
|
|
log(f'close(): stopping flightgear pid={self.child.pid}')
|
|
if 1:
|
|
# Kill any child processes so that things work if fgfs is being run
|
|
# by download_and_compile.sh's run_fgfs.sh script.
|
|
#
|
|
# This is Unix-only.
|
|
try:
|
|
child_pids = subprocess.check_output(f'pgrep -P {self.child.pid}', shell=True)
|
|
except Exception:
|
|
# We get here if self.child has no child processes.
|
|
child_pids = b''
|
|
child_pids = child_pids.decode('utf-8')
|
|
child_pids = child_pids.split()
|
|
for child_pid in child_pids:
|
|
#log(f'*** close() child_pid={child_pid}')
|
|
child_pid = int(child_pid)
|
|
#log(f'*** close() killing child_pid={child_pid}')
|
|
os.kill(child_pid, signal.SIGTERM)
|
|
self.child.terminate()
|
|
self.child.wait()
|
|
self.child = None
|
|
#log(f'*** close() returning.')
|
|
|
|
def __del__(self):
|
|
if self.child:
|
|
log('*** Fg.__del__() calling self.close()')
|
|
self.close()
|
|
|
|
def make_recording(
|
|
fg,
|
|
continuous=0, # 2 means continuous with compression.
|
|
extra_properties=0,
|
|
main_view=0,
|
|
length=5,
|
|
):
|
|
'''
|
|
Makes a recording, and returns its path.
|
|
|
|
We check that the recording file is newly created.
|
|
'''
|
|
t = time.time()
|
|
fg.fg['/sim/replay/record-signals'] = True # Just in case they are disabled by user.
|
|
if continuous:
|
|
assert not fg.fg['/sim/replay/record-continuous']
|
|
if continuous == 2:
|
|
fg.fg['/sim/replay/record-continuous-compression'] = 1
|
|
fg.fg['/sim/replay/record-continuous'] = 1
|
|
t0 = time.time()
|
|
while 1:
|
|
if time.time() > t0 + length:
|
|
break
|
|
time.sleep(1)
|
|
fg.run_command('run view-step step=1')
|
|
fg.fg['/sim/replay/record-continuous'] = 0
|
|
path = f'{g_tapedir}/{fg.aircraft}-continuous.fgtape'
|
|
time.sleep(1)
|
|
else:
|
|
# Normal recording will have effectively already started, so we sleep
|
|
# for the remaining time. This is a little inaccurate though because it
|
|
# looks like normal recording starts a little after t=0, e.g. at t=0.5.
|
|
#
|
|
# Also, it looks like /sim/time/elapsed-sec doesn't quite track real
|
|
# time, so we sometimes need to sleep a little longer.
|
|
#
|
|
while 1:
|
|
# Telnet interface seems very slow even if we set telnet_hz to
|
|
# 100 (for example). We want to make recording have near to the
|
|
# specified length, so we are cautious about overrunning.
|
|
#
|
|
#log(f'a: time.time()-t={time.time()-t}')
|
|
t_record_begin = fg.fg['sim/replay/record-normal-begin']
|
|
#log(f'b: time.time()-t={time.time()-t}')
|
|
t_record_end = fg.fg['sim/replay/record-normal-end']
|
|
#log(f'c: time.time()-t={time.time()-t}')
|
|
t_delta = t_record_end - t_record_begin
|
|
log(f't_record_begin={t_record_begin} t_record_end={t_record_end} t_delta={t_delta}')
|
|
if t_delta >= length:
|
|
break
|
|
ts = max(length - t_delta - 1, 0.2)
|
|
log(f'd: ts={ts}')
|
|
time.sleep(ts)
|
|
log(f'/sim/time/elapsed-sec={t}')
|
|
log(f'/sim/replay/start-time={fg.fg["/sim/replay/start-time"]}')
|
|
log(f'/sim/replay/end-time={fg.fg["/sim/replay/end-time"]}')
|
|
fg.fg.telnet._putcmd('run save-tape tape-data/starttime= tape-data/stoptime=')
|
|
response = fg.fg.telnet._getresp()
|
|
log(f'response: {response!r}')
|
|
path = f'{g_tapedir}/{fg.aircraft}.fgtape'
|
|
|
|
# Check recording is new.
|
|
os.system(f'ls -lL {path}')
|
|
s = os.stat(path, follow_symlinks=True)
|
|
assert s.st_mtime > t
|
|
path2 = readlink(path)
|
|
log(f'path={path} path2={path2}')
|
|
return path
|
|
|
|
|
|
def test_record_replay(
|
|
fgfs_save,
|
|
fgfs_load,
|
|
multiplayer,
|
|
continuous,
|
|
extra_properties,
|
|
main_view,
|
|
length,
|
|
):
|
|
if not fgfs_load:
|
|
fgfs_load = fgfs_save
|
|
log(f'=== save: {fgfs_save}')
|
|
log(f'=== load: {fgfs_load}')
|
|
log(f'=== --multiplayer {multiplayer} --continuous {continuous} --extra-properties {extra_properties} --main-view {main_view}')
|
|
log(f'===')
|
|
|
|
aircraft = 'harrier-gr3'
|
|
args = f'--state=vto --airport=egtk'
|
|
args += f' --prop:bool:/sim/replay/record-extra-properties={extra_properties}'
|
|
args += f' --prop:bool:/sim/replay/record-main-view={main_view}'
|
|
args += f' --prop:bool:/sim/replay/record-main-window=0'
|
|
#args += f' --prop:bool:/sim/time/simple-time/enabled=0'
|
|
|
|
# Start Flightgear.
|
|
fg = Fg(aircraft, f'{fgfs_save} {args}',
|
|
#env='SG_LOG_DELTAS=flightgear/src/Network/props.cxx=4',
|
|
telnet_hz=100,
|
|
)
|
|
fg.waitfor('/sim/fdm-initialized', 1, timeout=45)
|
|
|
|
assert fg.fg['sim/replay/record-extra-properties'] == extra_properties
|
|
assert fg.fg['sim/replay/record-main-view'] == main_view
|
|
log(f'sim/replay/record-extra-properties={fg.fg["sim/replay/record-extra-properties"]}')
|
|
|
|
# Save recording:
|
|
path = make_recording(fg,
|
|
continuous=continuous,
|
|
extra_properties=extra_properties,
|
|
main_view=main_view,
|
|
length=length,
|
|
)
|
|
|
|
g_cleanup.append(lambda: remove(path))
|
|
fg.close()
|
|
|
|
# Load recording into new Flightgear.
|
|
path = f'{g_tapedir}/{aircraft}-continuous.fgtape' if continuous else f'{g_tapedir}/{aircraft}.fgtape'
|
|
fg = Fg(aircraft, f'{fgfs_load} {args} --load-tape={path}')
|
|
fg.waitfor('/sim/fdm-initialized', 1, timeout=45)
|
|
fg.waitfor('/sim/replay/replay-state', 1)
|
|
|
|
t0 = time.time()
|
|
|
|
# Check replay time is ok.
|
|
rtime_begin = fg.fg['/sim/replay/start-time']
|
|
rtime_end = fg.fg['/sim/replay/end-time']
|
|
rtime = rtime_end - rtime_begin
|
|
log(f'rtime={rtime_begin}..{rtime_end}, recording length: {rtime}, length={length}')
|
|
assert rtime > length-1 and rtime <= length+2, \
|
|
f'length={length} rtime_begin={rtime_begin} rtime_end={rtime_end} rtime={rtime}'
|
|
|
|
num_frames_extra_properties = fg.fg['/sim/replay/continuous-stats-num-frames-extra-properties']
|
|
log(f'num_frames_extra_properties={num_frames_extra_properties}')
|
|
if continuous:
|
|
if main_view:
|
|
assert num_frames_extra_properties > 1, f'num_frames_extra_properties={num_frames_extra_properties}'
|
|
else:
|
|
assert num_frames_extra_properties == 0
|
|
else:
|
|
assert num_frames_extra_properties in (0, None), \
|
|
f'num_frames_extra_properties={num_frames_extra_properties}'
|
|
|
|
fg.run_command('run dialog-show dialog-name=replay')
|
|
|
|
while 1:
|
|
t = time.time()
|
|
if t < t0 + length - 1:
|
|
pass
|
|
# Disabled because it seems that Flightgear starts replaying before
|
|
# we see replay-state set to 1 because scenery loading blocks
|
|
# things.
|
|
#
|
|
#assert not fg.fg['/sim/replay/replay-state-eof'], f'Replay has finished too early; lenth={length} t-t0={t-t0}'
|
|
if t > t0 + length + 1:
|
|
assert fg.fg['/sim/replay/replay-state-eof'], f'Replay has not finished on time; lenth={length} t-t0={t-t0}'
|
|
break
|
|
e = fg.fg['sim/replay/replay-error']
|
|
assert not e, f'Replay failed: e={e}'
|
|
time.sleep(1)
|
|
|
|
fg.close()
|
|
|
|
remove(path)
|
|
|
|
log('Test passed')
|
|
|
|
|
|
def test_motion(fgfs, multiplayer=False):
|
|
'''
|
|
Records UFO moving with constant velocity with varying framerates, then
|
|
replays with varying framerates and checks that replayed UFO moves with
|
|
expected constant speed.
|
|
|
|
If <multiplayer> is true we also record MP UFO running in second Flightgear
|
|
instance and check that it too moves at constant speed when replaying.
|
|
'''
|
|
log('')
|
|
log('='*80)
|
|
log('== Record')
|
|
|
|
aircraft = 'ufo'
|
|
fgfs += ' --prop:bool:/sim/time/simple-time/enabled=true'
|
|
if multiplayer:
|
|
fg = Fg( aircraft, f'{fgfs} --prop:/sim/replay/log-raw-speed-multiplayer=cgdae-t')
|
|
else:
|
|
fg = Fg( aircraft, f'{fgfs}')
|
|
path = f'{g_tapedir}/{fg.aircraft}-continuous.fgtape'
|
|
|
|
fg.waitfor('/sim/fdm-initialized', 1, timeout=45)
|
|
|
|
fg.fg['/controls/engines/engine[0]/throttle'] = 0
|
|
|
|
# Throttle/speed for ufo is set in fgdata/Aircraft/ufo/ufo.nas.
|
|
#
|
|
speed_max = 2000 # default for ufo; current=7.
|
|
fixed_speed = 100
|
|
throttle = fixed_speed / speed_max
|
|
|
|
if multiplayer:
|
|
fg.fg['/sim/replay/record-multiplayer'] = True
|
|
fg2 = Fg( aircraft, f'{fgfs} --callsign=cgdae-t --multiplay=in,4,,5033 --read-only', telnet_port=5501)
|
|
fg2.waitfor('/sim/fdm-initialized', 1, timeout=45)
|
|
fg.fg['/controls/engines/engine[0]/throttle'] = throttle
|
|
fg2.fg['/controls/engines/engine[0]/throttle'] = throttle
|
|
time.sleep(1)
|
|
fgt = fg.fg['/controls/engines/engine[0]/throttle']
|
|
fg2t = fg2.fg['/controls/engines/engine[0]/throttle']
|
|
log(f'fgt={fgt} fg2t={fg2t}')
|
|
else:
|
|
fg.fg['/controls/engines/engine[0]/throttle'] = throttle
|
|
|
|
# Run UFO with constant speed, varying the framerate so we check whether
|
|
# recorded speeds are affected.
|
|
#
|
|
fg.fg['/sim/frame-rate-throttle-hz'] = 5
|
|
if multiplayer:
|
|
fg2.fg['/sim/frame-rate-throttle-hz'] = 5
|
|
|
|
# Delay to let frame rate settle.
|
|
time.sleep(10)
|
|
|
|
# Start recording.
|
|
fg.fg['/sim/replay/record-continuous'] = 1
|
|
time.sleep(5)
|
|
|
|
# Change frame rate.
|
|
fg.fg['/sim/frame-rate-throttle-hz'] = 2
|
|
time.sleep(5)
|
|
|
|
# Change frame rate.
|
|
fg.fg['/sim/frame-rate-throttle-hz'] = 5
|
|
if multiplayer:
|
|
fg2.fg['/sim/frame-rate-throttle-hz'] = 2
|
|
time.sleep(5)
|
|
|
|
# Stop recording.
|
|
fg.fg['/sim/replay/record-continuous'] = 0
|
|
|
|
fg.close()
|
|
if multiplayer:
|
|
fg2.close()
|
|
time.sleep(2)
|
|
|
|
path2 = readlink( path)
|
|
log(f'*** path={path} path2={path2}')
|
|
g_cleanup.append(lambda: remove(path2))
|
|
|
|
log('')
|
|
log('='*80)
|
|
log('== Replay')
|
|
|
|
if multiplayer:
|
|
fg = Fg( aircraft, f'{fgfs} --load-tape={path}'
|
|
f' --prop:/sim/replay/log-raw-speed-multiplayer=cgdae-t'
|
|
f' --prop:/sim/replay/log-raw-speed=true'
|
|
)
|
|
else:
|
|
fg = Fg( aircraft,
|
|
f'{fgfs} --load-tape={path} --prop:/sim/replay/log-raw-speed=true',
|
|
#env='SG_LOG_DELTAS=flightgear/src/Aircraft/flightrecorder.cxx:replay=3',
|
|
)
|
|
fg.waitfor('/sim/fdm-initialized', 1, timeout=45)
|
|
fg.fg['/sim/frame-rate-throttle-hz'] = 10
|
|
fg.waitfor('/sim/replay/replay-state', 1)
|
|
|
|
time.sleep(3)
|
|
fg.fg['/sim/frame-rate-throttle-hz'] = 2
|
|
time.sleep(5)
|
|
fg.fg['/sim/frame-rate-throttle-hz'] = 5
|
|
time.sleep(3)
|
|
fg.fg['/sim/frame-rate-throttle-hz'] = 7
|
|
|
|
fg.waitfor('/sim/replay/replay-state-eof', 1)
|
|
|
|
errors = []
|
|
def examine_values(infix=''):
|
|
'''
|
|
Looks at /sim/replay/log-raw-speed{infix}-values/value[], which will
|
|
contain measured speed of user/MP UFO. We check that the values are all
|
|
as expected - constant speed.
|
|
'''
|
|
log(f'== Looking at /sim/replay/log-raw-speed{infix}-values/value[]')
|
|
items0 = fg.fg.ls( f'/sim/replay/log-raw-speed{infix}-values')
|
|
log(f'{infix} len(items0)={len(items0)}')
|
|
assert items0, f'Failed to read items in /sim/replay/log-raw-speed{infix}-values/'
|
|
items = []
|
|
descriptions = []
|
|
for item in items0:
|
|
if item.name == 'value':
|
|
#log(f'have read item: {item}')
|
|
items.append(item)
|
|
elif item.name == 'description':
|
|
descriptions.append(item)
|
|
num_errors = 0
|
|
for i in range(len(items)-1): # Ignore last item because replay at end interpolates.
|
|
item = items[i]
|
|
description = ''
|
|
if i < len(descriptions):
|
|
description = descriptions[i].value
|
|
speed = float(item.value)
|
|
prefix = ' '
|
|
if abs(speed - fixed_speed) > 0.1:
|
|
num_errors += 1
|
|
prefix = '*'
|
|
log( f' {infix} {prefix} speed={speed:12.4} details: {item}: {description}')
|
|
if num_errors != 0:
|
|
log( f'*** Replay showed uneven speed')
|
|
errors.append('1')
|
|
|
|
def show_values(paths):
|
|
if isinstance(paths, str):
|
|
paths = paths,
|
|
log(f'Values in {paths}:')
|
|
line2values = dict()
|
|
for i, path in enumerate(paths):
|
|
line = 0
|
|
for item in fg.fg.ls(path):
|
|
if item.name == 'value':
|
|
line2values.setdefault(line, []).append(item.value)
|
|
line += 1
|
|
for line in sorted(line2values.keys()):
|
|
t = ''
|
|
for value in line2values[line]:
|
|
t += f' {value}'
|
|
log(f' {t}')
|
|
|
|
if multiplayer:
|
|
examine_values()
|
|
examine_values('-multiplayer')
|
|
examine_values('-multiplayer-post')
|
|
|
|
if 0:
|
|
show_values('/sim/replay/log-raw-speed-multiplayer-post-relative-distance')
|
|
show_values('/sim/replay/log-raw-speed-multiplayer-post-relative-bearing')
|
|
show_values('/sim/replay/log-raw-speed-multiplayer-post-absolute-distance')
|
|
show_values('/sim/replay/log-raw-speed-multiplayer-post-user-absolute-distance')
|
|
|
|
def get_values(path):
|
|
'''
|
|
Returns <path>/value[] as a list.
|
|
'''
|
|
ret = []
|
|
for item in fg.fg.ls(path):
|
|
if item.name == 'value':
|
|
ret.append(item.value)
|
|
return ret
|
|
|
|
# Check that distance between user and mp is constant.
|
|
#
|
|
# The two paths below contain values[] that are the distances of the
|
|
# mp and user aircraft from their starting points. Both are moving at
|
|
# the same speed in the same direction, so the differences between each
|
|
# pair of values should be constant.
|
|
#
|
|
distances_mp = get_values('/sim/replay/log-raw-speed-multiplayer-post-absolute-distance')
|
|
distances_user = get_values('/sim/replay/log-raw-speed-multiplayer-post-user-absolute-distance')
|
|
log(f'len(distances_user)={len(distances_user)} len(distances_mp)={len(distances_mp)}')
|
|
assert len(distances_user) == len(distances_mp)
|
|
assert len(distances_user) > 20
|
|
for i in range(len(distances_user)):
|
|
distance_mp = distances_mp[i]
|
|
distance_user = distances_user[i]
|
|
delta = distance_mp - distance_user
|
|
if i == 0:
|
|
delta_original = delta
|
|
prefix = ' '
|
|
if abs(delta - delta_original) > 0.01:
|
|
#log('replay shows varying differences between user and mp aircraft')
|
|
errors.append('1')
|
|
prefix = '*'
|
|
log(f' {prefix} user={distance_user} mp={distance_mp} delta={delta}')
|
|
else:
|
|
examine_values()
|
|
|
|
fg.close()
|
|
if errors:
|
|
raise Exception('Failure')
|
|
|
|
log('test_motion() passed')
|
|
|
|
|
|
def test_carrier(fgfs):
|
|
'''
|
|
Checks that mp carrier motion is even.
|
|
'''
|
|
# We require simple-time. Can probably also work by setting the default
|
|
# timing system's lag parameters but haven't figured this out yet.
|
|
#
|
|
simple_time = 'true'
|
|
fg = Fg( 'harrier-gr3',
|
|
f'{fgfs} --prop:int:/sim/mp-carriers/latch-always=1 --prop:bool:/sim/time/simple-time/enabled={simple_time} --callsign=cgdae3 --airport=ksfo',
|
|
telnet_port=5500,
|
|
telnet_hz=100,
|
|
#out='out-rr-carrier-1',
|
|
)
|
|
fg.waitfor('/sim/fdm-initialized', 1, timeout=45)
|
|
|
|
fg_carrier = Fg('Nimitz',
|
|
f'{fgfs} --prop:int:/sim/mp-carriers/latch-always=1 --prop:bool:/sim/time/simple-time/enabled={simple_time} --callsign=cgdae4 --multiplay=in,1,,5033 --read-only',
|
|
telnet_port=5501,
|
|
#out='out-rr-carrier-2',
|
|
)
|
|
fg_carrier.waitfor('/sim/fdm-initialized', 1, timeout=45)
|
|
|
|
fg.fg['/sim/replay/log-raw-speed-multiplayer'] = 'cgdae4'
|
|
fg.fg['/sim/log-multiplayer-callsign'] = 'cgdae4'
|
|
|
|
def get_items(path, leafname, out=None):
|
|
'''
|
|
Finds list of tuples from properties <path>/<leafname>[]/*. Appends new
|
|
items to <out> and returns new items.
|
|
|
|
Runs rather slowly because telnet commands appear to be throttled.
|
|
'''
|
|
if out is None:
|
|
out = []
|
|
out_len_original = len(out)
|
|
items = fg.fg.ls(path)
|
|
i = 0
|
|
for item_i, item in enumerate(items):
|
|
if item.name == leafname:
|
|
if i == len(out):
|
|
#print(f'len(items)={len(items)} item_i={item_i}: looking at {path}/{leafname}[{item.index}]')
|
|
class Item:
|
|
pass
|
|
item2 = Item()
|
|
item2.i = i
|
|
for j in fg.fg.ls(f'{path}/{leafname}[{item.index}]'):
|
|
setattr( item2, j.name, j)
|
|
out.append(item2)
|
|
i += 1
|
|
return out[out_len_original:]
|
|
|
|
t0 = time.time()
|
|
mps = []
|
|
mppackets = []
|
|
while 1:
|
|
time.sleep(1)
|
|
t = time.time() - t0
|
|
log(f'test_carrier(): t={t:.1f}')
|
|
if t > 60:
|
|
print(f'finished, t={t}')
|
|
break
|
|
mps_new = get_items( '/sim/log-multiplayer', 'mp', mps)
|
|
mppackets_new = get_items( '/sim/log-multiplayer', 'mppacket', mppackets)
|
|
for mp in mps_new:
|
|
log(f'test_carrier(): mp: i={mp.i}:'
|
|
f' speed={mp.speed.value:20}'
|
|
f' distance={mp.distance.value:20}'
|
|
f' t={mp.t.value:20}'
|
|
f' dt={mp.dt.value:20}={mp.dt.value*120:20}/120'
|
|
f' ubody={mp.ubody.value:20}'
|
|
f' vbody={mp.vbody.value:20}'
|
|
f' wbody={mp.wbody.value:20}'
|
|
)
|
|
for mppacket in mppackets_new:
|
|
log(f'test_carrier(): mppacket: i={mppacket.i}:'
|
|
f' speed={mppacket.speed.value:20}'
|
|
f' distance={mppacket.distance.value:20}'
|
|
f' t={mppacket.t.value:20}'
|
|
f' linear_vel={mppacket.linear_vel.value:20}'
|
|
f' dt={mppacket.dt.value:20}={mppacket.dt.value*120:20}/120'
|
|
)
|
|
|
|
# Check speed of multiplayer carrier is constant:
|
|
knots2si = 1852.0/3600
|
|
speed_expected = 10 * knots2si
|
|
num_incorrect = 0
|
|
for mp in mps[2:]: # First two items have bogus values.
|
|
delta = mp.speed.value - speed_expected
|
|
if abs(delta) > 0.001:
|
|
num_incorrect += 1
|
|
print(f' * speed={mp.speed.value:20}')
|
|
assert num_incorrect == 0, f'num_incorrect={num_incorrect}'
|
|
fg.close()
|
|
fg_carrier.close()
|
|
|
|
if __name__ == '__main__':
|
|
|
|
fgfs = f'./build-walk/fgfs.exe-run.sh'
|
|
fgfs_old = None
|
|
|
|
do_test = 'all'
|
|
continuous_s = [0, 1, 2] # 2 is continuous with compression.
|
|
extra_properties_s = [0, 1]
|
|
main_view_s = [0, 1]
|
|
multiplayer_s = [0, 1]
|
|
fgfs_reverse_s = [0]
|
|
it_min = None
|
|
it_max = None
|
|
|
|
if len(sys.argv) == 1:
|
|
do_all = True
|
|
|
|
args = iter(sys.argv[1:])
|
|
while 1:
|
|
try:
|
|
arg = next(args)
|
|
except StopIteration:
|
|
break
|
|
if arg == '--all':
|
|
do_all = True
|
|
elif arg == '--carrier':
|
|
do_test = 'carrier'
|
|
elif arg == '--continuous':
|
|
continuous_s = [int(x) for x in next(args).split(',')]
|
|
log(f'continuous_s={continuous_s}')
|
|
elif arg == '--tape-dir':
|
|
g_tapedir = next(args)
|
|
elif arg == '--extra-properties':
|
|
extra_properties_s = [int(x) for x in next(args).split(',')]
|
|
elif arg == '--it-max':
|
|
it_max = int(next(args))
|
|
elif arg == '--it-min':
|
|
it_min = int(next(args))
|
|
elif arg == '--main-view':
|
|
main_view_s = [int(x) for x in next(args).split(',')]
|
|
elif arg == '--multiplayer':
|
|
multiplayer_s = [int(x) for x in next(args).split(',')]
|
|
elif arg == '-f':
|
|
fgfs = next(args)
|
|
elif arg == '--f-old':
|
|
fgfs_old = next(args)
|
|
fgfs_reverse = [0, 1]
|
|
elif arg == '--test-motion':
|
|
do_test = 'motion'
|
|
elif arg == '--test-motion-mp':
|
|
do_test = 'motion-mp'
|
|
else:
|
|
raise Exception(f'Unrecognised arg: {arg!r}')
|
|
|
|
g_tapedir = os.path.abspath(g_tapedir)
|
|
os.makedirs( g_tapedir, exist_ok=True)
|
|
if 0:
|
|
pass
|
|
elif do_test == 'carrier':
|
|
test_carrier(fgfs)
|
|
elif do_test == 'motion':
|
|
test_motion( fgfs)
|
|
elif do_test == 'motion-mp':
|
|
test_motion( fgfs, True)
|
|
elif do_test == 'all':
|
|
try:
|
|
if fgfs_old:
|
|
for fgfs1, fgfs2 in [(fgfs, fgfs_old), (fgfs_old, fgfs)]:
|
|
for multiplayer in 0, 1:
|
|
test_record_replay(
|
|
fgfs1,
|
|
fgfs2,
|
|
multiplayer,
|
|
continuous=0,
|
|
extra_properties=0,
|
|
main_view=0,
|
|
length=10,
|
|
)
|
|
else:
|
|
log(f'continuous_s={continuous_s}')
|
|
its_max = len(multiplayer_s) * len(continuous_s) * len(extra_properties_s) * len(main_view_s) * len(fgfs_reverse_s)
|
|
it = 0
|
|
for multiplayer in multiplayer_s:
|
|
for continuous in continuous_s:
|
|
for extra_properties in extra_properties_s:
|
|
for main_view in main_view_s:
|
|
for fgfs_reverse in fgfs_reverse_s:
|
|
if fgfs_reverse:
|
|
fgfs_save = fgfs_old
|
|
fgfs_load = fgfs
|
|
else:
|
|
fgfs_save = fgfs
|
|
fgfs_load = fgfs_old
|
|
|
|
ok = True
|
|
if it_min is not None:
|
|
if it < it_min:
|
|
ok = False
|
|
if it_max is not None:
|
|
if it >= it_max:
|
|
ok = False
|
|
log('')
|
|
log(f'===')
|
|
log(f'=== {it}/{its_max}')
|
|
if ok:
|
|
test_record_replay(
|
|
fgfs_save,
|
|
fgfs_load,
|
|
multiplayer=multiplayer,
|
|
continuous=continuous,
|
|
extra_properties=extra_properties,
|
|
main_view=main_view,
|
|
length=10
|
|
)
|
|
it += 1
|
|
finally:
|
|
pass
|
|
else:
|
|
assert 0, f'do_test={do_test}'
|
|
|
|
# If everything passed, cleanup. Otherwise leave recordings in place, as
|
|
# they can be useful for debugging.
|
|
#
|
|
for f in g_cleanup:
|
|
try:
|
|
f()
|
|
except Exception:
|
|
pass
|
|
|
|
log(f'{__file__}: Returning 0')
|