29     def test_thread_suffix_supported(self):  argument
30         server = self.connect_to_debug_monitor()
31         self.assertIsNotNone(server)
33         self.do_handshake()
34         self.test_sequence.add_log_lines(
39         self.expect_gdbremote_sequence()
42     def test_list_threads_in_stop_reply_supported(self):  argument
43         server = self.connect_to_debug_monitor()
44         self.assertIsNotNone(server)
46         self.do_handshake()
47         self.test_sequence.add_log_lines(
51         self.expect_gdbremote_sequence()
53     def test_c_packet_works(self):  argument
54         self.build()
55         procs = self.prep_debug_monitor_and_inferior()
56         self.test_sequence.add_log_lines(
61         self.expect_gdbremote_sequence()
64     def test_inferior_print_exit(self):  argument
65         self.build()
66         procs = self.prep_debug_monitor_and_inferior(
68         self.test_sequence.add_log_lines(
70              {"type": "output_match", "regex": self.maybe_strict_output_regex(r"hello, world\r\n")},
74         context = self.expect_gdbremote_sequence()
75         self.assertIsNotNone(context)
77     def test_first_launch_stop_reply_thread_matches_first_qC(self):  argument
78         self.build()
79         procs = self.prep_debug_monitor_and_inferior()
80         self.test_sequence.add_log_lines(["read packet: $qC#00",
89         context = self.expect_gdbremote_sequence()
90         self.assertEqual(context.get("thread_id_QC"), context.get("thread_id_?"))
92     def test_attach_commandline_continue_app_exits(self):  argument
93         self.build()
94         self.set_inferior_startup_attach()
95         procs = self.prep_debug_monitor_and_inferior()
96         self.test_sequence.add_log_lines(
100         self.expect_gdbremote_sequence()
109             self.assertIsNotNone(poll_result)
113         self.assertFalse(
117     def test_qRegisterInfo_returns_one_valid_result(self):  argument
118         self.build()
119         self.prep_debug_monitor_and_inferior()
120         self.test_sequence.add_log_lines(
126         context = self.expect_gdbremote_sequence()
127         self.assertIsNotNone(context)
130         self.assertIsNotNone(reg_info_packet)
131         self.assert_valid_reg_info(
134     def test_qRegisterInfo_returns_all_valid_results(self):  argument
135         self.build()
136         self.prep_debug_monitor_and_inferior()
137         self.add_register_info_collection_packets()
140         context = self.expect_gdbremote_sequence()
141         self.assertIsNotNone(context)
144         for reg_info in self.parse_register_info_packets(context):
145             self.assert_valid_reg_info(reg_info)
147     def test_qRegisterInfo_contains_required_generics_debugserver(self):  argument
148         self.build()
149         self.prep_debug_monitor_and_inferior()
150         self.add_register_info_collection_packets()
153         context = self.expect_gdbremote_sequence()
154         self.assertIsNotNone(context)
157         reg_infos = self.parse_register_info_packets(context)
164         self.assertIn('pc', generic_regs)
167         if self.getArchitecture() != 'powerpc64le':
168             self.assertIn('fp', generic_regs)
171         self.assertIn('sp', generic_regs)
174         self.assertIn('flags', generic_regs)
176     def test_qRegisterInfo_contains_at_least_one_register_set(self):  argument
177         self.build()
178         self.prep_debug_monitor_and_inferior()
179         self.add_register_info_collection_packets()
182         context = self.expect_gdbremote_sequence()
183         self.assertIsNotNone(context)
186         reg_infos = self.parse_register_info_packets(context)
191         self.assertTrue(len(register_sets) >= 1)
193     def targetHasAVX(self):  argument
194         triple = self.dbg.GetSelectedPlatform().GetTriple()
202             self.runCmd('platform get-file "/proc/cpuinfo" "cpuinfo"')
204             self.addTearDownHook(lambda: os.unlink("cpuinfo"))
216     def test_qRegisterInfo_contains_avx_registers(self):  argument
217         self.build()
218         self.prep_debug_monitor_and_inferior()
219         self.add_register_info_collection_packets()
222         context = self.expect_gdbremote_sequence()
223         self.assertIsNotNone(context)
226         reg_infos = self.parse_register_info_packets(context)
231         self.assertEqual(
232             self.targetHasAVX(),
235     def qThreadInfo_contains_thread(self):  argument
236         procs = self.prep_debug_monitor_and_inferior()
237         self.add_threadinfo_collection_packets()
240         context = self.expect_gdbremote_sequence()
241         self.assertIsNotNone(context)
244         threads = self.parse_threadinfo_packets(context)
245         self.assertIsNotNone(threads)
248         self.assertEqual(len(threads), 1)
250     def test_qThreadInfo_contains_thread_launch(self):  argument
251         self.build()
252         self.set_inferior_startup_launch()
253         self.qThreadInfo_contains_thread()
256     def test_qThreadInfo_contains_thread_attach(self):  argument
257         self.build()
258         self.set_inferior_startup_attach()
259         self.qThreadInfo_contains_thread()
261     def qThreadInfo_matches_qC(self):  argument
262         procs = self.prep_debug_monitor_and_inferior()
264         self.add_threadinfo_collection_packets()
265         self.test_sequence.add_log_lines(
271         context = self.expect_gdbremote_sequence()
272         self.assertIsNotNone(context)
275         threads = self.parse_threadinfo_packets(context)
276         self.assertIsNotNone(threads)
279         self.assertEqual(len(threads), 1)
283         self.assertIsNotNone(QC_thread_id_hex)
287         self.assertEqual(threads[0], QC_thread_id)
289     def test_qThreadInfo_matches_qC_launch(self):  argument
290         self.build()
291         self.set_inferior_startup_launch()
292         self.qThreadInfo_matches_qC()
295     def test_qThreadInfo_matches_qC_attach(self):  argument
296         self.build()
297         self.set_inferior_startup_attach()
298         self.qThreadInfo_matches_qC()
300     def test_p_returns_correct_data_size_for_each_qRegisterInfo_launch(self):  argument
301         self.build()
302         self.set_inferior_startup_launch()
303         procs = self.prep_debug_monitor_and_inferior()
304         self.add_register_info_collection_packets()
307         context = self.expect_gdbremote_sequence()
308         self.assertIsNotNone(context)
311         reg_infos = self.parse_register_info_packets(context)
312         self.assertIsNotNone(reg_infos)
313         self.assertTrue(len(reg_infos) > 0)
315         byte_order = self.get_target_byte_order()
328             self.reset_test_sequence()
331             self.test_sequence.add_log_lines(
335             context = self.expect_gdbremote_sequence()
336             self.assertIsNotNone(context)
340             self.assertIsNotNone(p_response)
348                 self.updateRegInfoBitsize(reg_info, byte_order)
349             self.assertEqual(len(p_response), 2 * int(reg_info["bitsize"]) / 8,
355     def Hg_switches_to_3_threads(self, pass_pid=False):  argument
356         _, threads = self.launch_with_threads(3)
365             self.reset_test_sequence()
366             self.test_sequence.add_log_lines(
373             context = self.expect_gdbremote_sequence()
374             self.assertIsNotNone(context)
377             self.assertIsNotNone(context.get("thread_id"))
378             self.assertEqual(int(context.get("thread_id"), 16), thread)
381     def test_Hg_switches_to_3_threads_launch(self):  argument
382         self.build()
383         self.set_inferior_startup_launch()
384         self.Hg_switches_to_3_threads()
386     def Hg_fails_on_pid(self, pass_pid):  argument
387         _, threads = self.launch_with_threads(2)
395         self.test_sequence.add_log_lines(
400         self.expect_gdbremote_sequence()
403     def test_Hg_fails_on_another_pid(self):  argument
404         self.build()
405         self.set_inferior_startup_launch()
406         self.Hg_fails_on_pid(1)
409     def test_Hg_fails_on_zero_pid(self):  argument
410         self.build()
411         self.set_inferior_startup_launch()
412         self.Hg_fails_on_pid(0)
415     def test_Hg_fails_on_minus_one_pid(self):  argument
416         self.build()
417         self.set_inferior_startup_launch()
418         self.Hg_fails_on_pid(-1)
420     def Hc_then_Csignal_signals_correct_thread(self, segfault_signo):  argument
438         procs = self.prep_debug_monitor_and_inferior(
440         self.test_sequence.add_log_lines(["read packet: $c#63"], True)
441         context = self.expect_gdbremote_sequence()
449             self.reset_test_sequence()
450             self.test_sequence.add_log_lines([{"direction": "send",
456             context = self.expect_gdbremote_sequence()
457             self.assertIsNotNone(context)
459             self.assertEqual(int(signo, 16), segfault_signo)
463             self.assertNotIn(thread_id, signaled_tids)
467             self.reset_test_sequence()
468             self.test_sequence.add_log_lines(
492             context = self.expect_gdbremote_sequence()
493             self.assertIsNotNone(context)
509             self.assertIsNotNone(print_thread_id)
511             self.assertNotIn(print_thread_id, print_thread_ids)
520             self.assertIsNotNone(post_handle_thread_id)
522             self.assertEqual(post_handle_thread_id, print_thread_id)
527     def test_Hc_then_Csignal_signals_correct_thread_launch(self):  argument
528         self.build()
529         self.set_inferior_startup_launch()
531         if self.platformIsDarwin():
534             self.Hc_then_Csignal_signals_correct_thread(self.TARGET_EXC_BAD_ACCESS)
536             self.Hc_then_Csignal_signals_correct_thread(
540     def test_m_packet_reads_memory(self):  argument
541         self.build()
542         self.set_inferior_startup_launch()
548         procs = self.prep_debug_monitor_and_inferior(
556         self.test_sequence.add_log_lines(
562 …{"type": "output_match", "regex": self.maybe_strict_output_regex(r"data address: 0x([0-9a-fA-F]+)\…
571         context = self.expect_gdbremote_sequence()
572         self.assertIsNotNone(context)
575         self.assertIsNotNone(context.get("message_address"))
579         self.reset_test_sequence()
580         self.test_sequence.add_log_lines(
586         context = self.expect_gdbremote_sequence()
587         self.assertIsNotNone(context)
590         self.assertIsNotNone(context.get("read_contents"))
592         self.assertEqual(read_contents, MEMORY_CONTENTS)
594     def test_qMemoryRegionInfo_is_supported(self):  argument
595         self.build()
596         self.set_inferior_startup_launch()
598         procs = self.prep_debug_monitor_and_inferior()
601         self.test_sequence.add_log_lines(
605         self.expect_gdbremote_sequence()
608     def test_qMemoryRegionInfo_reports_code_address_as_executable(self):  argument
609         self.build()
610         self.set_inferior_startup_launch()
613         procs = self.prep_debug_monitor_and_inferior(
617         self.test_sequence.add_log_lines(
623 …{"type": "output_match", "regex": self.maybe_strict_output_regex(r"code address: 0x([0-9a-fA-F]+)\…
632         context = self.expect_gdbremote_sequence()
633         self.assertIsNotNone(context)
636         self.assertIsNotNone(context.get("code_address"))
640         self.reset_test_sequence()
641         self.add_query_memory_region_packets(code_address)
644         context = self.expect_gdbremote_sequence()
645         self.assertIsNotNone(context)
646         mem_region_dict = self.parse_memory_region_packet(context)
649         self.assertNotIn("error", mem_region_dict)
652         self.assertIn("permissions", mem_region_dict)
653         self.assertIn("r", mem_region_dict["permissions"])
654         self.assertIn("x", mem_region_dict["permissions"])
657         self.assert_address_within_memory_region(code_address, mem_region_dict)
660     def test_qMemoryRegionInfo_reports_stack_address_as_rw(self):  argument
661         self.build()
662         self.set_inferior_startup_launch()
665         procs = self.prep_debug_monitor_and_inferior(
669         self.test_sequence.add_log_lines(
675 …{"type": "output_match", "regex": self.maybe_strict_output_regex(r"stack address: 0x([0-9a-fA-F]+)…
684         context = self.expect_gdbremote_sequence()
685         self.assertIsNotNone(context)
688         self.assertIsNotNone(context.get("stack_address"))
692         self.reset_test_sequence()
693         self.add_query_memory_region_packets(stack_address)
696         context = self.expect_gdbremote_sequence()
697         self.assertIsNotNone(context)
698         mem_region_dict = self.parse_memory_region_packet(context)
701         self.assertNotIn("error", mem_region_dict)
704         self.assertIn("permissions", mem_region_dict)
705         self.assertIn("r", mem_region_dict["permissions"])
706         self.assertIn("w", mem_region_dict["permissions"])
709         self.assert_address_within_memory_region(
713     def test_qMemoryRegionInfo_reports_heap_address_as_rw(self):  argument
714         self.build()
715         self.set_inferior_startup_launch()
718         procs = self.prep_debug_monitor_and_inferior(
722         self.test_sequence.add_log_lines(
728 …{"type": "output_match", "regex": self.maybe_strict_output_regex(r"heap address: 0x([0-9a-fA-F]+)\…
737         context = self.expect_gdbremote_sequence()
738         self.assertIsNotNone(context)
741         self.assertIsNotNone(context.get("heap_address"))
745         self.reset_test_sequence()
746         self.add_query_memory_region_packets(heap_address)
749         context = self.expect_gdbremote_sequence()
750         self.assertIsNotNone(context)
751         mem_region_dict = self.parse_memory_region_packet(context)
754         self.assertNotIn("error", mem_region_dict)
757         self.assertIn("permissions", mem_region_dict)
758         self.assertIn("r", mem_region_dict["permissions"])
759         self.assertIn("w", mem_region_dict["permissions"])
762         self.assert_address_within_memory_region(heap_address, mem_region_dict)
764     def breakpoint_set_and_remove_work(self, want_hardware):  argument
766         procs = self.prep_debug_monitor_and_inferior(
773         self.add_register_info_collection_packets()
774         self.add_process_info_collection_packets()
775         self.test_sequence.add_log_lines(
780 …{"type": "output_match", "regex": self.maybe_strict_output_regex(r"code address: 0x([0-9a-fA-F]+)\…
789         context = self.expect_gdbremote_sequence()
790         self.assertIsNotNone(context)
794         process_info = self.parse_process_info_response(context)
796         self.assertIsNotNone(endian)
799         reg_infos = self.parse_register_info_packets(context)
800         (pc_lldb_reg_index, pc_reg_info) = self.find_pc_reg_info(reg_infos)
801         self.assertIsNotNone(pc_lldb_reg_index)
802         self.assertIsNotNone(pc_reg_info)
805         self.assertIsNotNone(context.get("function_address"))
809         target_arch = self.getArchitecture()
825         self.reset_test_sequence()
826         self.add_set_breakpoint_packets(
833         context = self.expect_gdbremote_sequence()
834         self.assertIsNotNone(context)
838         self.assertIsNotNone(stop_signo)
839         self.assertEqual(int(stop_signo, 16),
845         self.assertEqual(len(context["O_content"]), 0)
849         self.reset_test_sequence()
850         self.test_sequence.add_log_lines(
860         context = self.expect_gdbremote_sequence()
861         self.assertIsNotNone(context)
866         self.assertIsNotNone(p_response)
871         self.assertEqual(returned_pc, function_address)
875         self.reset_test_sequence()
878         self.add_remove_breakpoint_packets(
883         self.test_sequence.add_log_lines(
893         context = self.expect_gdbremote_sequence()
894         self.assertIsNotNone(context)
897     def test_software_breakpoint_set_and_remove_work(self):  argument
898         if self.getArchitecture() == "arm":
900             self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
902             self.build()
903         self.set_inferior_startup_launch()
904         self.breakpoint_set_and_remove_work(want_hardware=False)
908     def test_hardware_breakpoint_set_and_remove_work(self):  argument
909         if self.getArchitecture() == "arm":
911             self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
913             self.build()
914         self.set_inferior_startup_launch()
915         self.breakpoint_set_and_remove_work(want_hardware=True)
917     def get_qSupported_dict(self, features=[]):  argument
918         self.build()
919         self.set_inferior_startup_launch()
922         procs = self.prep_debug_monitor_and_inferior()
923         self.add_qSupported_packets(features)
926         context = self.expect_gdbremote_sequence()
927         self.assertIsNotNone(context)
930         return self.parse_qSupported_response(context)
932     def test_qSupported_returns_known_stub_features(self):  argument
933         supported_dict = self.get_qSupported_dict()
934         self.assertIsNotNone(supported_dict)
935         self.assertTrue(len(supported_dict) > 0)
937     def test_qSupported_auvx(self):  argument
940         supported_dict = self.get_qSupported_dict()
941         self.assertEqual(supported_dict.get('qXfer:auxv:read', '-'), expected)
943     def test_qSupported_libraries_svr4(self):  argument
946         supported_dict = self.get_qSupported_dict()
947         self.assertEqual(supported_dict.get('qXfer:libraries-svr4:read', '-'),
950     def test_qSupported_siginfo_read(self):  argument
953         supported_dict = self.get_qSupported_dict()
954         self.assertEqual(supported_dict.get('qXfer:siginfo:read', '-'),
957     def test_qSupported_QPassSignals(self):  argument
960         supported_dict = self.get_qSupported_dict()
961         self.assertEqual(supported_dict.get('QPassSignals', '-'), expected)
964     def test_qSupported_fork_events(self):  argument
966             self.get_qSupported_dict(['multiprocess+', 'fork-events+']))
967         self.assertEqual(supported_dict.get('multiprocess', '-'), '+')
968         self.assertEqual(supported_dict.get('fork-events', '-'), '+')
969         self.assertEqual(supported_dict.get('vfork-events', '-'), '-')
972     def test_qSupported_fork_events_without_multiprocess(self):  argument
974             self.get_qSupported_dict(['fork-events+']))
975         self.assertEqual(supported_dict.get('multiprocess', '-'), '-')
976         self.assertEqual(supported_dict.get('fork-events', '-'), '-')
977         self.assertEqual(supported_dict.get('vfork-events', '-'), '-')
980     def test_qSupported_vfork_events(self):  argument
982             self.get_qSupported_dict(['multiprocess+', 'vfork-events+']))
983         self.assertEqual(supported_dict.get('multiprocess', '-'), '+')
984         self.assertEqual(supported_dict.get('fork-events', '-'), '-')
985         self.assertEqual(supported_dict.get('vfork-events', '-'), '+')
988     def test_qSupported_vfork_events_without_multiprocess(self):  argument
990             self.get_qSupported_dict(['vfork-events+']))
991         self.assertEqual(supported_dict.get('multiprocess', '-'), '-')
992         self.assertEqual(supported_dict.get('fork-events', '-'), '-')
993         self.assertEqual(supported_dict.get('vfork-events', '-'), '-')
998     def test_qSupported_memory_tagging(self):  argument
999         supported_dict = self.get_qSupported_dict()
1000         self.assertEqual(supported_dict.get("memory-tagging", '-'),
1001                          '+' if self.isAArch64MTE() else '-')
1004     def test_written_M_content_reads_back_correctly(self):  argument
1005         self.build()
1006         self.set_inferior_startup_launch()
1011         procs = self.prep_debug_monitor_and_inferior(
1017         self.test_sequence.add_log_lines(
1023 …{"type": "output_match", "regex": self.maybe_strict_output_regex(r"data address: 0x([0-9a-fA-F]+)\…
1030         context = self.expect_gdbremote_sequence()
1031         self.assertIsNotNone(context)
1034         self.assertIsNotNone(context.get("message_address"))
1042         self.reset_test_sequence()
1043         self.test_sequence.add_log_lines(
1058         context = self.expect_gdbremote_sequence()
1059         self.assertIsNotNone(context)
1063         self.assertIsNotNone(printed_message)
1064         self.assertEqual(printed_message, TEST_MESSAGE + "X")
1069     def test_P_writes_all_gpr_registers(self):  argument
1070         self.build()
1071         self.set_inferior_startup_launch()
1074         procs = self.prep_debug_monitor_and_inferior(inferior_args=["sleep:2"])
1075         self.add_register_info_collection_packets()
1076         self.add_process_info_collection_packets()
1078         context = self.expect_gdbremote_sequence()
1079         self.assertIsNotNone(context)
1082         reg_infos = self.parse_register_info_packets(context)
1083         self.assertIsNotNone(reg_infos)
1084         self.add_lldb_register_index(reg_infos)
1087         process_info = self.parse_process_info_response(context)
1089         self.assertIsNotNone(endian)
1094             reg_info for reg_info in reg_infos if self.is_bit_flippable_register(reg_info)]
1095         self.assertTrue(len(gpr_reg_infos) > 0)
1098         (successful_writes, failed_writes) = self.flip_all_bits_in_each_register_value(
1100 …    self.trace("successful writes: {}, failed writes: {}".format(successful_writes, failed_writes))
1101         self.assertTrue(successful_writes > 0)
1106     def test_P_and_p_thread_suffix_work(self):  argument
1107         self.build()
1108         self.set_inferior_startup_launch()
1111         _, threads = self.launch_with_threads(3)
1113         self.reset_test_sequence()
1114         self.add_thread_suffix_request_packets()
1115         self.add_register_info_collection_packets()
1116         self.add_process_info_collection_packets()
1118         context = self.expect_gdbremote_sequence()
1119         self.assertIsNotNone(context)
1121         process_info = self.parse_process_info_response(context)
1122         self.assertIsNotNone(process_info)
1124         self.assertIsNotNone(endian)
1126         reg_infos = self.parse_register_info_packets(context)
1127         self.assertIsNotNone(reg_infos)
1128         self.add_lldb_register_index(reg_infos)
1130         reg_index = self.select_modifiable_register(reg_infos)
1131         self.assertIsNotNone(reg_index)
1133         self.assertTrue(reg_byte_size > 0)
1146                 self.reset_test_sequence()
1147                 self.test_sequence.add_log_lines(
1151                 context = self.expect_gdbremote_sequence()
1152                 self.assertIsNotNone(context)
1157                 self.assertIsNotNone(p_response)
1162             self.reset_test_sequence()
1163             self.test_sequence.add_log_lines(
1175             context = self.expect_gdbremote_sequence()
1176             self.assertIsNotNone(context)
1191             self.reset_test_sequence()
1192             self.test_sequence.add_log_lines(
1196             context = self.expect_gdbremote_sequence()
1197             self.assertIsNotNone(context)
1201             self.assertIsNotNone(p_response)
1206             self.assertEqual(read_value, expected_reg_values[thread_index])
1211     def test_launch_via_A(self):  argument
1212         self.build()
1213         exe_path = self.getBuildArtifact("a.out")
1217         server = self.connect_to_debug_monitor()
1218         self.assertIsNotNone(server)
1219         self.do_handshake()
1222         self.test_sequence.add_log_lines(
1230         context = self.expect_gdbremote_sequence()
1231         self.assertEqual(context["O_content"],
1236     def test_launch_via_vRun(self):  argument
1237         self.build()
1238         exe_path = self.getBuildArtifact("a.out")
1242         server = self.connect_to_debug_monitor()
1243         self.assertIsNotNone(server)
1244         self.do_handshake()
1245         self.test_sequence.add_log_lines(
1252         context = self.expect_gdbremote_sequence()
1253         self.assertEqual(context["O_content"],
1257     def test_launch_via_vRun_no_args(self):  argument
1258         self.build()
1259         exe_path = self.getBuildArtifact("a.out")
1262         server = self.connect_to_debug_monitor()
1263         self.assertIsNotNone(server)
1264         self.do_handshake()
1265         self.test_sequence.add_log_lines(
1272         self.expect_gdbremote_sequence()
1276     def test_QEnvironment(self):  argument
1277         self.build()
1278         exe_path = self.getBuildArtifact("a.out")
1283         server = self.connect_to_debug_monitor()
1284         self.assertIsNotNone(server)
1285         self.do_handshake()
1288             self.test_sequence.add_log_lines(
1292         self.test_sequence.add_log_lines(
1299         context = self.expect_gdbremote_sequence()
1300         self.assertEqual(context["O_content"], b"test\r\na=z\r\n")
1304     def test_QEnvironmentHexEncoded(self):  argument
1305         self.build()
1306         exe_path = self.getBuildArtifact("a.out")
1311         server = self.connect_to_debug_monitor()
1312         self.assertIsNotNone(server)
1313         self.do_handshake()
1317             self.test_sequence.add_log_lines(
1321         self.test_sequence.add_log_lines(
1328         context = self.expect_gdbremote_sequence()
1329         self.assertEqual(context["O_content"], b"test\r\na=z\r\na*}#z\r\n")
1333     def test_qXfer_siginfo_read(self):  argument
1334         self.build()
1335         self.set_inferior_startup_launch()
1336         procs = self.prep_debug_monitor_and_inferior(
1338         self.test_sequence.add_log_lines(["read packet: $c#63"], True)
1339         self.expect_gdbremote_sequence()
1342         self.reset_test_sequence()
1343         self.test_sequence.add_log_lines(
1350         context = self.expect_gdbremote_sequence()
1351         self.assertIsNotNone(context)
1352         self.assertEqual(int(context["signo"], 16),
1357         self.reset_test_sequence()
1358         self.add_process_info_collection_packets()
1359         self.test_sequence.add_log_lines(
1368         context = self.expect_gdbremote_sequence()
1369         self.assertIsNotNone(context)
1372         self.assertEqual(context.get("response_type"), "l")
1376         self.assertIsNotNone(content_raw)
1377         content = self.decode_gdbremote_binary(content_raw).encode("latin1")
1380         process_info = self.parse_process_info_response(context)
1405         self.assertEqual(decoded[signo_idx],
1407         self.assertEqual(decoded[errno_idx], 0)  # si_errno
1408         self.assertEqual(decoded[code_idx], SEGV_MAPERR)  # si_code
1409         self.assertEqual(decoded[addr_idx], 0)  # si_addr