This is an archive of the discontinued LLVM Phabricator instance.

Differential D128361

[lldb] [test] Move part of fork tests to common helper
ClosedPublic

Authored by mgorny on Jun 22 2022, 10:27 AM.

Details

Reviewers
labath
krytarowski
emaste
jingham
Commits
rGc1829e0ec58b: [lldb] [test] Move part of fork tests to common helper
Summary

Sponsored by: The FreeBSD Foundation

Diff Detail

Event Timeline

mgorny created this revision.Jun 22 2022, 10:27 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 22 2022, 10:27 AM
Herald added a subscriber: arichardson. · View Herald Transcript
mgorny requested review of this revision.Jun 22 2022, 10:27 AM
Harbormaster completed remote builds in B171370: Diff 439088.Jun 22 2022, 10:27 AM
labath accepted this revision.Jun 23 2022, 12:15 AM
This revision is now accepted and ready to land.Jun 23 2022, 12:15 AM
This revision was landed with ongoing or failed builds.Jun 24 2022, 8:21 AM
Closed by commit rGc1829e0ec58b: [lldb] [test] Move part of fork tests to common helper (authored by mgorny). · Explain Why
This revision was automatically updated to reflect the committed changes.
mgorny added a commit: rGc1829e0ec58b: [lldb] [test] Move part of fork tests to common helper.
Herald added a project: Restricted Project. · View Herald TranscriptJun 24 2022, 8:21 AM

Revision Contents

PathSize
lldb/
test/
API/
tools/
lldb-server/
321 lines

Diff 439778

lldb/test/API/tools/lldb-server/TestGdbRemoteFork.py

