[lldb/test] Move gdb client utils into the packages tree

[labath]

Summary

This infrastructure has proven proven its worth, so give it a more
prominent place.

My immediate motivation for this is the desire to reuse this
infrastructure for qemu platform testing, but I believe this move makes
sense independently of that. Moving this code to the packages tree will
allow as to add more structure to the gdb client tests -- currently they
are all crammed into the same test folder as that was the only way they
could access this code.

I'm splitting the code into two parts while moving it. The first once
contains just the generic gdb protocol wrappers, while the other one
contains the unit test glue. The reason for that is that for qemu
testing, I need to run the gdb code in a separate process, so I will
only be using the first part there.

[mgorny]

Are there any changes to the code you've moved that we should look at?

[labath]

Nope. In fact, if you look closely, you'll see that phabricator highlights the entire lldbgdbclient.py file as being moved from the original file. :)

I will need to make some changes to this code, but I'll do that as a separate patch.

[mgorny]

LGTM then.

lldb/packages/Python/lldbsuite/test/gdbclientutils.py

 import ctypes
 import errno
 import io
-import os
-import os.path
 import threading
 import socket
-import lldb
-import binascii
 import traceback
 from lldbsuite.support import seven
-from lldbsuite.test.lldbtest import *
-from lldbsuite.test import lldbtest_config
-
 
 def checksum(message):
     """
     Calculate the GDB server protocol checksum of the message.
 
     The GDB server protocol uses a simple modulo 256 sum.
     """
     check = 0
def _handlePacket(self, packet):
             self._socket.sendall(seven.bitcast_to_bytes(framed))
 
     PACKET_ACK = object()
     PACKET_INTERRUPT = object()
 
     class InvalidPacketException(Exception):
         pass
 
-
-class GDBRemoteTestBase(TestBase):
-    """
-    Base class for GDB client tests.
-
-    This class will setup and start a mock GDB server for the test to use.
-    It also provides assertPacketLogContains, which simplifies the checking
-    of packets sent by the client.
-    """
-
-    NO_DEBUG_INFO_TESTCASE = True
-    mydir = TestBase.compute_mydir(__file__)
-    server = None
-    server_socket_class = TCPServerSocket
-
-    def setUp(self):
-        TestBase.setUp(self)
-        self.server = MockGDBServer(socket_class=self.server_socket_class)
-        self.server.start()
-
-    def tearDown(self):
-        # TestBase.tearDown will kill the process, but we need to kill it early
-        # so its client connection closes and we can stop the server before
-        # finally calling the base tearDown.
-        if self.process() is not None:
-            self.process().Kill()
-        self.server.stop()
-        TestBase.tearDown(self)
-
-    def createTarget(self, yaml_path):
-        """
-        Create a target by auto-generating the object based on the given yaml
-        instructions.
-
-        This will track the generated object so it can be automatically removed
-        during tearDown.
-        """
-        yaml_base, ext = os.path.splitext(yaml_path)
-        obj_path = self.getBuildArtifact(yaml_base)
-        self.yaml2obj(yaml_path, obj_path)
-        return self.dbg.CreateTarget(obj_path)
-
-    def connect(self, target):
-        """
-        Create a process by connecting to the mock GDB server.
-
-        Includes assertions that the process was successfully created.
-        """
-        listener = self.dbg.GetListener()
-        error = lldb.SBError()
-        process = target.ConnectRemote(listener,
-                self.server.get_connect_url(), "gdb-remote", error)
-        self.assertTrue(error.Success(), error.description)
-        self.assertTrue(process, PROCESS_IS_VALID)
-        return process
-
-    def assertPacketLogContains(self, packets):
-        """
-        Assert that the mock server's packet log contains the given packets.
-
-        The packet log includes all packets sent by the client and received
-        by the server.  This fuction makes it easy to verify that the client
-        sent the expected packets to the server.
-
-        The check does not require that the packets be consecutive, but does
-        require that they are ordered in the log as they ordered in the arg.
-        """
-        i = 0
-        j = 0
-        log = self.server.responder.packetLog
-
-        while i < len(packets) and j < len(log):
-            if log[j] == packets[i]:
-                i += 1
-            j += 1
-        if i < len(packets):
-            self.fail(u"Did not receive: %s\nLast 10 packets:\n\t%s" %
-                    (packets[i], u'\n\t'.join(log)))
-
-
-class GDBPlatformClientTestBase(GDBRemoteTestBase):
-    """
-    Base class for platform server clients.
-
-    This class extends GDBRemoteTestBase by automatically connecting
-    via "platform connect" in the setUp() method.
-    """
-
-    def setUp(self):
-        super().setUp()
-        self.runCmd("platform select remote-gdb-server")
-        self.runCmd("platform connect " + self.server.get_connect_url())
-        self.assertTrue(self.dbg.GetSelectedPlatform().IsConnected())
-
-    def tearDown(self):
-        self.dbg.GetSelectedPlatform().DisconnectRemote()
-        super().tearDown()

