def test_gdb(board_id=None, n=0):
temp_test_elf_name = None
result = GdbTestResult()
with ConnectHelper.session_with_chosen_probe(unique_id=board_id, **get_session_options()) as session:
board = session.board
memory_map = board.target.get_memory_map()
ram_region = memory_map.get_default_region_of_type(MemoryType.RAM)
rom_region = memory_map.get_boot_memory()
target_type = board.target_type
binary_file = get_test_binary_path(board.test_binary)
if board_id is None:
board_id = board.unique_id
target_test_params = get_target_test_params(session)
test_port = 3333 + n
telnet_port = 4444 + n
# Hardware breakpoints are not supported above 0x20000000 on
# Cortex-M devices with FPB revision 1.
fpb = session.target.selected_core.fpb
assert fpb is not None
ignore_hw_bkpt_result = int(fpb.revision == 1 and ram_region.start >= 0x20000000)
# Program with initial test image
FileProgrammer(session).program(binary_file, base_address=rom_region.start)
# Generate an elf from the binary test file.
temp_test_elf_name = binary_to_elf_file(binary_file, rom_region.start)
# Write out the test configuration
test_params = {
"test_port" : test_port,
"rom_start" : rom_region.start,
"rom_length" : rom_region.length,
"ram_start" : ram_region.start,
"ram_length" : ram_region.length,
"invalid_start" : 0x3E000000,
"invalid_length" : 0x1000,
"expect_error_on_invalid_access" : target_test_params['error_on_invalid_access'],
"ignore_hw_bkpt_result" : ignore_hw_bkpt_result,
"test_elf" : temp_test_elf_name,
}
test_param_filename = os.path.join(TEST_OUTPUT_DIR, "gdb_test_params%s_%d.txt" % (get_env_file_name(), n))
with open(test_param_filename, "w") as f:
f.write(json.dumps(test_params))
# Remove result from previous run.
test_result_filename = os.path.join(TEST_OUTPUT_DIR, "gdb_test_results%s_%d.txt" % (get_env_file_name(), n))
if os.path.exists(test_result_filename):
os.remove(test_result_filename)
# Run the test
gdb_args = [PYTHON_GDB, "--nh", "-ex", "set $testn=%d" % n, "--command=%s" % GDB_SCRIPT_PATH]
gdb_output_filename = os.path.join(TEST_OUTPUT_DIR, "gdb_output%s_%s_%d.txt" % (get_env_file_name(), board.target_type, n))
with open(gdb_output_filename, "w") as f:
LOG.info('Starting gdb (stdout -> %s): %s', gdb_output_filename, ' '.join(gdb_args))
gdb_program = Popen(gdb_args, stdin=PIPE, stdout=f, stderr=STDOUT)
server_args = ['gdbserver',
'--port=%i' % test_port,
"--telnet-port=%i" % telnet_port,
"--frequency=%i" % target_test_params['test_clock'],
"--uid=%s" % board_id,
]
server = PyOCDTool()
server._setup_logging = lambda: None # Disable logging setup so we don't have duplicate log output.
LOG.info('Starting gdbserver: %s', ' '.join(server_args))
server_thread = threading.Thread(target=server.run, args=[server_args])
server_thread.daemon = True
server_thread.start()
LOG.info('Waiting for gdb to finish...')
did_complete = wait_with_deadline(gdb_program, TEST_TIMEOUT_SECONDS)
if not did_complete:
LOG.error("Test timed out!")
LOG.info('Waiting for server to finish...')
server_thread.join(timeout=SERVER_EXIT_TIMEOUT)
if server_thread.is_alive():
LOG.error('Server is still running! Stopping now... and failing test')
did_complete = False
session = Session.get_current()
LOG.info(f"gdbserver session: {session}")
LOG.info(f"gdbservers: {session.gdbservers}")
for g in session.gdbservers.values():
g.stop()
# Wait again for server thread to complete now that the gdbservers are stopped.
server_thread.join(timeout=SERVER_EXIT_TIMEOUT)
if server_thread.is_alive():
# The server thread is _still_ alive. Not much we can do at this point. Any tests run
# past this point will likely fail.
LOG.error("Server thread is still alive after stopping gdbservers!")
try:
with open(gdb_output_filename, 'r') as f:
LOG.debug('Gdb output:\n%s', f.read())
except IOError:
pass
# Read back the result
result.passed = False
if did_complete:
try:
with open(test_result_filename, "r") as f:
test_result = json.loads(f.read())
# Print results
if set(TEST_RESULT_KEYS).issubset(test_result):
print("----------------Test Results----------------")
print("HW breakpoint count: %s" % test_result["breakpoint_count"])
print("Watchpoint count: %s" % test_result["watchpoint_count"])
print("Average instruction step time: %s" %
test_result["step_time_si"])
print("Average single step time: %s" % test_result["step_time_s"])
print("Average over step time: %s" % test_result["step_time_n"])
print("Failure count: %i" % test_result["fail_count"])
result.passed = test_result["fail_count"] == 0
except IOError as err:
LOG.error("Error reading test results: %s", err, exc_info=True)
if result.passed:
print("GDB TEST PASSED")
else:
print("GDB TEST FAILED")
# Cleanup
try:
if temp_test_elf_name and os.path.exists(temp_test_elf_name):
os.remove(temp_test_elf_name)
os.remove(test_result_filename)
os.remove(test_param_filename)
except IOError as err:
pass
return result
def test_probeserver(board_id=None, n=0):
test_port = 5555 + n
temp_test_elf_name = None
result = ProbeserverTestResult()
print("Connecting to identify target")
with ConnectHelper.session_with_chosen_probe(
unique_id=board_id, **get_session_options()) as session:
board = session.board
target_test_params = get_target_test_params(session)
binary_file = get_test_binary_path(board.test_binary)
if board_id is None:
board_id = board.unique_id
target_type = board.target_type
# Run the test. We can't kill the server thread, so
LOG.info('Starting server on port %d', test_port)
server_args = [
'pyocd',
'server',
'-v',
'--port=%i' % test_port,
"--uid=%s" % board_id,
]
server_program = Popen(server_args, stdout=PIPE, stderr=STDOUT)
try:
# Read server output waiting for it to report that the server is running.
with Timeout(TEST_TIMEOUT_SECONDS) as time_out:
while time_out.check():
ln = server_program.stdout.readline().decode('ascii')
print("Server:", ln, end='')
if "Serving debug probe" in ln:
break
if ln == '':
raise TestError("no more output from server")
else:
raise TestError("server failed to start")
server_thread = threading.Thread(
target=wait_with_deadline,
args=[server_program, TEST_TIMEOUT_SECONDS])
server_thread.daemon = True
server_thread.start()
# Start client in a thread.
client_args = [
'flash',
"--frequency=%i" % target_test_params['test_clock'],
"--uid=remote:localhost:%d" % test_port,
"--target=%s" % target_type, binary_file
]
client = PyOCDTool()
client._setup_logging = lambda: None # Disable logging setup so we don't have duplicate log output.
LOG.info('Starting client: %s', ' '.join(client_args))
client_thread = threading.Thread(target=client.run, args=[client_args])
client_thread.daemon = True
client_thread.start()
LOG.info('Waiting for client to finish...')
client_thread.join(timeout=TEST_TIMEOUT_SECONDS)
did_complete = not client_thread.is_alive()
if not did_complete:
LOG.error("Test timed out!")
LOG.info("killing probe server process")
server_program.kill()
except TestError as err:
LOG.info("test failed: %s", err)
did_complete = False
if server_program.returncode is None:
server_program.kill()
# Read back the result
result.passed = did_complete
if result.passed:
print("PROBESERVER TEST PASSED")
else:
print("PROBESERVER TEST FAILED")
return result