102 lines
4.0 KiB
Python
102 lines
4.0 KiB
Python
from unittest.mock import Mock
|
|
from target_simulator.simulation.simulation_controller import SimulationController
|
|
|
|
class DummyComm:
|
|
def __init__(self, use_json=False, send_results=None):
|
|
self.is_open = True
|
|
self._use_json_protocol = use_json
|
|
self._send_calls = []
|
|
self._send_results = send_results
|
|
|
|
def send_commands(self, cmds):
|
|
print('DummyComm.send_commands called with', cmds)
|
|
self._send_calls.append(cmds)
|
|
if callable(self._send_results):
|
|
return self._send_results(cmds)
|
|
if isinstance(self._send_results, list):
|
|
if len(self._send_results) >= len(self._send_calls):
|
|
return self._send_results[len(self._send_calls) - 1]
|
|
return self._send_results[-1]
|
|
return True
|
|
|
|
def send_scenario(self, scenario):
|
|
print('DummyComm.send_scenario called')
|
|
return True
|
|
|
|
def router(self):
|
|
return None
|
|
|
|
class DummyCommManager:
|
|
def __init__(self, target_comm=None):
|
|
self.target_communicator = target_comm
|
|
|
|
class DummyHub:
|
|
def __init__(self, active_sequence=None):
|
|
self._seq = list(active_sequence) if active_sequence is not None else []
|
|
def has_active_real_targets(self):
|
|
if self._seq:
|
|
return self._seq.pop(0)
|
|
return False
|
|
def reset(self): pass
|
|
def get_ownship_state(self): return {}
|
|
def set_simulation_origin(self, origin): pass
|
|
|
|
class DummyScenario:
|
|
def __init__(self):
|
|
class T:
|
|
_total_duration_s = 5.0
|
|
self.targets=[T()]
|
|
self.name='dummy'
|
|
def get_all_targets(self): return self.targets
|
|
def reset_simulation(self): pass
|
|
|
|
class DummyMainView:
|
|
def __init__(self):
|
|
self.is_simulation_running = type('V', (), {'get': lambda s: False, 'set': lambda s,v: print('is_simulation_running.set', v)})()
|
|
self.update_time = type('V', (), {'get': lambda s: 1.0})()
|
|
self.time_multiplier = 1.0
|
|
self.scenario = DummyScenario()
|
|
self.ppi_widget = type('P', (), {'clear_trails': lambda s: None, 'clear_previews': lambda s: None})()
|
|
self.sim_slider_var = type('V', (), {'get': lambda s: 0.0, 'set': lambda s,v: None})()
|
|
self.simulation_engine = None
|
|
self.current_archive = None
|
|
self._start_in_progress_main = False
|
|
self.simulation_controls = type('C', (), {'sim_slider_var': type('V', (), {'set': lambda s,v: None})(), 'show_notice': lambda *a, **k: None})()
|
|
def _update_simulation_progress_display(self): pass
|
|
def _update_button_states(self): pass
|
|
def _refresh_analysis_list(self): pass
|
|
def show_status_message(self, text, timeout_ms=None): print('show_status_message', text)
|
|
def after(self, delay_ms, func, *args, **kwargs): return func(*args, **kwargs)
|
|
def clear_status_message(self): pass
|
|
|
|
# patch SimulationEngine used in controller
|
|
class DummyEngine:
|
|
def __init__(self, communicator=None, simulation_hub=None):
|
|
self.started=False
|
|
def set_time_multiplier(self,v): pass
|
|
def set_update_interval(self,v): pass
|
|
def load_scenario(self,s): print('engine.load_scenario')
|
|
def start(self): print('engine.start called'); self.started=True
|
|
def stop(self): self.started=False
|
|
def is_running(self): return self.started
|
|
|
|
import target_simulator.simulation.simulation_controller as scmod
|
|
scmod.SimulationEngine = DummyEngine
|
|
|
|
comm = DummyComm(use_json=False, send_results=[True])
|
|
cm = DummyCommManager(comm)
|
|
hub = DummyHub()
|
|
controller = SimulationController(cm, hub, config_manager=None, logger=Mock())
|
|
mv = DummyMainView()
|
|
print('Calling reset directly...')
|
|
ok = controller._reset_radar_state_no_ui(mv)
|
|
print('reset returned', ok)
|
|
print('comm._send_calls after reset =', comm._send_calls)
|
|
|
|
print('\nNow calling start_simulation...')
|
|
controller.start_simulation(mv)
|
|
print('after start, mv.simulation_engine =', mv.simulation_engine)
|
|
if mv.simulation_engine:
|
|
print('engine.is_running()', mv.simulation_engine.is_running())
|
|
print('comm._send_calls final =', comm._send_calls)
|