lldb/packages/Python/lldbsuite/test/lldbgdbclient.py

+import os
+import os.path
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.gdbclientutils import *
+
+class GDBRemoteTestBase(TestBase):
+    """
+    Base class for GDB client tests.
+
+    This class will setup and start a mock GDB server for the test to use.
+    It also provides assertPacketLogContains, which simplifies the checking
+    of packets sent by the client.
+    """
+
+    NO_DEBUG_INFO_TESTCASE = True
+    server = None
+    server_socket_class = TCPServerSocket
+
+    def setUp(self):
+        TestBase.setUp(self)
+        self.server = MockGDBServer(socket_class=self.server_socket_class)
+        self.server.start()
+
+    def tearDown(self):
+        # TestBase.tearDown will kill the process, but we need to kill it early
+        # so its client connection closes and we can stop the server before
+        # finally calling the base tearDown.
+        if self.process() is not None:
+            self.process().Kill()
+        self.server.stop()
+        TestBase.tearDown(self)
+
+    def createTarget(self, yaml_path):
+        """
+        Create a target by auto-generating the object based on the given yaml
+        instructions.
+
+        This will track the generated object so it can be automatically removed
+        during tearDown.
+        """
+        yaml_base, ext = os.path.splitext(yaml_path)
+        obj_path = self.getBuildArtifact(yaml_base)
+        self.yaml2obj(yaml_path, obj_path)
+        return self.dbg.CreateTarget(obj_path)
+
+    def connect(self, target):
+        """
+        Create a process by connecting to the mock GDB server.
+
+        Includes assertions that the process was successfully created.
+        """
+        listener = self.dbg.GetListener()
+        error = lldb.SBError()
+        process = target.ConnectRemote(listener,
+                self.server.get_connect_url(), "gdb-remote", error)
+        self.assertTrue(error.Success(), error.description)
+        self.assertTrue(process, PROCESS_IS_VALID)
+        return process
+
+    def assertPacketLogContains(self, packets):
+        """
+        Assert that the mock server's packet log contains the given packets.
+
+        The packet log includes all packets sent by the client and received
+        by the server.  This fuction makes it easy to verify that the client
+        sent the expected packets to the server.
+
+        The check does not require that the packets be consecutive, but does
+        require that they are ordered in the log as they ordered in the arg.
+        """
+        i = 0
+        j = 0
+        log = self.server.responder.packetLog
+
+        while i < len(packets) and j < len(log):
+            if log[j] == packets[i]:
+                i += 1
+            j += 1
+        if i < len(packets):
+            self.fail(u"Did not receive: %s\nLast 10 packets:\n\t%s" %
+                    (packets[i], u'\n\t'.join(log)))
+
+
+class GDBPlatformClientTestBase(GDBRemoteTestBase):
+    """
+    Base class for platform server clients.
+
+    This class extends GDBRemoteTestBase by automatically connecting
+    via "platform connect" in the setUp() method.
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.runCmd("platform select remote-gdb-server")
+        self.runCmd("platform connect " + self.server.get_connect_url())
+        self.assertTrue(self.dbg.GetSelectedPlatform().IsConnected())
+
+    def tearDown(self):
+        self.dbg.GetSelectedPlatform().DisconnectRemote()
+        super().tearDown()

lldb/test/API/functionalities/gdb_remote_client/TestAArch64XMLRegOffsets.py

 from __future__ import print_function
 from textwrap import dedent
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 
 class MyResponder(MockGDBServerResponder):
     def qXferRead(self, obj, annex, offset, length):
         if annex == "target.xml":
             return dedent("""\
                 <?xml version="1.0"?>
                   <target version="1.0">
