24         def qRegisterInfo(self, num):  argument
26                 return self.registers[num]
30         def readRegisters(self):  argument
31             return len(self.registers) * 16 * '0'
33         def readRegister(self, register):  argument
36     def test_connect(self):  argument
38         target = self.createTarget("a.yaml")
39         process = self.connect(target)
40         self.assertPacketLogContains(["qProcessInfo", "qfThreadInfo"])
42     def test_attach_fail(self):  argument
47             def qC(self):  argument
50             def qfThreadInfo(self):  argument
54             def vAttach(self, pid):  argument
57         self.server.responder = MyResponder()
59         target = self.dbg.CreateTarget("")
60         process = self.connect(target)
61         lldbutil.expect_state_changes(self, self.dbg.GetListener(), process, [lldb.eStateConnected])
65         self.assertEquals(error_msg, error.GetCString())
67     def test_launch_fail(self):  argument
70             def qC(self):  argument
73             def qfThreadInfo(self):  argument
77             def A(self, packet):  argument
80         self.server.responder = MyResponder()
82         target = self.createTarget("a.yaml")
83         process = self.connect(target)
84         lldbutil.expect_state_changes(self, self.dbg.GetListener(), process, [lldb.eStateConnected])
89         self.assertEquals("'A' packet returned an error: 71", error.GetCString())
91     def test_read_registers_using_g_packets(self):  argument
93         self.dbg.HandleCommand(
95         self.addTearDownHook(lambda:
96 …              self.runCmd("settings set plugin.process.gdb-remote.use-g-packet-for-reading false"))
97         self.server.responder = self.gPacketResponder()
98         target = self.createTarget("a.yaml")
99         process = self.connect(target)
101         self.assertEquals(1, self.server.responder.packetLog.count("g"))
102         self.server.responder.packetLog = []
103         self.read_registers(process)
105         self.assertEquals(
106                 0, len([p for p in self.server.responder.packetLog if p.startswith("p")]))
108     def test_read_registers_using_p_packets(self):  argument
110         self.dbg.HandleCommand(
112         self.server.responder = self.gPacketResponder()
113         target = self.createTarget("a.yaml")
114         process = self.connect(target)
116         self.read_registers(process)
117         self.assertNotIn("g", self.server.responder.packetLog)
118         self.assertGreater(
119                 len([p for p in self.server.responder.packetLog if p.startswith("p")]), 0)
121     def test_write_registers_using_P_packets(self):  argument
123         self.server.responder = self.gPacketResponder()
124         target = self.createTarget("a.yaml")
125         process = self.connect(target)
127         self.write_registers(process)
128         self.assertEquals(0, len(
129                 [p for p in self.server.responder.packetLog if p.startswith("G")]))
130         self.assertGreater(
131                 len([p for p in self.server.responder.packetLog if p.startswith("P")]), 0)
133     def test_write_registers_using_G_packets(self):  argument
136         class MyResponder(self.gPacketResponder):
137             def readRegister(self, register):  argument
141         self.server.responder = MyResponder()
142         target = self.createTarget("a.yaml")
143         process = self.connect(target)
145         self.write_registers(process)
146         self.assertEquals(0, len(
147                 [p for p in self.server.responder.packetLog if p.startswith("P")]))
148         self.assertGreater(len(
149                 [p for p in self.server.responder.packetLog if p.startswith("G")]), 0)
151     def read_registers(self, process):  argument
152         self.for_each_gpr(
153                 process, lambda r: self.assertEquals("0x0000000000000000", r.GetValue()))
155     def write_registers(self, process):  argument
156         self.for_each_gpr(
159     def for_each_gpr(self, process, operation):  argument
161         self.assertGreater(registers.GetSize(), 0)
164         self.assertGreater(numChildren, 0)
168     def test_launch_A(self):  argument
170             def __init__(self, *args, **kwargs):  argument
171                 self.started = False
174             def qC(self):  argument
175                 if self.started:
180             def qfThreadInfo(self):  argument
181                 if self.started:
186             def qsThreadInfo(self):  argument
189             def A(self, packet):  argument
190                 self.started = True
193             def qLaunchSuccess(self):  argument
194                 if self.started:
198         self.server.responder = MyResponder()
200         target = self.createTarget("a.yaml")
202         exe_path = self.getBuildArtifact("a").replace(os.path.sep, '/')
204         process = self.connect(target)
205         lldbutil.expect_state_changes(self, self.dbg.GetListener(), process,
218         self.assertTrue(process, PROCESS_IS_VALID)
219         self.assertEqual(process.GetProcessID(), 16)
221         self.assertPacketLogContains([
226     def test_launch_vRun(self):  argument
228             def __init__(self, *args, **kwargs):  argument
229                 self.started = False
232             def qC(self):  argument
233                 if self.started:
238             def qfThreadInfo(self):  argument
239                 if self.started:
244             def qsThreadInfo(self):  argument
247             def vRun(self, packet):  argument
248                 self.started = True
251             def A(self, packet):  argument
254         self.server.responder = MyResponder()
256         target = self.createTarget("a.yaml")
258         exe_path = self.getBuildArtifact("a").replace(os.path.sep, '/')
260         process = self.connect(target)
261         lldbutil.expect_state_changes(self, self.dbg.GetListener(), process,
274         self.assertTrue(process, PROCESS_IS_VALID)
275         self.assertEqual(process.GetProcessID(), 16)
277         self.assertPacketLogContains([
281     def test_launch_QEnvironment(self):  argument
283             def qC(self):  argument
286             def qfThreadInfo(self):  argument
289             def vRun(self, packet):  argument
290                 self.started = True
293         self.server.responder = MyResponder()
295         target = self.createTarget("a.yaml")
296         process = self.connect(target)
297         lldbutil.expect_state_changes(self, self.dbg.GetListener(), process,
317         self.assertPacketLogContains([
326     def test_launch_QEnvironmentHexEncoded_only(self):  argument
328             def qC(self):  argument
331             def qfThreadInfo(self):  argument
334             def vRun(self, packet):  argument
335                 self.started = True
338             def QEnvironment(self, packet):  argument
341         self.server.responder = MyResponder()
343         target = self.createTarget("a.yaml")
344         process = self.connect(target)
345         lldbutil.expect_state_changes(self, self.dbg.GetListener(), process,
365         self.assertPacketLogContains([
374     def test_detach_no_multiprocess(self):  argument
376             def __init__(self):  argument
378                 self.detached = None
380             def qfThreadInfo(self):  argument
383             def D(self, packet):  argument
384                 self.detached = packet
387         self.server.responder = MyResponder()
388         target = self.dbg.CreateTarget('')
389         process = self.connect(target)
391         self.assertEqual(self.server.responder.detached, "D")
393     def test_detach_pid(self):  argument
395             def __init__(self, test_case):  argument
397                 self.test_case = test_case
398                 self.detached = None
400             def qSupported(self, client_supported):  argument
401                 self.test_case.assertIn("multiprocess+", client_supported)
404             def qfThreadInfo(self):  argument
407             def D(self, packet):  argument
408                 self.detached = packet
411         self.server.responder = MyResponder(self)
412         target = self.dbg.CreateTarget('')
413         process = self.connect(target)
415         self.assertRegex(self.server.responder.detached, r"D;0*400")
417     def test_signal_gdb(self):  argument
419             def qSupported(self, client_supported):  argument
422             def haltReason(self):  argument
425             def cont(self):  argument
426                 return self.haltReason()
428         self.server.responder = MyResponder()
430         self.runCmd("platform select remote-linux")
431         target = self.createTarget("a.yaml")
432         process = self.connect(target)
434         self.assertEqual(process.threads[0].GetStopReason(),
436         self.assertEqual(process.threads[0].GetStopDescription(100),
439     def test_signal_lldb_old(self):  argument
441             def qSupported(self, client_supported):  argument
444             def qHostInfo(self):  argument
447             def QThreadSuffixSupported(self):  argument
450             def haltReason(self):  argument
453             def cont(self):  argument
454                 return self.haltReason()
456         self.server.responder = MyResponder()
458         self.runCmd("platform select remote-linux")
459         target = self.createTarget("a.yaml")
460         process = self.connect(target)
462         self.assertEqual(process.threads[0].GetStopReason(),
464         self.assertEqual(process.threads[0].GetStopDescription(100),
467     def test_signal_lldb(self):  argument
469             def qSupported(self, client_supported):  argument
472             def qHostInfo(self):  argument
475             def haltReason(self):  argument
478             def cont(self):  argument
479                 return self.haltReason()
481         self.server.responder = MyResponder()
483         self.runCmd("platform select remote-linux")
484         target = self.createTarget("a.yaml")
485         process = self.connect(target)
487         self.assertEqual(process.threads[0].GetStopReason(),
489         self.assertEqual(process.threads[0].GetStopDescription(100),
492     def do_siginfo_test(self, platform, target_yaml, raw_data, expected):  argument
494             def qSupported(self, client_supported):  argument
497             def qXferRead(self, obj, annex, offset, length):  argument
503             def haltReason(self):  argument
506             def cont(self):  argument
507                 return self.haltReason()
509         self.server.responder = MyResponder()
511         self.runCmd("platform select " + platform)
512         target = self.createTarget(target_yaml)
513         process = self.connect(target)
516         self.assertSuccess(siginfo.GetError())
519             self.assertEqual(siginfo.GetValueForExpressionPath("." + key)
524     def test_siginfo_linux_amd64(self):  argument
542         self.do_siginfo_test("remote-linux", "basic_eh_frame.yaml",
545     def test_siginfo_linux_i386(self):  argument
562         self.do_siginfo_test("remote-linux", "basic_eh_frame-i386.yaml",
565     def test_siginfo_freebsd_amd64(self):  argument
584         self.do_siginfo_test("remote-freebsd", "basic_eh_frame.yaml",