import random import random
import gdbremote_testcase import gdbremote_testcase
from lldbsuite.test.decorators import * from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import * from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil from lldbsuite.test import lldbutil
class TestGdbRemoteFork(gdbremote_testcase.GdbRemoteTestCaseBase): class TestGdbRemoteFork(gdbremote_testcase.GdbRemoteTestCaseBase):
fork_regex = ("[$]T05thread:p([0-9a-f]+)[.]([0-9a-f]+);.*" fork_regex = ("[$]T05thread:p([0-9a-f]+)[.]([0-9a-f]+);.*"
"{}:p([0-9a-f]+)[.]([0-9a-f]+).*") "{}:p([0-9a-f]+)[.]([0-9a-f]+).*")
fork_capture = {1: "parent_pid", 2: "parent_tid", fork_capture = {1: "parent_pid", 2: "parent_tid",
3: "child_pid", 4: "child_tid"} 3: "child_pid", 4: "child_tid"}
@add_test_categories(["fork"]) def start_fork_test(self, args, variant="fork"):
def test_fork_multithreaded(self):
self.build() self.build()
self.prep_debug_monitor_and_inferior(inferior_args=["thread:new"]*2 + ["fork"]) self.prep_debug_monitor_and_inferior(inferior_args=args)
self.add_qSupported_packets(["multiprocess+", "fork-events+"]) self.add_qSupported_packets(["multiprocess+",
"{}-events+".format(variant)])
ret = self.expect_gdbremote_sequence() ret = self.expect_gdbremote_sequence()
self.assertIn("fork-events+", ret["qSupported_response"]) self.assertIn("{}-events+".format(variant), ret["qSupported_response"])
self.reset_test_sequence() self.reset_test_sequence()
# continue and expect fork # continue and expect fork
self.test_sequence.add_log_lines([ self.test_sequence.add_log_lines([
"read packet: $c#00", "read packet: $c#00",
{"direction": "send", "regex": self.fork_regex.format("fork"), {"direction": "send", "regex": self.fork_regex.format(variant),
"capture": self.fork_capture}, "capture": self.fork_capture},
], True) ], True)
ret = self.expect_gdbremote_sequence() ret = self.expect_gdbremote_sequence()
child_pid = ret["child_pid"]
self.reset_test_sequence() self.reset_test_sequence()
return tuple(ret[x] for x in ("parent_pid", "parent_tid",
"child_pid", "child_tid"))
@add_test_categories(["fork"])
def test_fork_multithreaded(self):
_, _, child_pid, _ = self.start_fork_test(["thread:new"]*2 + ["fork"])
# detach the forked child # detach the forked child
self.test_sequence.add_log_lines([ self.test_sequence.add_log_lines([
"read packet: $D;{}#00".format(child_pid), "read packet: $D;{}#00".format(child_pid),
"send packet: $OK#00", "send packet: $OK#00",
"read packet: $k#00", "read packet: $k#00",
], True) ], True)
self.expect_gdbremote_sequence() self.expect_gdbremote_sequence()
def fork_and_detach_test(self, variant): def fork_and_detach_test(self, variant):
self.build() parent_pid, parent_tid, child_pid, child_tid = (
self.prep_debug_monitor_and_inferior(inferior_args=[variant]) self.start_fork_test([variant], variant))
self.add_qSupported_packets(["multiprocess+",
"{}-events+".format(variant)])
ret = self.expect_gdbremote_sequence()
self.assertIn("{}-events+".format(variant), ret["qSupported_response"])
self.reset_test_sequence()
# continue and expect fork
self.test_sequence.add_log_lines([
"read packet: $c#00",
{"direction": "send", "regex": self.fork_regex.format(variant),
"capture": self.fork_capture},
], True)
ret = self.expect_gdbremote_sequence()
parent_pid = ret["parent_pid"]
parent_tid = ret["parent_tid"]
child_pid = ret["child_pid"]
child_tid = ret["child_tid"]
self.reset_test_sequence()
# detach the forked child # detach the forked child
self.test_sequence.add_log_lines([ self.test_sequence.add_log_lines([
"read packet: $D;{}#00".format(child_pid), "read packet: $D;{}#00".format(child_pid),
"send packet: $OK#00", "send packet: $OK#00",
# verify that the current process is correct # verify that the current process is correct
"read packet: $qC#00", "read packet: $qC#00",
"send packet: $QCp{}.{}#00".format(parent_pid, parent_tid), "send packet: $QCp{}.{}#00".format(parent_pid, parent_tid),
Show All 30 Lines def test_vfork(self):
parent_tid), parent_tid),
}, },
"read packet: $c#00", "read packet: $c#00",
"send packet: $W00;process:{}#00".format(parent_pid), "send packet: $W00;process:{}#00".format(parent_pid),
], True) ], True)
self.expect_gdbremote_sequence() self.expect_gdbremote_sequence()
def fork_and_follow_test(self, variant): def fork_and_follow_test(self, variant):
self.build() parent_pid, parent_tid, child_pid, child_tid = (
self.prep_debug_monitor_and_inferior(inferior_args=[variant]) self.start_fork_test([variant], variant))
self.add_qSupported_packets(["multiprocess+",
"{}-events+".format(variant)])
ret = self.expect_gdbremote_sequence()
self.assertIn("{}-events+".format(variant), ret["qSupported_response"])
self.reset_test_sequence()
# continue and expect fork
self.test_sequence.add_log_lines([
"read packet: $c#00",
{"direction": "send", "regex": self.fork_regex.format(variant),
"capture": self.fork_capture},
], True)
ret = self.expect_gdbremote_sequence()
parent_pid = ret["parent_pid"]
parent_tid = ret["parent_tid"]
child_pid = ret["child_pid"]
child_tid = ret["child_tid"]
self.reset_test_sequence()
# switch to the forked child # switch to the forked child
self.test_sequence.add_log_lines([ self.test_sequence.add_log_lines([
"read packet: $Hgp{}.{}#00".format(child_pid, child_tid), "read packet: $Hgp{}.{}#00".format(child_pid, child_tid),
"send packet: $OK#00", "send packet: $OK#00",
"read packet: $Hcp{}.{}#00".format(child_pid, child_tid), "read packet: $Hcp{}.{}#00".format(child_pid, child_tid),
"send packet: $OK#00", "send packet: $OK#00",
# detach the parent # detach the parent
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines def test_detach_current(self):
"send packet: $OK#00", "send packet: $OK#00",
"read packet: $qC#00", "read packet: $qC#00",
"send packet: $E44#00", "send packet: $E44#00",
], True) ], True)
self.expect_gdbremote_sequence() self.expect_gdbremote_sequence()
@add_test_categories(["fork"]) @add_test_categories(["fork"])
def test_detach_all(self): def test_detach_all(self):
self.build() parent_pid, parent_tid, child_pid, child_tid = (
self.prep_debug_monitor_and_inferior(inferior_args=["fork"]) self.start_fork_test(["fork"]))
self.add_qSupported_packets(["multiprocess+",
"fork-events+"])
ret = self.expect_gdbremote_sequence()
self.assertIn("fork-events+", ret["qSupported_response"])
self.reset_test_sequence()
# continue and expect fork
self.test_sequence.add_log_lines([
"read packet: $c#00",
{"direction": "send", "regex": self.fork_regex.format("fork"),
"capture": self.fork_capture},
], True)
ret = self.expect_gdbremote_sequence()
parent_pid = ret["parent_pid"]
parent_tid = ret["parent_tid"]
child_pid = ret["child_pid"]
child_tid = ret["child_tid"]
self.reset_test_sequence()
self.test_sequence.add_log_lines([ self.test_sequence.add_log_lines([
# double-check our PIDs # double-check our PIDs
"read packet: $Hgp{}.{}#00".format(parent_pid, parent_tid), "read packet: $Hgp{}.{}#00".format(parent_pid, parent_tid),
"send packet: $OK#00", "send packet: $OK#00",
"read packet: $Hgp{}.{}#00".format(child_pid, child_tid), "read packet: $Hgp{}.{}#00".format(child_pid, child_tid),
"send packet: $OK#00", "send packet: $OK#00",
# detach all processes # detach all processes
"read packet: $D#00", "read packet: $D#00",
"send packet: $OK#00", "send packet: $OK#00",
# verify that both PIDs are invalid now # verify that both PIDs are invalid now
"read packet: $Hgp{}.{}#00".format(parent_pid, parent_tid), "read packet: $Hgp{}.{}#00".format(parent_pid, parent_tid),
"send packet: $Eff#00", "send packet: $Eff#00",
"read packet: $Hgp{}.{}#00".format(child_pid, child_tid), "read packet: $Hgp{}.{}#00".format(child_pid, child_tid),
"send packet: $Eff#00", "send packet: $Eff#00",
], True) ], True)
self.expect_gdbremote_sequence() self.expect_gdbremote_sequence()
@add_test_categories(["fork"]) @add_test_categories(["fork"])
def test_kill_all(self): def test_kill_all(self):
self.build() parent_pid, _, child_pid, _ = self.start_fork_test(["fork"])
self.prep_debug_monitor_and_inferior(inferior_args=["fork"])
self.add_qSupported_packets(["multiprocess+",
"fork-events+"])
ret = self.expect_gdbremote_sequence()
self.assertIn("fork-events+", ret["qSupported_response"])
self.reset_test_sequence()
# continue and expect fork
self.test_sequence.add_log_lines([
"read packet: $c#00",
{"direction": "send", "regex": self.fork_regex.format("fork"),
"capture": self.fork_capture},
], True)
ret = self.expect_gdbremote_sequence()
parent_pid = ret["parent_pid"]
child_pid = ret["child_pid"]
self.reset_test_sequence()
exit_regex = "[$]X09;process:([0-9a-f]+)#.*" exit_regex = "[$]X09;process:([0-9a-f]+)#.*"
self.test_sequence.add_log_lines([ self.test_sequence.add_log_lines([
# kill all processes # kill all processes
"read packet: $k#00", "read packet: $k#00",
{"direction": "send", "regex": exit_regex, {"direction": "send", "regex": exit_regex,
"capture": {1: "pid1"}}, "capture": {1: "pid1"}},
{"direction": "send", "regex": exit_regex, {"direction": "send", "regex": exit_regex,
"capture": {1: "pid2"}}, "capture": {1: "pid2"}},
], True) ], True)
ret = self.expect_gdbremote_sequence() ret = self.expect_gdbremote_sequence()
self.assertEqual(set([ret["pid1"], ret["pid2"]]), self.assertEqual(set([ret["pid1"], ret["pid2"]]),
set([parent_pid, child_pid])) set([parent_pid, child_pid]))
def vkill_test(self, kill_parent=False, kill_child=False): def vkill_test(self, kill_parent=False, kill_child=False):
assert kill_parent or kill_child assert kill_parent or kill_child
self.build() parent_pid, parent_tid, child_pid, child_tid = (
self.prep_debug_monitor_and_inferior(inferior_args=["fork"]) self.start_fork_test(["fork"]))
self.add_qSupported_packets(["multiprocess+",
"fork-events+"])
ret = self.expect_gdbremote_sequence()
self.assertIn("fork-events+", ret["qSupported_response"])
self.reset_test_sequence()
# continue and expect fork
self.test_sequence.add_log_lines([
"read packet: $c#00",
{"direction": "send", "regex": self.fork_regex.format("fork"),
"capture": self.fork_capture},
], True)
ret = self.expect_gdbremote_sequence()
parent_pid = ret["parent_pid"]
parent_tid = ret["parent_tid"]
child_pid = ret["child_pid"]
child_tid = ret["child_tid"]
self.reset_test_sequence()
if kill_parent: if kill_parent:
self.test_sequence.add_log_lines([ self.test_sequence.add_log_lines([
# kill the process # kill the process
"read packet: $vKill;{}#00".format(parent_pid), "read packet: $vKill;{}#00".format(parent_pid),
"send packet: $OK#00", "send packet: $OK#00",
], True) ], True)
if kill_child: if kill_child:
Show All 20 Linesclass TestGdbRemoteFork(gdbremote_testcase.GdbRemoteTestCaseBase):
def test_vkill_parent(self): def test_vkill_parent(self):
self.vkill_test(kill_parent=True) self.vkill_test(kill_parent=True)
@add_test_categories(["fork"]) @add_test_categories(["fork"])
def test_vkill_both(self): def test_vkill_both(self):
self.vkill_test(kill_parent=True, kill_child=True) self.vkill_test(kill_parent=True, kill_child=True)
def resume_one_test(self, run_order, use_vCont=False): def resume_one_test(self, run_order, use_vCont=False):
self.build() parent_pid, parent_tid, child_pid, child_tid = (
self.prep_debug_monitor_and_inferior(inferior_args=["fork", "trap"]) self.start_fork_test(["fork", "trap"]))
self.add_qSupported_packets(["multiprocess+",
"fork-events+"])
ret = self.expect_gdbremote_sequence()
self.assertIn("fork-events+", ret["qSupported_response"])
self.reset_test_sequence()
# continue and expect fork
self.test_sequence.add_log_lines([
"read packet: $c#00",
{"direction": "send", "regex": self.fork_regex.format("fork"),
"capture": self.fork_capture},
], True)
ret = self.expect_gdbremote_sequence()
parent_pid = ret["parent_pid"]
parent_tid = ret["parent_tid"]
child_pid = ret["child_pid"]
child_tid = ret["child_tid"]
self.reset_test_sequence()
parent_expect = [ parent_expect = [
"[$]T05thread:p{}.{};.*".format(parent_pid, parent_tid), "[$]T05thread:p{}.{};.*".format(parent_pid, parent_tid),
"[$]W00;process:{}#.*".format(parent_pid), "[$]W00;process:{}#.*".format(parent_pid),
] ]
child_expect = [ child_expect = [
"[$]T05thread:p{}.{};.*".format(child_pid, child_tid), "[$]T05thread:p{}.{};.*".format(child_pid, child_tid),
"[$]W00;process:{}#.*".format(child_pid), "[$]W00;process:{}#.*".format(child_pid),
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Linesclass TestGdbRemoteFork(gdbremote_testcase.GdbRemoteTestCaseBase):
@add_test_categories(["fork"]) @add_test_categories(["fork"])
def test_vCont_interspersed(self): def test_vCont_interspersed(self):
self.resume_one_test(run_order=["parent", "child", "parent", "child"], self.resume_one_test(run_order=["parent", "child", "parent", "child"],
use_vCont=True) use_vCont=True)
@add_test_categories(["fork"]) @add_test_categories(["fork"])
def test_vCont_two_processes(self): def test_vCont_two_processes(self):
self.build() parent_pid, parent_tid, child_pid, child_tid = (
self.prep_debug_monitor_and_inferior(inferior_args=["fork", "trap"]) self.start_fork_test(["fork", "trap"]))
self.add_qSupported_packets(["multiprocess+",
"fork-events+"])
ret = self.expect_gdbremote_sequence()
self.assertIn("fork-events+", ret["qSupported_response"])
self.reset_test_sequence()
# continue and expect fork
self.test_sequence.add_log_lines([
"read packet: $c#00",
{"direction": "send", "regex": self.fork_regex.format("fork"),
"capture": self.fork_capture},
], True)
ret = self.expect_gdbremote_sequence()
parent_pid = ret["parent_pid"]
parent_tid = ret["parent_tid"]
child_pid = ret["child_pid"]
child_tid = ret["child_tid"]
self.reset_test_sequence()
self.test_sequence.add_log_lines([ self.test_sequence.add_log_lines([
# try to resume both processes # try to resume both processes
"read packet: $vCont;c:p{}.{};c:p{}.{}#00".format( "read packet: $vCont;c:p{}.{};c:p{}.{}#00".format(
parent_pid, parent_tid, child_pid, child_tid), parent_pid, parent_tid, child_pid, child_tid),
"send packet: $E03#00", "send packet: $E03#00",
], True) ], True)
self.expect_gdbremote_sequence() self.expect_gdbremote_sequence()
@add_test_categories(["fork"]) @add_test_categories(["fork"])
def test_vCont_all_processes_explicit(self): def test_vCont_all_processes_explicit(self):
self.build() self.start_fork_test(["fork", "trap"])
self.prep_debug_monitor_and_inferior(inferior_args=["fork", "trap"])
self.add_qSupported_packets(["multiprocess+",
"fork-events+"])
ret = self.expect_gdbremote_sequence()
self.assertIn("fork-events+", ret["qSupported_response"])
self.reset_test_sequence()
# continue and expect fork
self.test_sequence.add_log_lines([
"read packet: $c#00",
{"direction": "send", "regex": self.fork_regex.format("fork"),
"capture": self.fork_capture},
], True)
ret = self.expect_gdbremote_sequence()
parent_pid = ret["parent_pid"]
parent_tid = ret["parent_tid"]
child_pid = ret["child_pid"]
child_tid = ret["child_tid"]
self.reset_test_sequence()
self.test_sequence.add_log_lines([ self.test_sequence.add_log_lines([
# try to resume all processes implicitly # try to resume all processes implicitly
"read packet: $vCont;c:p-1.-1#00", "read packet: $vCont;c:p-1.-1#00",
"send packet: $E03#00", "send packet: $E03#00",
], True) ], True)
self.expect_gdbremote_sequence() self.expect_gdbremote_sequence()
@add_test_categories(["fork"]) @add_test_categories(["fork"])
def test_vCont_all_processes_implicit(self): def test_vCont_all_processes_implicit(self):
self.build() self.start_fork_test(["fork", "trap"])
self.prep_debug_monitor_and_inferior(inferior_args=["fork", "trap"])
self.add_qSupported_packets(["multiprocess+",
"fork-events+"])
ret = self.expect_gdbremote_sequence()
self.assertIn("fork-events+", ret["qSupported_response"])
self.reset_test_sequence()
# continue and expect fork
self.test_sequence.add_log_lines([
"read packet: $c#00",
{"direction": "send", "regex": self.fork_regex.format("fork"),
"capture": self.fork_capture},
], True)
ret = self.expect_gdbremote_sequence()
parent_pid = ret["parent_pid"]
parent_tid = ret["parent_tid"]
child_pid = ret["child_pid"]
child_tid = ret["child_tid"]
self.reset_test_sequence()
self.test_sequence.add_log_lines([ self.test_sequence.add_log_lines([
# try to resume all processes implicitly # try to resume all processes implicitly
"read packet: $vCont;c#00", "read packet: $vCont;c#00",
"send packet: $E03#00", "send packet: $E03#00",
], True) ], True)
self.expect_gdbremote_sequence() self.expect_gdbremote_sequence()
@add_test_categories(["fork"]) @add_test_categories(["fork"])
def test_threadinfo(self): def test_threadinfo(self):
self.build() parent_pid, parent_tid, child_pid, child_tid = (
self.prep_debug_monitor_and_inferior( self.start_fork_test(["fork", "thread:new", "trap"]))
inferior_args=["fork", pidtids = [
"thread:new", (parent_pid, parent_tid),
"trap", (child_pid, child_tid),
]) ]
self.add_qSupported_packets(["multiprocess+",
"fork-events+"])
ret = self.expect_gdbremote_sequence()
self.assertIn("fork-events+", ret["qSupported_response"])
self.reset_test_sequence()
# continue and expect fork
self.test_sequence.add_log_lines([
"read packet: $c#00",
{"direction": "send", "regex": self.fork_regex.format("fork"),
"capture": self.fork_capture},
], True)
self.add_threadinfo_collection_packets() self.add_threadinfo_collection_packets()
ret = self.expect_gdbremote_sequence() ret = self.expect_gdbremote_sequence()
pidtids = [
(ret["parent_pid"], ret["parent_tid"]),
(ret["child_pid"], ret["child_tid"]),
]
prev_pidtids = set(self.parse_threadinfo_packets(ret)) prev_pidtids = set(self.parse_threadinfo_packets(ret))
self.assertEqual(prev_pidtids, self.assertEqual(prev_pidtids,
frozenset((int(pid, 16), int(tid, 16)) frozenset((int(pid, 16), int(tid, 16))
for pid, tid in pidtids)) for pid, tid in pidtids))
self.reset_test_sequence() self.reset_test_sequence()
for pidtid in pidtids: for pidtid in pidtids:
self.test_sequence.add_log_lines( self.test_sequence.add_log_lines(
▲ Show 20 Lines • Show All 107 Lines • ▼ Show 20 Lines def test_memory_read_write(self):
ret = self.expect_gdbremote_sequence() ret = self.expect_gdbremote_sequence()
self.assertIsNotNone(ret.get("data")) self.assertIsNotNone(ret.get("data"))
data = seven.unhexlify(ret.get("data")) data = seven.unhexlify(ret.get("data"))
self.assertEqual(data, name + "\0") self.assertEqual(data, name + "\0")
self.reset_test_sequence() self.reset_test_sequence()
@add_test_categories(["fork"]) @add_test_categories(["fork"])
def test_register_read_write(self): def test_register_read_write(self):
self.build() parent_pid, parent_tid, child_pid, child_tid = (
self.prep_debug_monitor_and_inferior( self.start_fork_test(["fork", "thread:new", "trap"]))
inferior_args=["fork",
"thread:new",
"trap",
])
self.add_qSupported_packets(["multiprocess+",
"fork-events+"])
ret = self.expect_gdbremote_sequence()
self.assertIn("fork-events+", ret["qSupported_response"])
self.reset_test_sequence()
# continue and expect fork
self.test_sequence.add_log_lines([
"read packet: $c#00",
{"direction": "send", "regex": self.fork_regex.format("fork"),
"capture": self.fork_capture},
], True)
self.add_threadinfo_collection_packets()
ret = self.expect_gdbremote_sequence()
pidtids = [ pidtids = [
(ret["parent_pid"], ret["parent_tid"]), (parent_pid, parent_tid),
(ret["child_pid"], ret["child_tid"]), (child_pid, child_tid),
] ]
self.reset_test_sequence()
for pidtid in pidtids: for pidtid in pidtids:
self.test_sequence.add_log_lines( self.test_sequence.add_log_lines(
["read packet: $Hcp{}.{}#00".format(*pidtid), ["read packet: $Hcp{}.{}#00".format(*pidtid),
"send packet: $OK#00", "send packet: $OK#00",
"read packet: $c#00", "read packet: $c#00",
{"direction": "send", {"direction": "send",
"regex": "^[$]T05thread:p{}.{}.*".format(*pidtid), "regex": "^[$]T05thread:p{}.{}.*".format(*pidtid),
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines def test_register_read_write(self):
], True) ], True)
ret = self.expect_gdbremote_sequence() ret = self.expect_gdbremote_sequence()
data = ret.get("data") data = ret.get("data")
self.assertIsNotNone(data) self.assertIsNotNone(data)
self.assertEqual(data, old_val[1]) self.assertEqual(data, old_val[1])
@add_test_categories(["fork"]) @add_test_categories(["fork"])
def test_qC(self): def test_qC(self):
self.build() parent_pid, parent_tid, child_pid, child_tid = (
self.prep_debug_monitor_and_inferior( self.start_fork_test(["fork", "thread:new", "trap"]))
inferior_args=["fork",
"thread:new",
"trap",
])
self.add_qSupported_packets(["multiprocess+",
"fork-events+"])
ret = self.expect_gdbremote_sequence()
self.assertIn("fork-events+", ret["qSupported_response"])
self.reset_test_sequence()
# continue and expect fork
self.test_sequence.add_log_lines([
"read packet: $c#00",
{"direction": "send", "regex": self.fork_regex.format("fork"),
"capture": self.fork_capture},
], True)
self.add_threadinfo_collection_packets()
ret = self.expect_gdbremote_sequence()
pidtids = [ pidtids = [
(ret["parent_pid"], ret["parent_tid"]), (parent_pid, parent_tid),
(ret["child_pid"], ret["child_tid"]), (child_pid, child_tid),
] ]
self.reset_test_sequence()
for pidtid in pidtids: for pidtid in pidtids:
self.test_sequence.add_log_lines( self.test_sequence.add_log_lines(
["read packet: $Hcp{}.{}#00".format(*pidtid), ["read packet: $Hcp{}.{}#00".format(*pidtid),
"send packet: $OK#00", "send packet: $OK#00",
"read packet: $c#00", "read packet: $c#00",
{"direction": "send", {"direction": "send",
"regex": "^[$]T05thread:p{}.{}.*".format(*pidtid), "regex": "^[$]T05thread:p{}.{}.*".format(*pidtid),
Show All 12 Lines def test_qC(self):
"send packet: $OK#00", "send packet: $OK#00",
"read packet: $qC#00", "read packet: $qC#00",
"send packet: $QCp{:x}.{:x}#00".format(*pidtid), "send packet: $QCp{:x}.{:x}#00".format(*pidtid),
], True) ], True)
self.expect_gdbremote_sequence() self.expect_gdbremote_sequence()
@add_test_categories(["fork"]) @add_test_categories(["fork"])
def test_T(self): def test_T(self):
self.build() parent_pid, parent_tid, child_pid, child_tid = (
self.prep_debug_monitor_and_inferior( self.start_fork_test(["fork", "thread:new", "trap"]))
inferior_args=["fork",
"thread:new",
"trap",
])
self.add_qSupported_packets(["multiprocess+",
"fork-events+"])
ret = self.expect_gdbremote_sequence()
self.assertIn("fork-events+", ret["qSupported_response"])
self.reset_test_sequence()
# continue and expect fork
self.test_sequence.add_log_lines([
"read packet: $c#00",
{"direction": "send", "regex": self.fork_regex.format("fork"),
"capture": self.fork_capture},
], True)
self.add_threadinfo_collection_packets()
ret = self.expect_gdbremote_sequence()
pidtids = [ pidtids = [
(ret["parent_pid"], ret["parent_tid"]), (parent_pid, parent_tid),
(ret["child_pid"], ret["child_tid"]), (child_pid, child_tid),
] ]
self.reset_test_sequence()
for pidtid in pidtids: for pidtid in pidtids:
self.test_sequence.add_log_lines( self.test_sequence.add_log_lines(
["read packet: $Hcp{}.{}#00".format(*pidtid), ["read packet: $Hcp{}.{}#00".format(*pidtid),
"send packet: $OK#00", "send packet: $OK#00",
"read packet: $c#00", "read packet: $c#00",
{"direction": "send", {"direction": "send",
"regex": "^[$]T05thread:p{}.{}.*".format(*pidtid), "regex": "^[$]T05thread:p{}.{}.*".format(*pidtid),
Show All 37 Lines