def readRegister(self, regnum):
         return "E01"
 
     def readRegisters(self):
         return "20000000000000002000000000000000f0c154bfffff00005daa985a8fea0b48f0b954bfffff0000ad13cce570150b48380000000000000070456abfffff0000a700000000000000000000000000000001010101010101010000000000000000f0c154bfffff00000f2700000000000008e355bfffff0000080e55bfffff0000281041000000000010de61bfffff00005c05000000000000f0c154bfffff000090fcffffffff00008efcffffffff00008ffcffffffff00000000000000000000001000000000000090fcffffffff000000d06cbfffff0000f0c154bfffff00000100000000000000d0b954bfffff0000e407400000000000d0b954bfffff0000e40740000000000000100000"
 
 
 class TestAArch64XMLRegOffsets(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @skipIfXmlSupportMissing
     @skipIfRemote
     @skipIfLLVMTargetMissing("AArch64")
     def test_register_gpacket_offsets(self):
         """
         Test that we correctly associate the register info with the eh_frame
         register numbers.
         """

lldb/test/API/functionalities/gdb_remote_client/TestArmRegisterDefinition.py

 from __future__ import print_function
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 class TestArmRegisterDefinition(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @skipIfXmlSupportMissing
     @skipIfRemote
     def test(self):
         """
         Test lldb's parsing of the <architecture> tag in the target.xml register
         description packet.
         """
         class MyResponder(MockGDBServerResponder):

lldb/test/API/functionalities/gdb_remote_client/TestFork.py

 from __future__ import print_function
 import lldb
 import unittest
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 
 class TestMultiprocess(GDBRemoteTestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
     def base_test(self, variant):
         class MyResponder(MockGDBServerResponder):
             def __init__(self):
                 super().__init__()
                 self.first = True
                 self.detached = None
                 self.property = "{}-events+".format(variant)
 

lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteClient.py

 import lldb
 import binascii
 import os.path
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 
 class TestGDBRemoteClient(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     class gPacketResponder(MockGDBServerResponder):
         registers = [
             "name:rax;bitsize:64;offset:0;encoding:uint;format:hex;set:General Purpose Registers;ehframe:0;dwarf:0;",
             "name:rbx;bitsize:64;offset:8;encoding:uint;format:hex;set:General Purpose Registers;ehframe:3;dwarf:3;",
             "name:rcx;bitsize:64;offset:16;encoding:uint;format:hex;set:General Purpose Registers;ehframe:2;dwarf:2;generic:arg4;",
             "name:rdx;bitsize:64;offset:24;encoding:uint;format:hex;set:General Purpose Registers;ehframe:1;dwarf:1;generic:arg3;",
             "name:rdi;bitsize:64;offset:32;encoding:uint;format:hex;set:General Purpose Registers;ehframe:5;dwarf:5;generic:arg1;",
             "name:rsi;bitsize:64;offset:40;encoding:uint;format:hex;set:General Purpose Registers;ehframe:4;dwarf:4;generic:arg2;",

lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteDiskFileCompletion.py

-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBPlatformClientTestBase
 
 class TestGDBRemoteDiskFileCompletion(GDBPlatformClientTestBase):
 
+    mydir = GDBPlatformClientTestBase.compute_mydir(__file__)
+
     def test_autocomplete_request(self):
         """Test remote disk completion on remote-gdb-server plugin"""
 
         class Responder(MockGDBServerResponder):
             def qPathComplete(self):
                 return "M{},{}".format(
                     "test".encode().hex(),
                     "123".encode().hex()

lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteLoad.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 
 class TestGDBRemoteLoad(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @expectedFailureAll(archs=["aarch64"], oslist=["freebsd"],
                         bugnumber="llvm.org/pr49414")
     def test_module_load_address(self):
         """Test that setting the load address of a module uses virtual addresses"""
         target = self.createTarget("a.yaml")
         process = self.connect(target)
         module = target.GetModuleAtIndex(0)
         self.assertTrue(module.IsValid())

lldb/test/API/functionalities/gdb_remote_client/TestGDBRemotePlatformFile.py

-from gdbclientutils import *
-
+from lldbsuite.test.gdbclientutils import *
 from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbgdbclient import GDBPlatformClientTestBase
 
 class TestGDBRemotePlatformFile(GDBPlatformClientTestBase):
 
+    mydir = GDBPlatformClientTestBase.compute_mydir(__file__)
+
     def test_file(self):
         """Test mock operations on a remote file"""
 
         class Responder(MockGDBServerResponder):
             def vFile(self, packet):
                 if packet.startswith("vFile:open:"):
                     return "F10"
                 elif packet.startswith("vFile:pread:"):

lldb/test/API/functionalities/gdb_remote_client/TestGDBServerTargetXML.py

 from __future__ import print_function
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 
 class TestGDBServerTargetXML(GDBRemoteTestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
     @skipIfXmlSupportMissing
     @skipIfRemote
     @skipIfLLVMTargetMissing("X86")
     def test_x86_64_regs(self):
         """Test grabbing various x86_64 registers from gdbserver."""
         class MyResponder(MockGDBServerResponder):
             reg_data = (
                 "0102030405060708"  # rcx

lldb/test/API/functionalities/gdb_remote_client/TestIOSSimulator.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 class TestIOSSimulator(GDBRemoteTestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
     """
     Test that an ios simulator process is recognized as such.
     """
 
     class MyResponder(MockGDBServerResponder):
         def __init__(self, host, process):
             self.host_ostype = host
             self.process_ostype = process

lldb/test/API/functionalities/gdb_remote_client/TestJLink6Armv7RegisterDefinition.py

 from __future__ import print_function
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 class TestJLink6Armv7RegisterDefinition(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @skipIfXmlSupportMissing
     @skipIfRemote
     def test(self):
         """
         Test lldb's parsing of SEGGER J-Link v6.54 register
         definition for a Cortex M-4 dev board, and the fact
         that the J-Link only supports g/G for reading/writing
         register AND the J-Link v6.54 doesn't provide anything

lldb/test/API/functionalities/gdb_remote_client/TestMemoryRegionDirtyPages.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 
 class TestMemoryRegionDirtyPages(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @skipIfXmlSupportMissing
     def test(self):
         class MyResponder(MockGDBServerResponder):
 
             def qHostInfo(self):
                 return "ptrsize:8;endian:little;vm-page-size:4096;"
 
             def qMemoryRegionInfo(self, addr):

lldb/test/API/functionalities/gdb_remote_client/TestMultiprocess.py

 from __future__ import print_function
 import lldb
 import unittest
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 
 class TestMultiprocess(GDBRemoteTestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
     def test_qfThreadInfo(self):
         class MyResponder(MockGDBServerResponder):
             def qfThreadInfo(self):
                 return "mp400.10200,p400.10204,p401.10300,p400.10208"
 
         self.server.responder = MyResponder()
         target = self.dbg.CreateTarget('')
         if self.TraceOn():

lldb/test/API/functionalities/gdb_remote_client/TestNestedRegDefinitions.py

 from __future__ import print_function
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 class TestNestedRegDefinitions(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @skipIfXmlSupportMissing
     @skipIfRemote
     def test(self):
         """
         Test lldb's parsing of the <architecture> tag in the target.xml register
         description packet.
         """
         class MyResponder(MockGDBServerResponder):

lldb/test/API/functionalities/gdb_remote_client/TestNoGPacketSupported.py

 from __future__ import print_function
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 
 # This test case is testing three things:
 #
 #  1. three register values will be provided in the ? stop packet (T11) -
 #     registers 0 ("rax"), 1 ("rbx"), and 3 ("rip")
 #  2. ReadRegister packet will provide the value of register 2 ("rsi")
 #  3. The "g" read-all-registers packet is not supported; p must be used
 #     to get the value of register 2 ("rsi")
 #
 # Forcing lldb to use the expedited registers in the stop packet and
 # marking it an error to request that register value is to prevent
 # performance regressions.
 # 
 # Some gdb RSP stubs only implement p/P, they do not support g/G.
 # lldb must be able to work with either.
 
 class TestNoGPacketSupported(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @skipIfXmlSupportMissing
     def test(self):
         class MyResponder(MockGDBServerResponder):
             def haltReason(self):
                 return "T02thread:1ff0d;threads:1ff0d;thread-pcs:000000010001bc00;00:7882773ce0ffffff;01:1122334455667788;03:00bc010001000000;"
 
             def threadStopInfo(self, threadnum):
                 return "T02thread:1ff0d;threads:1ff0d;thread-pcs:000000010001bc00;00:7882773ce0ffffff;01:1122334455667788;03:00bc010001000000;"

lldb/test/API/functionalities/gdb_remote_client/TestNoWatchpointSupportInfo.py

 from __future__ import print_function
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 class TestNoWatchpointSupportInfo(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @skipIfXmlSupportMissing
     @skipIfRemote
     def test(self):
         """
         Test lldb's parsing of the <architecture> tag in the target.xml register
         description packet.
         """
         class MyResponder(MockGDBServerResponder):

lldb/test/API/functionalities/gdb_remote_client/TestPartialGPacket.py

 from __future__ import print_function
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 
 class TestPartialGPacket(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @skipIfXmlSupportMissing
     @skipIfRemote
     def test(self):
         """
         Test GDB remote fallback to 'p' packet when 'g' packet does not include all registers.
         """
         class MyResponder(MockGDBServerResponder):
 

lldb/test/API/functionalities/gdb_remote_client/TestPlatformClient.py

 import lldb
 import binascii
 import os
 import time
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 def hexlify(string):
     return binascii.hexlify(string.encode()).decode()
 
 class TestPlatformClient(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     def test_process_list_with_all_users(self):
         """Test connecting to a remote linux platform"""
 
         class MyResponder(MockGDBServerResponder):
             def __init__(self):
                 MockGDBServerResponder.__init__(self)
                 self.currentQsProc = 0
                 self.all_users = False

lldb/test/API/functionalities/gdb_remote_client/TestPlatformKill.py

 import lldb
 import time
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 class TestPlatformKill(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @skipIfRemote
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr52451")
     def test_kill_different_platform(self):
         """Test connecting to a remote linux platform"""
 
         self.build(dictionary={"CXX_SOURCES":"sleep.cpp"})
         host_process = self.spawnSubprocess(self.getBuildArtifact())
 

lldb/test/API/functionalities/gdb_remote_client/TestProcessConnect.py

 import lldb
 import binascii
 import os
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 
 @skipIfRemote
 class TestProcessConnect(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_gdb_remote_sync(self):
         """Test the gdb-remote command in synchronous mode"""
         try:
             self.dbg.SetAsync(False)
             self.expect("gdb-remote " + self.server.get_connect_address(),
                         substrs=['Process', 'stopped'])

lldb/test/API/functionalities/gdb_remote_client/TestPty.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 
 @skipIfWindows
 class TestPty(GDBRemoteTestBase):
     mydir = TestBase.compute_mydir(__file__)
     server_socket_class = PtyServerSocket
 
     def get_term_attrs(self):

lldb/test/API/functionalities/gdb_remote_client/TestQemuAArch64TargetXml.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
 from textwrap import dedent
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 class MyResponder(MockGDBServerResponder):
     def qXferRead(self, obj, annex, offset, length):
         if annex == "target.xml":
             return dedent("""\
                 <?xml version="1.0"?>
                   <target version="1.0">
                     <architecture>aarch64</architecture>
def qXferRead(self, obj, annex, offset, length):
                     </feature>
                   </target>
                 """), False
         else:
             return None, False
 
 class TestQemuAarch64TargetXml(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @skipIfXmlSupportMissing
     @skipIfRemote
     @skipIfLLVMTargetMissing("AArch64")
     def test_register_augmentation(self):
         """
         Test that we correctly associate the register info with the eh_frame
         register numbers.
         """

lldb/test/API/functionalities/gdb_remote_client/TestRecognizeBreakpoint.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 
 class TestRecognizeBreakpoint(GDBRemoteTestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
     """ This tests the case where the gdb-remote server doesn't support any
         of the thread-info packets, and just tells which thread got the stop
         signal with:
               T05thread:01;
         There was a bug in lldb that we would set the stop reason from this 
         packet too early - before we had updated the thread list.  So when we
         later updated the thread list, we would throw away this info.  Normally
         we would be able to reconstruct it from the thread info, but not if the

lldb/test/API/functionalities/gdb_remote_client/TestRegDefinitionInParts.py

 from __future__ import print_function
 import lldb
 import time
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 class TestRegDefinitionInParts(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @skipIfXmlSupportMissing
     @skipIfRemote
     def test(self):
         """
         Test that lldb correctly fetches the target definition file
         in multiple chunks if the remote server only provides the 
         content in small parts, and the small parts it provides is
         smaller than the maximum packet size that it declared at

lldb/test/API/functionalities/gdb_remote_client/TestRemoteRegNums.py

 from __future__ import print_function
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 
 # This test case checks for register number mismatch between lldb and gdb stub.
 # LLDB client assigns register numbers to target xml registers in increasing
 # order starting with regnum = 0, while gdb-remote may specify different regnum
 # which is stored as eRegisterKindProcessPlugin. Remote side will use its
 # register number in expedited register list, value_regs and invalidate_regnums.
 #
 # This test creates a ficticious target xml with non-sequential regnums to test
 # that correct registers are accessed in all of above mentioned cases.
 
 class TestRemoteRegNums(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @skipIfXmlSupportMissing
     def test(self):
         class MyResponder(MockGDBServerResponder):
             def haltReason(self):
                 return "T02thread:1ff0d;threads:1ff0d;thread-pcs:000000010001bc00;00:00bc010001000000;09:c04825ebfe7f0000;"
 
             def threadStopInfo(self, threadnum):
                 return "T02thread:1ff0d;threads:1ff0d;thread-pcs:000000010001bc00;00:00bc010001000000;09:c04825ebfe7f0000;"

lldb/test/API/functionalities/gdb_remote_client/TestRestartBug.py

 from __future__ import print_function
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 
 class TestRestartBug(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @expectedFailureAll(bugnumber="llvm.org/pr24530")
     def test(self):
         """
         Test auto-continue behavior when a process is interrupted to deliver
         an "asynchronous" packet. This simulates the situation when a process
         stops on its own just as lldb client is about to interrupt it. The
         client should not auto-continue in this case, unless the user has
         explicitly requested that we ignore signals of this type.

lldb/test/API/functionalities/gdb_remote_client/TestStopPCs.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 
 class TestStopPCs(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @skipIfXmlSupportMissing
     def test(self):
         class MyResponder(MockGDBServerResponder):
             def haltReason(self):
                 return "T02thread:1ff0d;threads:1ff0d,2ff0d;thread-pcs:10001bc00,10002bc00;"
 
             def threadStopInfo(self, threadnum):
                 if threadnum == 0x1ff0d:

lldb/test/API/functionalities/gdb_remote_client/TestTargetXMLArch.py

 from __future__ import print_function
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 class MyResponder(MockGDBServerResponder):
     def qXferRead(self, obj, annex, offset, length):
         if annex == "target.xml":
             return """<?xml version="1.0"?>
                 <target version="1.0">
                   <architecture>i386:x86-64</architecture>
                   <feature name="org.gnu.gdb.i386.core">
def readRegister(self, register):
                 0x10: "c0d7bf1b80ffffff" }
         if register in regs:
             return regs[register]
         else:
             return "0000000000000000"
 
 class TestTargetXMLArch(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @skipIfXmlSupportMissing
     @expectedFailureAll(archs=["i386"])
     @skipIfRemote
     def test(self):
         """
         Test lldb's parsing of the <architecture> tag in the target.xml register
         description packet.
         """

lldb/test/API/functionalities/gdb_remote_client/TestThreadInfoTrailingComma.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
-
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 class TestThreadInfoTrailingComma(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     def test(self):
         class MyResponder(MockGDBServerResponder):
             def haltReason(self):
                 return "T02thread:1"
 
             def qfThreadInfo(self):
                 return "m1,2,3,4,"
 

lldb/test/API/functionalities/gdb_remote_client/TestThreadSelectionBug.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 
 class TestThreadSelectionBug(GDBRemoteTestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
     def test(self):
         class MyResponder(MockGDBServerResponder):
             def cont(self):
                 # Simulate process stopping due to a raise(SIGINT)
                 return "T01reason:signal"
 
         self.server.responder = MyResponder()
         target = self.createTarget("a.yaml")

lldb/test/API/functionalities/gdb_remote_client/TestWasm.py

 import lldb
 import binascii
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 LLDB_INVALID_ADDRESS = lldb.LLDB_INVALID_ADDRESS
 load_address = 0x400000000
 
 def format_register_value(val):
     """
     Encode each byte by two hex digits in little-endian order.
     """
def readMemory(self, addr, length):
             for i in range(addr_from, addr_to):
                 result += format(file_content[i], '02x')
             file.close()
         return result
 
 
 class TestWasm(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @skipIfAsan
     @skipIfXmlSupportMissing
     def test_load_module_with_embedded_symbols_from_remote(self):
         """Test connecting to a WebAssembly engine via GDB-remote and loading a Wasm module with embedded DWARF symbols"""
 
         yaml_path = "test_wasm_embedded_debug_sections.yaml"
         yaml_base, ext = os.path.splitext(yaml_path)
         obj_path = self.getBuildArtifact(yaml_base)

lldb/test/API/functionalities/gdb_remote_client/TestWriteMemory.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
-
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 class TestWriteMemory(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     def test(self):
 
         class MyResponder(MockGDBServerResponder):
             def setBreakpoint(self, packet):
                 return "OK"
 
         self.server.responder = MyResponder()
         target = self.dbg.CreateTargetWithFileAndTargetTriple('', 'x86_64-pc-linux')

lldb/test/API/functionalities/gdb_remote_client/TestqOffsets.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
-from gdbclientutils import *
-
+from lldbsuite.test.gdbclientutils import *
+from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
 class TestqOffsets(GDBRemoteTestBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     class Responder(MockGDBServerResponder):
         def qOffsets(self):
             return 'Text=470000;Data=470000'
 
     def test(self):
         self.server.responder = TestqOffsets.Responder()
         target = self.createTarget("qOffsets.yaml")
         text = target.modules[0].FindSection(".text")
         self.assertEquals(text.GetLoadAddress(target), lldb.LLDB_INVALID_ADDRESS)
 
         process = self.connect(target)
         self.assertEquals(text.GetLoadAddress(target), 0x471000)