Restore tests for lldb-server and lldb-vscode removed at rL366590

[aadsm]

Summary

This was removed here rL366590 by accident.

[xiaobai]

Thanks for restoring them.

[labath]

Thanks.

[teemperor]

Thanks for restoring this, but I'm a bit confused how this has happened. My original diff didn't remove these folders, but it seems when I committed the diff via arcanist and git llvm it also removed these other folders. I assume git llvm is when translating the change to SVN not just removing a folder but also all folders in the same directory?

[labath]

In D65123#1596935, @teemperor wrote:

Thanks for restoring this, but I'm a bit confused how this has happened. My original diff didn't remove these folders, but it seems when I committed the diff via arcanist and git llvm it also removed these other folders. I assume git llvm is when translating the change to SVN not just removing a folder but also all folders in the same directory?

Interesting.. I wouldn't be totally surprised by that as git-llvm does some magic to svn check out only the files/directories that have been modified. Combining that with the different treatment of directories in svn and git (explicit modelling vs. implicit "it exists if it contains a file"), I can see how things might go south in some corner cases like this. But that's just speculation -- I'm generally trying to avoid git-llvm as it is too magical for my taste. Maybe @jyknight or @mehdi_amini can shed more light on this?

[jankratochvil]

I was glad the vscode testcases are gone as they are racy causing many false failures on our Fedora buildbot always hanging until the whole testsuite gets killed:

1910 ?        Sl     0:00          |   \_ /usr/bin/python /home/jkratoch/slave-lldb-x86_64-fedora/lldb-x86_64-fedora/llvm/tools/lldb/test/dotest.py -q --arch=x86_64 -s /home/jkratoch/slave-lldb-x86_64-fedora/lldb-x86_64-fedora/build/lldb-test-traces --build-dir /home/jkratoch/slave-lldb-x86_64-fedora/lldb-x86_64-fedora/build/lldb-test-build.noindex -S nm -u CXXFLAGS -u CFLAGS --executable /home/jkratoch/slave-lldb-x86_64-fedora/lldb-x86_64-fedora/build/./bin/lldb --dsymutil /home/jkratoch/slave-lldb-x86_64-fedora/lldb-x86_64-fedora/build/./bin/dsymutil --filecheck /home/jkratoch/slave-lldb-x86_64-fedora/lldb-x86_64-fedora/build/./bin/FileCheck -C /home/jkratoch/slave-lldb-x86_64-fedora/lldb-x86_64-fedora/build/./bin/clang --env ARCHIVER=/usr/bin/ar --env OBJCOPY=/usr/bin/objcopy --env LLVM_LIBS_DIR=/home/jkratoch/slave-lldb-x86_64-fedora/lldb-x86_64-fedora/build/./lib /home/jkratoch/slave-lldb-x86_64-fedora/lldb-x86_64-fedora/llvm/tools/lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/breakpoint -p TestVSCode_setBreakpoints.py
2649 ?        Sl     0:00          |       \_ /home/jkratoch/slave-lldb-x86_64-fedora/lldb-x86_64-fedora/build/bin/lldb-vscode
2690 ?        S      0:00          |           \_ /home/jkratoch/slave-lldb-x86_64-fedora/lldb-x86_64-fedora/build/bin/lldb-server gdbserver --fd=9 --native-regs --setsid
2708 ?        t      0:00          |               \_ /home/jkratoch/slave-lldb-x86_64-fedora/lldb-x86_64-fedora/build/lldb-test-build.noindex/tools/lldb-vscode/breakpoint/TestVSCode_setBreakpoints.test_functionality/a.out

I have checked the lldb-vscode server does print:

{"body":{"allThreadsStopped":true,"preserveFocusHint":false,"reason":"breakpoint","threadCausedFocus":true,"threadId":10215},"event":"stopped","seq":0,"type":"event"}

But then lldb itself waits forever for the breakpoint hit, unaware why so far. The problem debugging it is that it happens only on slow hosts where it is difficult to run the testsuite on LLDB built with full DWARF.
If someone has an idea, otherwise we (with @kwk) will continue debugging it.

[jyknight]

In D65123#1596983, @labath wrote:

In D65123#1596935, @teemperor wrote:

Thanks for restoring this, but I'm a bit confused how this has happened. My original diff didn't remove these folders, but it seems when I committed the diff via arcanist and git llvm it also removed these other folders. I assume git llvm is when translating the change to SVN not just removing a folder but also all folders in the same directory?

Interesting.. I wouldn't be totally surprised by that as git-llvm does some magic to svn check out only the files/directories that have been modified. Combining that with the different treatment of directories in svn and git (explicit modelling vs. implicit "it exists if it contains a file"), I can see how things might go south in some corner cases like this. But that's just speculation -- I'm generally trying to avoid git-llvm as it is too magical for my taste. Maybe @jyknight or @mehdi_amini can shed more light on this?

Reproduced this bug, and working on a fix.

[aadsm]

@jankratochvil interesting, we're also not able to run the lldb-vscode tests and it was on my todo list to take a look. Although I didn't realize it was a common think I thought it was specific to the environment where I was trying to run them. /cc @xiaobai. Thanks for looking into this!

[jankratochvil]

In D65123#1597742, @aadsm wrote:

@jankratochvil interesting, we're also not able to run the lldb-vscode tests and it was on my todo list to take a look.

It is hanging in vscode.py function recv_packet somehow despite the packet type=event event=stopped is received by the other Python thread (and put into recv_packets) it somehow never quits the loop.

[Hui]

Any chance to restore the tracking history as well?

[jankratochvil]

In D65123#1597229, @jankratochvil wrote:

I was glad the vscode testcases are gone as they are racy causing many false failures on our Fedora buildbot always hanging until the whole testsuite gets killed:

That should be fixed now by D65163.

[aadsm]

@Hui what do you mean? the history is still there:

$ git log lldb/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py
commit a61c247ce189efe7641dccb8ad7f85f60fc72220 (master)
Author: Antonio Afonso <[e-mail]>
Date:   Mon Jul 22 23:35:05 2019 +0000

    Restore tests for lldb-server and lldb-vscode removed at rL366590

commit b45853f173139c7c3078b97f53e7a6eba6148c13
Author: Raphael Isemann <[e-mail]>
Date:   Fri Jul 19 15:55:23 2019 +0000

    [lldb][NFC] Cleanup mentions and code related to lldb-mi

commit 08c38f77c5fb4d3735ec215032fed8ee6730b3db
Author: Pavel Labath <[e-mail]>
Date:   Mon Jul 1 12:41:20 2019 +0000

    Revert "Implement xfer:libraries-svr4:read packet"
...

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/.clang-format

+BasedOnStyle: LLVM

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/Makefile

+LEVEL = ../../make
+
+override CFLAGS_EXTRAS += -D__STDC_LIMIT_MACROS -D__STDC_FORMAT_MACROS
+ENABLE_THREADS := YES
+CXX_SOURCES := main.cpp
+MAKE_DSYM :=NO
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestAppleSimulatorOSType.py

+from __future__ import print_function
+
+
+import gdbremote_testcase
+import lldbgdbserverutils
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+import json
+
+class TestAppleSimulatorOSType(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def check_simulator_ostype(self, sdk, platform, arch='x86_64'):
+        sim_devices_str = subprocess.check_output(['xcrun', 'simctl', 'list',
+                                                   '-j', 'devices']).decode("utf-8")
+        sim_devices = json.loads(sim_devices_str)['devices']
+        # Find an available simulator for the requested platform
+        deviceUDID = None
+        for simulator in sim_devices:
+            if isinstance(simulator,dict):
+                runtime = simulator['name']
+                devices = simulator['devices']
+            else:
+                runtime = simulator
+                devices = sim_devices[simulator]
+            if not platform in runtime.lower():
+                continue
+            for device in devices:
+                if 'availability' in device and device['availability'] != '(available)':
+                    continue
+                if 'isAvailable' in device and device['isAvailable'] != True:
+                    continue
+                deviceUDID = device['udid']
+                break
+            if deviceUDID != None:
+                break
+
+        # Launch the process using simctl
+        self.assertIsNotNone(deviceUDID)
+        exe_name = 'test_simulator_platform_{}'.format(platform)
+        sdkroot = subprocess.check_output(['xcrun', '--show-sdk-path', '--sdk',
+                                           sdk]).decode("utf-8")
+        self.build(dictionary={ 'EXE': exe_name, 'SDKROOT': sdkroot.strip(),
+                                'ARCH': arch })
+        exe_path = self.getBuildArtifact(exe_name)
+        sim_launcher = subprocess.Popen(['xcrun', 'simctl', 'spawn',
+                                         deviceUDID, exe_path,
+                                         'print-pid', 'sleep:10'],
+                                        stderr=subprocess.PIPE)
+        # Get the PID from the process output
+        pid = None
+        while not pid:
+            stderr = sim_launcher.stderr.readline().decode("utf-8")
+            if stderr == '':
+                continue
+            m = re.match(r"PID: (.*)", stderr)
+            self.assertIsNotNone(m)
+            pid = int(m.group(1))
+
+        # Launch debug monitor attaching to the simulated process
+        self.init_debugserver_test()
+        server = self.connect_to_debug_monitor(attach_pid=pid)
+
+        # Setup packet sequences
+        self.add_no_ack_remote_stream()
+        self.add_process_info_collection_packets()
+        self.test_sequence.add_log_lines(
+            ["read packet: " +
+             "$jGetLoadedDynamicLibrariesInfos:{\"fetch_all_solibs\" : true}]#ce",
+             {"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$",
+              "capture": {1: "dylib_info_raw"}}],
+            True)
+
+        # Run the stream
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Gather process info response
+        process_info = self.parse_process_info_response(context)
+        self.assertIsNotNone(process_info)
+
+        # Check that ostype is correct
+        self.assertEquals(process_info['ostype'], platform)
+
+        # Now for dylibs
+        dylib_info_raw = context.get("dylib_info_raw")
+        dylib_info = json.loads(self.decode_gdbremote_binary(dylib_info_raw))
+        images = dylib_info['images']
+
+        image_info = None
+        for image in images:
+            if image['pathname'] != exe_path:
+                continue
+            image_info = image
+            break
+
+        self.assertIsNotNone(image_info)
+        self.assertEquals(image['min_version_os_name'], platform)
+
+
+    @apple_simulator_test('iphone')
+    @debugserver_test
+    @skipIfDarwinEmbedded
+    def test_simulator_ostype_ios(self):
+        self.check_simulator_ostype(sdk='iphonesimulator',
+                                    platform='ios')
+
+    @apple_simulator_test('appletv')
+    @debugserver_test
+    @skipIfDarwinEmbedded
+    def test_simulator_ostype_tvos(self):
+        self.check_simulator_ostype(sdk='appletvsimulator',
+                                    platform='tvos')
+
+    @apple_simulator_test('watch')
+    @debugserver_test
+    @skipIfDarwinEmbedded
+    def test_simulator_ostype_watchos(self):
+        self.check_simulator_ostype(sdk='watchsimulator',
+                                    platform='watchos', arch='i386')

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteAttach.py

+from __future__ import print_function
+
+
+import gdbremote_testcase
+import lldbgdbserverutils
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestGdbRemoteAttach(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def attach_with_vAttach(self):
+        # Start the inferior, start the debug monitor, nothing is attached yet.
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=["sleep:60"])
+        self.assertIsNotNone(procs)
+
+        # Make sure the target process has been launched.
+        inferior = procs.get("inferior")
+        self.assertIsNotNone(inferior)
+        self.assertTrue(inferior.pid > 0)
+        self.assertTrue(
+            lldbgdbserverutils.process_is_running(
+                inferior.pid, True))
+
+        # Add attach packets.
+        self.test_sequence.add_log_lines([
+            # Do the attach.
+            "read packet: $vAttach;{:x}#00".format(inferior.pid),
+            # Expect a stop notification from the attach.
+            {"direction": "send",
+             "regex": r"^\$T([0-9a-fA-F]{2})[^#]*#[0-9a-fA-F]{2}$",
+             "capture": {1: "stop_signal_hex"}},
+        ], True)
+        self.add_process_info_collection_packets()
+
+        # Run the stream
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Gather process info response
+        process_info = self.parse_process_info_response(context)
+        self.assertIsNotNone(process_info)
+
+        # Ensure the process id matches what we expected.
+        pid_text = process_info.get('pid', None)
+        self.assertIsNotNone(pid_text)
+        reported_pid = int(pid_text, base=16)
+        self.assertEqual(reported_pid, inferior.pid)
+
+    @debugserver_test
+    def test_attach_with_vAttach_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_attach_manually()
+        self.attach_with_vAttach()
+
+    @llgs_test
+    def test_attach_with_vAttach_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_attach_manually()
+        self.attach_with_vAttach()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteAuxvSupport.py

+from __future__ import print_function
+
+
+import gdbremote_testcase
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestGdbRemoteAuxvSupport(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    AUXV_SUPPORT_FEATURE_NAME = "qXfer:auxv:read"
+
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def has_auxv_support(self):
+        inferior_args = ["message:main entered", "sleep:5"]
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=inferior_args)
+
+        # Don't do anything until we match the launched inferior main entry output.
+        # Then immediately interrupt the process.
+        # This prevents auxv data being asked for before it's ready and leaves
+        # us in a stopped state.
+        self.test_sequence.add_log_lines([
+            # Start the inferior...
+            "read packet: $c#63",
+            # ... match output....
+            {"type": "output_match", "regex": self.maybe_strict_output_regex(
+                r"message:main entered\r\n")},
+        ], True)
+        # ... then interrupt.
+        self.add_interrupt_packets()
+        self.add_qSupported_packets()
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        features = self.parse_qSupported_response(context)
+        return self.AUXV_SUPPORT_FEATURE_NAME in features and features[
+            self.AUXV_SUPPORT_FEATURE_NAME] == "+"
+
+    def get_raw_auxv_data(self):
+        # Start up llgs and inferior, and check for auxv support.
+        if not self.has_auxv_support():
+            self.skipTest("auxv data not supported")
+
+        # Grab pointer size for target.  We'll assume that is equivalent to an unsigned long on the target.
+        # Auxv is specified in terms of pairs of unsigned longs.
+        self.reset_test_sequence()
+        self.add_process_info_collection_packets()
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        proc_info = self.parse_process_info_response(context)
+        self.assertIsNotNone(proc_info)
+        self.assertTrue("ptrsize" in proc_info)
+        word_size = int(proc_info["ptrsize"])
+
+        OFFSET = 0
+        LENGTH = 0x400
+
+        # Grab the auxv data.
+        self.reset_test_sequence()
+        self.test_sequence.add_log_lines(
+            [
+                "read packet: $qXfer:auxv:read::{:x},{:x}:#00".format(
+                    OFFSET,
+                    LENGTH),
+                {
+                    "direction": "send",
+                    "regex": re.compile(
+                        r"^\$([^E])(.*)#[0-9a-fA-F]{2}$",
+                        re.MULTILINE | re.DOTALL),
+                    "capture": {
+                        1: "response_type",
+                        2: "content_raw"}}],
+            True)
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Ensure we end up with all auxv data in one packet.
+        # FIXME don't assume it all comes back in one packet.
+        self.assertEqual(context.get("response_type"), "l")
+
+        # Decode binary data.
+        content_raw = context.get("content_raw")
+        self.assertIsNotNone(content_raw)
+        return (word_size, self.decode_gdbremote_binary(content_raw))
+
+    def supports_auxv(self):
+        # When non-auxv platforms support llgs, skip the test on platforms
+        # that don't support auxv.
+        self.assertTrue(self.has_auxv_support())
+
+    #
+    # We skip the "supports_auxv" test on debugserver.  The rest of the tests
+    # appropriately skip the auxv tests if the support flag is not present
+    # in the qSupported response, so the debugserver test bits are still there
+    # in case debugserver code one day does have auxv support and thus those
+    # tests don't get skipped.
+    #
+
+    @llgs_test
+    def test_supports_auxv_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.supports_auxv()
+
+    def auxv_data_is_correct_size(self):
+        (word_size, auxv_data) = self.get_raw_auxv_data()
+        self.assertIsNotNone(auxv_data)
+
+        # Ensure auxv data is a multiple of 2*word_size (there should be two
+        # unsigned long fields per auxv entry).
+        self.assertEqual(len(auxv_data) % (2 * word_size), 0)
+        # print("auxv contains {} entries".format(len(auxv_data) / (2*word_size)))
+
+    @debugserver_test
+    def test_auxv_data_is_correct_size_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.auxv_data_is_correct_size()
+
+    @llgs_test
+    def test_auxv_data_is_correct_size_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.auxv_data_is_correct_size()
+
+    def auxv_keys_look_valid(self):
+        (word_size, auxv_data) = self.get_raw_auxv_data()
+        self.assertIsNotNone(auxv_data)
+
+        # Grab endian.
+        self.reset_test_sequence()
+        self.add_process_info_collection_packets()
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        process_info = self.parse_process_info_response(context)
+        self.assertIsNotNone(process_info)
+        endian = process_info.get("endian")
+        self.assertIsNotNone(endian)
+
+        auxv_dict = self.build_auxv_dict(endian, word_size, auxv_data)
+        self.assertIsNotNone(auxv_dict)
+
+        # Verify keys look reasonable.
+        for auxv_key in auxv_dict:
+            self.assertTrue(auxv_key >= 1)
+            self.assertTrue(auxv_key <= 1000)
+        # print("auxv dict: {}".format(auxv_dict))
+
+    @debugserver_test
+    def test_auxv_keys_look_valid_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.auxv_keys_look_valid()
+
+    @llgs_test
+    def test_auxv_keys_look_valid_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.auxv_keys_look_valid()
+
+    def auxv_chunked_reads_work(self):
+        # Verify that multiple smaller offset,length reads of auxv data
+        # return the same data as a single larger read.
+
+        # Grab the auxv data with a single large read here.
+        (word_size, auxv_data) = self.get_raw_auxv_data()
+        self.assertIsNotNone(auxv_data)
+
+        # Grab endian.
+        self.reset_test_sequence()
+        self.add_process_info_collection_packets()
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        process_info = self.parse_process_info_response(context)
+        self.assertIsNotNone(process_info)
+        endian = process_info.get("endian")
+        self.assertIsNotNone(endian)
+
+        auxv_dict = self.build_auxv_dict(endian, word_size, auxv_data)
+        self.assertIsNotNone(auxv_dict)
+
+        iterated_auxv_data = self.read_binary_data_in_chunks(
+            "qXfer:auxv:read::", 2 * word_size)
+        self.assertIsNotNone(iterated_auxv_data)
+
+        auxv_dict_iterated = self.build_auxv_dict(
+            endian, word_size, iterated_auxv_data)
+        self.assertIsNotNone(auxv_dict_iterated)
+
+        # Verify both types of data collection returned same content.
+        self.assertEqual(auxv_dict_iterated, auxv_dict)
+
+    @debugserver_test
+    def test_auxv_chunked_reads_work_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.auxv_chunked_reads_work()
+
+    @llgs_test
+    def test_auxv_chunked_reads_work_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.auxv_chunked_reads_work()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteExitCode.py

+from __future__ import print_function
+
+# lldb test suite imports
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import TestBase
+
+# gdb-remote-specific imports
+import lldbgdbserverutils
+from gdbremote_testcase import GdbRemoteTestCaseBase
+
+
+class TestGdbRemoteExitCode(GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    FAILED_LAUNCH_CODE = "E08"
+
+    def get_launch_fail_reason(self):
+        self.reset_test_sequence()
+        self.test_sequence.add_log_lines(
+            ["read packet: $qLaunchSuccess#00"],
+            True)
+        self.test_sequence.add_log_lines(
+            [{"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$",
+              "capture": {1: "launch_result"}}],
+            True)
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+        return context.get("launch_result")[1:]
+
+    def start_inferior(self):
+        launch_args = self.install_and_create_launch_args()
+
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        self.add_no_ack_remote_stream()
+        self.test_sequence.add_log_lines(
+            ["read packet: %s" % lldbgdbserverutils.build_gdbremote_A_packet(
+                launch_args)],
+            True)
+        self.test_sequence.add_log_lines(
+            [{"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$",
+              "capture": {1: "A_result"}}],
+            True)
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        launch_result = context.get("A_result")
+        self.assertIsNotNone(launch_result)
+        if launch_result == self.FAILED_LAUNCH_CODE:
+            fail_reason = self.get_launch_fail_reason()
+            self.fail("failed to launch inferior: " + fail_reason)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_start_inferior_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.start_inferior()
+
+    @llgs_test
+    def test_start_inferior_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.start_inferior()
+
+    def inferior_exit_0(self):
+        launch_args = self.install_and_create_launch_args()
+
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        self.add_no_ack_remote_stream()
+        self.add_verified_launch_packets(launch_args)
+        self.test_sequence.add_log_lines(
+            ["read packet: $vCont;c#a8",
+             "send packet: $W00#00"],
+            True)
+
+        self.expect_gdbremote_sequence()
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_inferior_exit_0_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.inferior_exit_0()
+
+    @llgs_test
+    def test_inferior_exit_0_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.inferior_exit_0()
+
+    def inferior_exit_42(self):
+        launch_args = self.install_and_create_launch_args()
+
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        RETVAL = 42
+
+        # build launch args
+        launch_args += ["retval:%d" % RETVAL]
+
+        self.add_no_ack_remote_stream()
+        self.add_verified_launch_packets(launch_args)
+        self.test_sequence.add_log_lines(
+            ["read packet: $vCont;c#a8",
+             "send packet: $W{0:02x}#00".format(RETVAL)],
+            True)
+
+        self.expect_gdbremote_sequence()
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_inferior_exit_42_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.inferior_exit_42()
+
+    @llgs_test
+    def test_inferior_exit_42_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.inferior_exit_42()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteExpeditedRegisters.py

+from __future__ import print_function
+
+
+import gdbremote_testcase
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestGdbRemoteExpeditedRegisters(
+        gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+
+    def gather_expedited_registers(self):
+        # Setup the stub and set the gdb remote command stream.
+        procs = self.prep_debug_monitor_and_inferior(inferior_args=["sleep:2"])
+        self.test_sequence.add_log_lines([
+            # Start up the inferior.
+            "read packet: $c#63",
+            # Immediately tell it to stop.  We want to see what it reports.
+            "read packet: {}".format(chr(3)),
+            {"direction": "send",
+             "regex": r"^\$T([0-9a-fA-F]+)([^#]+)#[0-9a-fA-F]{2}$",
+             "capture": {1: "stop_result",
+                         2: "key_vals_text"}},
+        ], True)
+
+        # Run the gdb remote command stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Pull out expedited registers.
+        key_vals_text = context.get("key_vals_text")
+        self.assertIsNotNone(key_vals_text)
+
+        expedited_registers = self.extract_registers_from_stop_notification(
+            key_vals_text)
+        self.assertIsNotNone(expedited_registers)
+
+        return expedited_registers
+
+    def stop_notification_contains_generic_register(
+            self, generic_register_name):
+        # Generate a stop reply, parse out expedited registers from stop
+        # notification.
+        expedited_registers = self.gather_expedited_registers()
+        self.assertIsNotNone(expedited_registers)
+        self.assertTrue(len(expedited_registers) > 0)
+
+        # Gather target register infos.
+        reg_infos = self.gather_register_infos()
+
+        # Find the generic register.
+        reg_info = self.find_generic_register_with_name(
+            reg_infos, generic_register_name)
+        self.assertIsNotNone(reg_info)
+
+        # Ensure the expedited registers contained it.
+        self.assertTrue(reg_info["lldb_register_index"] in expedited_registers)
+        # print("{} reg_info:{}".format(generic_register_name, reg_info))
+
+    def stop_notification_contains_any_registers(self):
+        # Generate a stop reply, parse out expedited registers from stop
+        # notification.
+        expedited_registers = self.gather_expedited_registers()
+        # Verify we have at least one expedited register.
+        self.assertTrue(len(expedited_registers) > 0)
+
+    @debugserver_test
+    def test_stop_notification_contains_any_registers_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_notification_contains_any_registers()
+
+    @llgs_test
+    def test_stop_notification_contains_any_registers_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_notification_contains_any_registers()
+
+    def stop_notification_contains_no_duplicate_registers(self):
+        # Generate a stop reply, parse out expedited registers from stop
+        # notification.
+        expedited_registers = self.gather_expedited_registers()
+        # Verify no expedited register was specified multiple times.
+        for (reg_num, value) in list(expedited_registers.items()):
+            if (isinstance(value, list)) and (len(value) > 0):
+                self.fail(
+                    "expedited register number {} specified more than once ({} times)".format(
+                        reg_num, len(value)))
+
+    @debugserver_test
+    def test_stop_notification_contains_no_duplicate_registers_debugserver(
+            self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_notification_contains_no_duplicate_registers()
+
+    @llgs_test
+    def test_stop_notification_contains_no_duplicate_registers_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_notification_contains_no_duplicate_registers()
+
+    def stop_notification_contains_pc_register(self):
+        self.stop_notification_contains_generic_register("pc")
+
+    @debugserver_test
+    def test_stop_notification_contains_pc_register_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_notification_contains_pc_register()
+
+    @llgs_test
+    def test_stop_notification_contains_pc_register_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_notification_contains_pc_register()
+
+    # powerpc64 has no FP register
+    @skipIf(triple='^powerpc64')
+    def stop_notification_contains_fp_register(self):
+        self.stop_notification_contains_generic_register("fp")
+
+    @debugserver_test
+    def test_stop_notification_contains_fp_register_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_notification_contains_fp_register()
+
+    @llgs_test
+    def test_stop_notification_contains_fp_register_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_notification_contains_fp_register()
+
+    def stop_notification_contains_sp_register(self):
+        self.stop_notification_contains_generic_register("sp")
+
+    @debugserver_test
+    def test_stop_notification_contains_sp_register_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_notification_contains_sp_register()
+
+    @llgs_test
+    def test_stop_notification_contains_sp_register_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_notification_contains_sp_register()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteHostInfo.py

+from __future__ import print_function
+
+# lldb test suite imports
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import TestBase
+
+# gdb-remote-specific imports
+import lldbgdbserverutils
+from gdbremote_testcase import GdbRemoteTestCaseBase
+
+
+class TestGdbRemoteHostInfo(GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    KNOWN_HOST_INFO_KEYS = set([
+        "arch",
+        "cputype",
+        "cpusubtype",
+        "distribution_id",
+        "endian",
+        "hostname",
+        "ostype",
+        "os_build",
+        "os_kernel",
+        "os_version",
+        "ptrsize",
+        "triple",
+        "vendor",
+        "watchpoint_exceptions_received",
+        "default_packet_timeout",
+    ])
+
+    DARWIN_REQUIRED_HOST_INFO_KEYS = set([
+        "cputype",
+        "cpusubtype",
+        "endian",
+        "ostype",
+        "ptrsize",
+        "vendor",
+        "watchpoint_exceptions_received"
+    ])
+
+    def add_host_info_collection_packets(self):
+        self.test_sequence.add_log_lines(
+            ["read packet: $qHostInfo#9b",
+             {"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$",
+              "capture": {1: "host_info_raw"}}],
+            True)
+
+    def parse_host_info_response(self, context):
+        # Ensure we have a host info response.
+        self.assertIsNotNone(context)
+        host_info_raw = context.get("host_info_raw")
+        self.assertIsNotNone(host_info_raw)
+
+        # Pull out key:value; pairs.
+        host_info_dict = {match.group(1): match.group(2)
+                          for match in re.finditer(r"([^:]+):([^;]+);",
+                                                   host_info_raw)}
+
+        import pprint
+        print("\nqHostInfo response:")
+        pprint.pprint(host_info_dict)
+
+        # Validate keys are known.
+        for (key, val) in list(host_info_dict.items()):
+            self.assertTrue(key in self.KNOWN_HOST_INFO_KEYS,
+                            "unknown qHostInfo key: " + key)
+            self.assertIsNotNone(val)
+
+        # Return the key:val pairs.
+        return host_info_dict
+
+    def get_qHostInfo_response(self):
+        # Launch the debug monitor stub, attaching to the inferior.
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+        self.add_no_ack_remote_stream()
+
+        # Request qHostInfo and get response
+        self.add_host_info_collection_packets()
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Parse qHostInfo response.
+        host_info = self.parse_host_info_response(context)
+        self.assertIsNotNone(host_info)
+        self.assertGreater(len(host_info), 0, "qHostInfo should have returned "
+                           "at least one key:val pair.")
+        return host_info
+
+    def validate_darwin_minimum_host_info_keys(self, host_info_dict):
+        self.assertIsNotNone(host_info_dict)
+        missing_keys = [key for key in self.DARWIN_REQUIRED_HOST_INFO_KEYS
+                        if key not in host_info_dict]
+        self.assertEquals(0, len(missing_keys),
+                          "qHostInfo is missing the following required "
+                          "keys: " + str(missing_keys))
+
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    @debugserver_test
+    def test_qHostInfo_returns_at_least_one_key_val_pair_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.get_qHostInfo_response()
+
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    @llgs_test
+    def test_qHostInfo_returns_at_least_one_key_val_pair_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.get_qHostInfo_response()
+
+    @skipUnlessDarwin
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    @debugserver_test
+    def test_qHostInfo_contains_darwin_required_keys_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        host_info_dict = self.get_qHostInfo_response()
+        self.validate_darwin_minimum_host_info_keys(host_info_dict)
+
+    @skipUnlessDarwin
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    @llgs_test
+    def test_qHostInfo_contains_darwin_required_keys_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        host_info_dict = self.get_qHostInfo_response()
+        self.validate_darwin_minimum_host_info_keys(host_info_dict)

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteKill.py

+from __future__ import print_function
+
+
+import gdbremote_testcase
+import lldbgdbserverutils
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestGdbRemoteKill(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+
+    def attach_commandline_kill_after_initial_stop(self):
+        procs = self.prep_debug_monitor_and_inferior()
+        self.test_sequence.add_log_lines([
+            "read packet: $k#6b",
+            {"direction": "send", "regex": r"^\$X[0-9a-fA-F]+([^#]*)#[0-9A-Fa-f]{2}"},
+        ], True)
+
+        if self.stub_sends_two_stop_notifications_on_kill:
+            # Add an expectation for a second X result for stubs that send two
+            # of these.
+            self.test_sequence.add_log_lines([
+                {"direction": "send", "regex": r"^\$X[0-9a-fA-F]+([^#]*)#[0-9A-Fa-f]{2}"},
+            ], True)
+
+        self.expect_gdbremote_sequence()
+
+        # Wait a moment for completed and now-detached inferior process to
+        # clear.
+        time.sleep(1)
+
+        if not lldb.remote_platform:
+            # Process should be dead now. Reap results.
+            poll_result = procs["inferior"].poll()
+            self.assertIsNotNone(poll_result)
+
+        # Where possible, verify at the system level that the process is not
+        # running.
+        self.assertFalse(
+            lldbgdbserverutils.process_is_running(
+                procs["inferior"].pid, False))
+
+    @debugserver_test
+    def test_attach_commandline_kill_after_initial_stop_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_attach()
+        self.attach_commandline_kill_after_initial_stop()
+
+    @llgs_test
+    def test_attach_commandline_kill_after_initial_stop_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_attach()
+        self.attach_commandline_kill_after_initial_stop()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteModuleInfo.py

+from __future__ import print_function
+
+
+import gdbremote_testcase
+import lldbgdbserverutils
+from lldbsuite.support import seven
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestGdbRemoteModuleInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def module_info(self):
+        procs = self.prep_debug_monitor_and_inferior()
+        self.add_process_info_collection_packets()
+        context = self.expect_gdbremote_sequence()
+        info = self.parse_process_info_response(context)
+
+        self.test_sequence.add_log_lines([
+            'read packet: $jModulesInfo:[{"file":"%s","triple":"%s"}]]#00' % (
+                lldbutil.append_to_process_working_directory(self, "a.out"),
+                seven.unhexlify(info["triple"])),
+            {"direction": "send",
+             "regex": r'^\$\[{(.*)}\]\]#[0-9A-Fa-f]{2}',
+             "capture": {1: "spec"}},
+        ], True)
+
+        context = self.expect_gdbremote_sequence()
+        spec = context.get("spec")
+        self.assertRegexpMatches(spec, '"file_path":".*"')
+        self.assertRegexpMatches(spec, '"file_offset":\d+')
+        self.assertRegexpMatches(spec, '"file_size":\d+')
+        self.assertRegexpMatches(spec, '"triple":"\w*-\w*-.*"')
+        self.assertRegexpMatches(spec, '"uuid":"[A-Fa-f0-9]+"')
+
+    @llgs_test
+    def test_module_info(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.module_info()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteProcessInfo.py

+from __future__ import print_function
+
+
+import sys
+
+import gdbremote_testcase
+import lldbgdbserverutils
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestGdbRemoteProcessInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def qProcessInfo_returns_running_process(self):
+        procs = self.prep_debug_monitor_and_inferior()
+        self.add_process_info_collection_packets()
+
+        # Run the stream
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Gather process info response
+        process_info = self.parse_process_info_response(context)
+        self.assertIsNotNone(process_info)
+
+        # Ensure the process id looks reasonable.
+        pid_text = process_info.get("pid")
+        self.assertIsNotNone(pid_text)
+        pid = int(pid_text, base=16)
+        self.assertNotEqual(0, pid)
+
+        # If possible, verify that the process is running.
+        self.assertTrue(lldbgdbserverutils.process_is_running(pid, True))
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qProcessInfo_returns_running_process_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.qProcessInfo_returns_running_process()
+
+    @llgs_test
+    def test_qProcessInfo_returns_running_process_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.qProcessInfo_returns_running_process()
+
+    def attach_commandline_qProcessInfo_reports_correct_pid(self):
+        procs = self.prep_debug_monitor_and_inferior()
+        self.assertIsNotNone(procs)
+        self.add_process_info_collection_packets()
+
+        # Run the stream
+        context = self.expect_gdbremote_sequence(timeout_seconds=8)
+        self.assertIsNotNone(context)
+
+        # Gather process info response
+        process_info = self.parse_process_info_response(context)
+        self.assertIsNotNone(process_info)
+
+        # Ensure the process id matches what we expected.
+        pid_text = process_info.get('pid', None)
+        self.assertIsNotNone(pid_text)
+        reported_pid = int(pid_text, base=16)
+        self.assertEqual(reported_pid, procs["inferior"].pid)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_attach_commandline_qProcessInfo_reports_correct_pid_debugserver(
+            self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_attach()
+        self.attach_commandline_qProcessInfo_reports_correct_pid()
+
+    @llgs_test
+    def test_attach_commandline_qProcessInfo_reports_correct_pid_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_attach()
+        self.attach_commandline_qProcessInfo_reports_correct_pid()
+
+    def qProcessInfo_reports_valid_endian(self):
+        procs = self.prep_debug_monitor_and_inferior()
+        self.add_process_info_collection_packets()
+
+        # Run the stream
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Gather process info response
+        process_info = self.parse_process_info_response(context)
+        self.assertIsNotNone(process_info)
+
+        # Ensure the process id looks reasonable.
+        endian = process_info.get("endian")
+        self.assertIsNotNone(endian)
+        self.assertTrue(endian in ["little", "big", "pdp"])
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qProcessInfo_reports_valid_endian_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.qProcessInfo_reports_valid_endian()
+
+    @llgs_test
+    def test_qProcessInfo_reports_valid_endian_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.qProcessInfo_reports_valid_endian()
+
+    def qProcessInfo_contains_keys(self, expected_key_set):
+        procs = self.prep_debug_monitor_and_inferior()
+        self.add_process_info_collection_packets()
+
+        # Run the stream
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Gather process info response
+        process_info = self.parse_process_info_response(context)
+        self.assertIsNotNone(process_info)
+
+        # Ensure the expected keys are present and non-None within the process
+        # info.
+        missing_key_set = set()
+        for expected_key in expected_key_set:
+            if expected_key not in process_info:
+                missing_key_set.add(expected_key)
+
+        self.assertEqual(
+            missing_key_set,
+            set(),
+            "the listed keys are missing in the qProcessInfo result")
+
+    def qProcessInfo_does_not_contain_keys(self, absent_key_set):
+        procs = self.prep_debug_monitor_and_inferior()
+        self.add_process_info_collection_packets()
+
+        # Run the stream
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Gather process info response
+        process_info = self.parse_process_info_response(context)
+        self.assertIsNotNone(process_info)
+
+        # Ensure the unexpected keys are not present
+        unexpected_key_set = set()
+        for unexpected_key in absent_key_set:
+            if unexpected_key in process_info:
+                unexpected_key_set.add(unexpected_key)
+
+        self.assertEqual(
+            unexpected_key_set,
+            set(),
+            "the listed keys were present but unexpected in qProcessInfo result")
+
+    @skipUnlessDarwin
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qProcessInfo_contains_cputype_cpusubtype_debugserver_darwin(self):
+        self.init_debugserver_test()
+        self.build()
+        self.qProcessInfo_contains_keys(set(['cputype', 'cpusubtype']))
+
+    @skipUnlessDarwin
+    @llgs_test
+    def test_qProcessInfo_contains_cputype_cpusubtype_llgs_darwin(self):
+        self.init_llgs_test()
+        self.build()
+        self.qProcessInfo_contains_keys(set(['cputype', 'cpusubtype']))
+
+    @skipUnlessPlatform(["linux"])
+    @llgs_test
+    def test_qProcessInfo_contains_triple_llgs_linux(self):
+        self.init_llgs_test()
+        self.build()
+        self.qProcessInfo_contains_keys(set(['triple']))
+
+    @skipUnlessDarwin
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qProcessInfo_does_not_contain_triple_debugserver_darwin(self):
+        self.init_debugserver_test()
+        self.build()
+        # We don't expect to see triple on darwin.  If we do, we'll prefer triple
+        # to cputype/cpusubtype and skip some darwin-based ProcessGDBRemote ArchSpec setup
+        # for the remote Host and Process.
+        self.qProcessInfo_does_not_contain_keys(set(['triple']))
+
+    @skipUnlessDarwin
+    @llgs_test
+    def test_qProcessInfo_does_not_contain_triple_llgs_darwin(self):
+        self.init_llgs_test()
+        self.build()
+        # We don't expect to see triple on darwin.  If we do, we'll prefer triple
+        # to cputype/cpusubtype and skip some darwin-based ProcessGDBRemote ArchSpec setup
+        # for the remote Host and Process.
+        self.qProcessInfo_does_not_contain_keys(set(['triple']))
+
+    @skipUnlessPlatform(["linux"])
+    @llgs_test
+    def test_qProcessInfo_does_not_contain_cputype_cpusubtype_llgs_linux(self):
+        self.init_llgs_test()
+        self.build()
+        self.qProcessInfo_does_not_contain_keys(set(['cputype', 'cpusubtype']))

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteRegisterState.py

+from __future__ import print_function
+
+
+import gdbremote_testcase
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestGdbRemoteRegisterState(gdbremote_testcase.GdbRemoteTestCaseBase):
+    """Test QSaveRegisterState/QRestoreRegisterState support."""
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def grp_register_save_restore_works(self, with_suffix):
+        # Start up the process, use thread suffix, grab main thread id.
+        inferior_args = ["message:main entered", "sleep:5"]
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=inferior_args)
+
+        self.add_process_info_collection_packets()
+        self.add_register_info_collection_packets()
+        if with_suffix:
+            self.add_thread_suffix_request_packets()
+        self.add_threadinfo_collection_packets()
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Gather process info.
+        process_info = self.parse_process_info_response(context)
+        endian = process_info.get("endian")
+        self.assertIsNotNone(endian)
+
+        # Gather register info.
+        reg_infos = self.parse_register_info_packets(context)
+        self.assertIsNotNone(reg_infos)
+        self.add_lldb_register_index(reg_infos)
+
+        # Pull out the register infos that we think we can bit flip
+        # successfully.
+        gpr_reg_infos = [
+            reg_info for reg_info in reg_infos if self.is_bit_flippable_register(reg_info)]
+        self.assertTrue(len(gpr_reg_infos) > 0)
+
+        # Gather thread info.
+        if with_suffix:
+            threads = self.parse_threadinfo_packets(context)
+            self.assertIsNotNone(threads)
+            thread_id = threads[0]
+            self.assertIsNotNone(thread_id)
+            # print("Running on thread: 0x{:x}".format(thread_id))
+        else:
+            thread_id = None
+
+        # Save register state.
+        self.reset_test_sequence()
+        self.add_QSaveRegisterState_packets(thread_id)
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        (success, state_id) = self.parse_QSaveRegisterState_response(context)
+        self.assertTrue(success)
+        self.assertIsNotNone(state_id)
+        # print("saved register state id: {}".format(state_id))
+
+        # Remember initial register values.
+        initial_reg_values = self.read_register_values(
+            gpr_reg_infos, endian, thread_id=thread_id)
+        # print("initial_reg_values: {}".format(initial_reg_values))
+
+        # Flip gpr register values.
+        (successful_writes, failed_writes) = self.flip_all_bits_in_each_register_value(
+            gpr_reg_infos, endian, thread_id=thread_id)
+        # print("successful writes: {}, failed writes: {}".format(successful_writes, failed_writes))
+        self.assertTrue(successful_writes > 0)
+
+        flipped_reg_values = self.read_register_values(
+            gpr_reg_infos, endian, thread_id=thread_id)
+        # print("flipped_reg_values: {}".format(flipped_reg_values))
+
+        # Restore register values.
+        self.reset_test_sequence()
+        self.add_QRestoreRegisterState_packets(state_id, thread_id)
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Verify registers match initial register values.
+        final_reg_values = self.read_register_values(
+            gpr_reg_infos, endian, thread_id=thread_id)
+        # print("final_reg_values: {}".format(final_reg_values))
+        self.assertIsNotNone(final_reg_values)
+        self.assertEqual(final_reg_values, initial_reg_values)
+
+    @debugserver_test
+    def test_grp_register_save_restore_works_with_suffix_debugserver(self):
+        USE_THREAD_SUFFIX = True
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.grp_register_save_restore_works(USE_THREAD_SUFFIX)
+
+    @llgs_test
+    def test_grp_register_save_restore_works_with_suffix_llgs(self):
+        USE_THREAD_SUFFIX = True
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.grp_register_save_restore_works(USE_THREAD_SUFFIX)
+
+    @debugserver_test
+    def test_grp_register_save_restore_works_no_suffix_debugserver(self):
+        USE_THREAD_SUFFIX = False
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.grp_register_save_restore_works(USE_THREAD_SUFFIX)
+
+    @llgs_test
+    def test_grp_register_save_restore_works_no_suffix_llgs(self):
+        USE_THREAD_SUFFIX = False
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.grp_register_save_restore_works(USE_THREAD_SUFFIX)

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteSingleStep.py

+from __future__ import print_function
+
+
+import gdbremote_testcase
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestGdbRemoteSingleStep(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    @debugserver_test
+    def test_single_step_only_steps_one_instruction_with_s_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.single_step_only_steps_one_instruction(
+            use_Hc_packet=True, step_instruction="s")
+
+    @llgs_test
+    @expectedFailureAndroid(
+        bugnumber="llvm.org/pr24739",
+        archs=[
+            "arm",
+            "aarch64"])
+    @expectedFailureAll(
+        oslist=["linux"],
+        archs=[
+            "arm",
+            "aarch64"],
+        bugnumber="llvm.org/pr24739")
+    @skipIf(triple='^mips')
+    def test_single_step_only_steps_one_instruction_with_s_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.single_step_only_steps_one_instruction(
+            use_Hc_packet=True, step_instruction="s")

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteThreadsInStopReply.py

+from __future__ import print_function
+
+import json
+import re
+
+import gdbremote_testcase
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestGdbRemoteThreadsInStopReply(
+        gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    ENABLE_THREADS_IN_STOP_REPLY_ENTRIES = [
+        "read packet: $QListThreadsInStopReply#21",
+        "send packet: $OK#00",
+    ]
+
+    def gather_stop_reply_fields(self, post_startup_log_lines, thread_count,
+            field_names):
+        # Set up the inferior args.
+        inferior_args = []
+        for i in range(thread_count - 1):
+            inferior_args.append("thread:new")
+        inferior_args.append("sleep:10")
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=inferior_args)
+
+        self.add_register_info_collection_packets()
+        self.add_process_info_collection_packets()
+
+        # Assumes test_sequence has anything added needed to setup the initial state.
+        # (Like optionally enabling QThreadsInStopReply.)
+        if post_startup_log_lines:
+            self.test_sequence.add_log_lines(post_startup_log_lines, True)
+        self.test_sequence.add_log_lines([
+            "read packet: $c#63"
+        ], True)
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+        hw_info = self.parse_hw_info(context)
+
+        # Give threads time to start up, then break.
+        time.sleep(1)
+        self.reset_test_sequence()
+        self.test_sequence.add_log_lines(
+            [
+                "read packet: {}".format(
+                    chr(3)),
+                {
+                    "direction": "send",
+                    "regex": r"^\$T([0-9a-fA-F]+)([^#]+)#[0-9a-fA-F]{2}$",
+                    "capture": {
+                        1: "stop_result",
+                        2: "key_vals_text"}},
+            ],
+            True)
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Wait until all threads have started.
+        threads = self.wait_for_thread_count(thread_count, timeout_seconds=3)
+        self.assertIsNotNone(threads)
+        self.assertEqual(len(threads), thread_count)
+
+        # Run, then stop the process, grab the stop reply content.
+        self.reset_test_sequence()
+        self.test_sequence.add_log_lines(["read packet: $c#63",
+                                          "read packet: {}".format(chr(3)),
+                                          {"direction": "send",
+                                           "regex": r"^\$T([0-9a-fA-F]+)([^#]+)#[0-9a-fA-F]{2}$",
+                                           "capture": {1: "stop_result",
+                                                       2: "key_vals_text"}},
+                                          ],
+                                         True)
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Parse the stop reply contents.
+        key_vals_text = context.get("key_vals_text")
+        self.assertIsNotNone(key_vals_text)
+        kv_dict = self.parse_key_val_dict(key_vals_text)
+        self.assertIsNotNone(kv_dict)
+
+        result = dict();
+        result["pc_register"] = hw_info["pc_register"]
+        result["little_endian"] = hw_info["little_endian"]
+        for key_field in field_names:
+            result[key_field] = kv_dict.get(key_field)
+
+        return result
+
+    def gather_stop_reply_threads(self, post_startup_log_lines, thread_count):
+        # Pull out threads from stop response.
+        stop_reply_threads_text = self.gather_stop_reply_fields(
+                post_startup_log_lines, thread_count, ["threads"])["threads"]
+        if stop_reply_threads_text:
+            return [int(thread_id, 16)
+                    for thread_id in stop_reply_threads_text.split(",")]
+        else:
+            return []
+
+    def gather_stop_reply_pcs(self, post_startup_log_lines, thread_count):
+        results = self.gather_stop_reply_fields( post_startup_log_lines,
+                thread_count, ["threads", "thread-pcs"])
+        if not results:
+            return []
+
+        threads_text = results["threads"]
+        pcs_text = results["thread-pcs"]
+        thread_ids = threads_text.split(",")
+        pcs = pcs_text.split(",")
+        self.assertTrue(len(thread_ids) == len(pcs))
+
+        thread_pcs = dict()
+        for i in range(0, len(pcs)):
+            thread_pcs[int(thread_ids[i], 16)] = pcs[i]
+
+        result = dict()
+        result["thread_pcs"] = thread_pcs
+        result["pc_register"] = results["pc_register"]
+        result["little_endian"] = results["little_endian"]
+        return result
+
+    def switch_endian(self, egg):
+        return "".join(reversed(re.findall("..", egg)))
+
+    def parse_hw_info(self, context):
+        self.assertIsNotNone(context)
+        process_info = self.parse_process_info_response(context)
+        endian = process_info.get("endian")
+        reg_info = self.parse_register_info_packets(context)
+        (pc_lldb_reg_index, pc_reg_info) = self.find_pc_reg_info(reg_info)
+
+        hw_info = dict()
+        hw_info["pc_register"] = pc_lldb_reg_index
+        hw_info["little_endian"] = (endian == "little")
+        return hw_info
+
+    def gather_threads_info_pcs(self, pc_register, little_endian):
+        self.reset_test_sequence()
+        self.test_sequence.add_log_lines(
+                [
+                    "read packet: $jThreadsInfo#c1",
+                    {
+                        "direction": "send",
+                        "regex": r"^\$(.*)#[0-9a-fA-F]{2}$",
+                        "capture": {
+                            1: "threads_info"}},
+                ],
+                True)
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+        threads_info = context.get("threads_info")
+        register = str(pc_register)
+        # The jThreadsInfo response is not valid JSON data, so we have to
+        # clean it up first.
+        jthreads_info = json.loads(re.sub(r"}]", "}", threads_info))
+        thread_pcs = dict()
+        for thread_info in jthreads_info:
+            tid = thread_info["tid"]
+            pc = thread_info["registers"][register]
+            thread_pcs[tid] = self.switch_endian(pc) if little_endian else pc
+
+        return thread_pcs
+
+    def QListThreadsInStopReply_supported(self):
+        procs = self.prep_debug_monitor_and_inferior()
+        self.test_sequence.add_log_lines(
+            self.ENABLE_THREADS_IN_STOP_REPLY_ENTRIES, True)
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    @debugserver_test
+    def test_QListThreadsInStopReply_supported_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.QListThreadsInStopReply_supported()
+
+    @llgs_test
+    def test_QListThreadsInStopReply_supported_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.QListThreadsInStopReply_supported()
+
+    def stop_reply_reports_multiple_threads(self, thread_count):
+        # Gather threads from stop notification when QThreadsInStopReply is
+        # enabled.
+        stop_reply_threads = self.gather_stop_reply_threads(
+            self.ENABLE_THREADS_IN_STOP_REPLY_ENTRIES, thread_count)
+        self.assertEqual(len(stop_reply_threads), thread_count)
+
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    @debugserver_test
+    def test_stop_reply_reports_multiple_threads_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_reply_reports_multiple_threads(5)
+
+    @llgs_test
+    def test_stop_reply_reports_multiple_threads_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_reply_reports_multiple_threads(5)
+
+    def no_QListThreadsInStopReply_supplies_no_threads(self, thread_count):
+        # Gather threads from stop notification when QThreadsInStopReply is not
+        # enabled.
+        stop_reply_threads = self.gather_stop_reply_threads(None, thread_count)
+        self.assertEqual(len(stop_reply_threads), 0)
+
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    @debugserver_test
+    def test_no_QListThreadsInStopReply_supplies_no_threads_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.no_QListThreadsInStopReply_supplies_no_threads(5)
+
+    @llgs_test
+    def test_no_QListThreadsInStopReply_supplies_no_threads_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.no_QListThreadsInStopReply_supplies_no_threads(5)
+
+    def stop_reply_reports_correct_threads(self, thread_count):
+        # Gather threads from stop notification when QThreadsInStopReply is
+        # enabled.
+        stop_reply_threads = self.gather_stop_reply_threads(
+            self.ENABLE_THREADS_IN_STOP_REPLY_ENTRIES, thread_count)
+        self.assertEqual(len(stop_reply_threads), thread_count)
+
+        # Gather threads from q{f,s}ThreadInfo.
+        self.reset_test_sequence()
+        self.add_threadinfo_collection_packets()
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        threads = self.parse_threadinfo_packets(context)
+        self.assertIsNotNone(threads)
+        self.assertEqual(len(threads), thread_count)
+
+        # Ensure each thread in q{f,s}ThreadInfo appears in stop reply threads
+        for tid in threads:
+            self.assertTrue(tid in stop_reply_threads)
+
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    @debugserver_test
+    def test_stop_reply_reports_correct_threads_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_reply_reports_correct_threads(5)
+
+    @llgs_test
+    def test_stop_reply_reports_correct_threads_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_reply_reports_correct_threads(5)
+
+    def stop_reply_contains_thread_pcs(self, thread_count):
+        results = self.gather_stop_reply_pcs(
+                self.ENABLE_THREADS_IN_STOP_REPLY_ENTRIES, thread_count)
+        stop_reply_pcs = results["thread_pcs"]
+        pc_register = results["pc_register"]
+        little_endian = results["little_endian"]
+        self.assertEqual(len(stop_reply_pcs), thread_count)
+
+        threads_info_pcs = self.gather_threads_info_pcs(pc_register,
+                little_endian)
+
+        self.assertEqual(len(threads_info_pcs), thread_count)
+        for thread_id in stop_reply_pcs:
+            self.assertTrue(thread_id in threads_info_pcs)
+            self.assertTrue(int(stop_reply_pcs[thread_id], 16)
+                    == int(threads_info_pcs[thread_id], 16))
+
+    @llgs_test
+    def test_stop_reply_contains_thread_pcs_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_reply_contains_thread_pcs(5)
+
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    @debugserver_test
+    def test_stop_reply_contains_thread_pcs_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_reply_contains_thread_pcs(5)

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemote_qThreadStopInfo.py

+from __future__ import print_function
+
+
+import sys
+
+import unittest2
+import gdbremote_testcase
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestGdbRemote_qThreadStopInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    THREAD_COUNT = 5
+
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    @skipIfDarwinEmbedded # <rdar://problem/27005337>
+    def gather_stop_replies_via_qThreadStopInfo(self, thread_count):
+        # Set up the inferior args.
+        inferior_args = []
+        for i in range(thread_count - 1):
+            inferior_args.append("thread:new")
+        inferior_args.append("sleep:10")
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=inferior_args)
+
+        # Assumes test_sequence has anything added needed to setup the initial state.
+        # (Like optionally enabling QThreadsInStopReply.)
+        self.test_sequence.add_log_lines([
+            "read packet: $c#63"
+        ], True)
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Give threads time to start up, then break.
+        time.sleep(1)
+        self.reset_test_sequence()
+        self.test_sequence.add_log_lines(
+            [
+                "read packet: {}".format(
+                    chr(3)),
+                {
+                    "direction": "send",
+                    "regex": r"^\$T([0-9a-fA-F]+)([^#]+)#[0-9a-fA-F]{2}$",
+                    "capture": {
+                        1: "stop_result",
+                        2: "key_vals_text"}},
+            ],
+            True)
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Wait until all threads have started.
+        threads = self.wait_for_thread_count(thread_count, timeout_seconds=3)
+        self.assertIsNotNone(threads)
+        self.assertEqual(len(threads), thread_count)
+
+        # Grab stop reply for each thread via qThreadStopInfo{tid:hex}.
+        stop_replies = {}
+        thread_dicts = {}
+        for thread in threads:
+            # Run the qThreadStopInfo command.
+            self.reset_test_sequence()
+            self.test_sequence.add_log_lines(
+                [
+                    "read packet: $qThreadStopInfo{:x}#00".format(thread),
+                    {
+                        "direction": "send",
+                        "regex": r"^\$T([0-9a-fA-F]+)([^#]+)#[0-9a-fA-F]{2}$",
+                        "capture": {
+                            1: "stop_result",
+                            2: "key_vals_text"}},
+                ],
+                True)
+            context = self.expect_gdbremote_sequence()
+            self.assertIsNotNone(context)
+
+            # Parse stop reply contents.
+            key_vals_text = context.get("key_vals_text")
+            self.assertIsNotNone(key_vals_text)
+            kv_dict = self.parse_key_val_dict(key_vals_text)
+            self.assertIsNotNone(kv_dict)
+
+            # Verify there is a thread and that it matches the expected thread
+            # id.
+            kv_thread = kv_dict.get("thread")
+            self.assertIsNotNone(kv_thread)
+            kv_thread_id = int(kv_thread, 16)
+            self.assertEqual(kv_thread_id, thread)
+
+            # Grab the stop id reported.
+            stop_result_text = context.get("stop_result")
+            self.assertIsNotNone(stop_result_text)
+            stop_replies[kv_thread_id] = int(stop_result_text, 16)
+
+            # Hang on to the key-val dictionary for the thread.
+            thread_dicts[kv_thread_id] = kv_dict
+
+        return (stop_replies, thread_dicts)
+
+    def qThreadStopInfo_works_for_multiple_threads(self, thread_count):
+        (stop_replies, _) = self.gather_stop_replies_via_qThreadStopInfo(thread_count)
+        self.assertEqual(len(stop_replies), thread_count)
+
+    @debugserver_test
+    def test_qThreadStopInfo_works_for_multiple_threads_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qThreadStopInfo_works_for_multiple_threads(self.THREAD_COUNT)
+
+    @llgs_test
+    def test_qThreadStopInfo_works_for_multiple_threads_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qThreadStopInfo_works_for_multiple_threads(self.THREAD_COUNT)
+
+    def qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt(
+            self, thread_count):
+        (stop_replies, _) = self.gather_stop_replies_via_qThreadStopInfo(thread_count)
+        self.assertIsNotNone(stop_replies)
+
+        no_stop_reason_count = sum(
+            1 for stop_reason in list(
+                stop_replies.values()) if stop_reason == 0)
+        with_stop_reason_count = sum(
+            1 for stop_reason in list(
+                stop_replies.values()) if stop_reason != 0)
+
+        # All but one thread should report no stop reason.
+        self.assertEqual(no_stop_reason_count, thread_count - 1)
+
+        # Only one thread should should indicate a stop reason.
+        self.assertEqual(with_stop_reason_count, 1)
+
+    @debugserver_test
+    def test_qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt_debugserver(
+            self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt(
+            self.THREAD_COUNT)
+
+    @llgs_test
+    def test_qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt_llgs(
+            self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt(
+            self.THREAD_COUNT)
+
+    def qThreadStopInfo_has_valid_thread_names(
+            self, thread_count, expected_thread_name):
+        (_, thread_dicts) = self.gather_stop_replies_via_qThreadStopInfo(thread_count)
+        self.assertIsNotNone(thread_dicts)
+
+        for thread_dict in list(thread_dicts.values()):
+            name = thread_dict.get("name")
+            self.assertIsNotNone(name)
+            self.assertEqual(name, expected_thread_name)
+
+    @unittest2.skip("MacOSX doesn't have a default thread name")
+    @debugserver_test
+    def test_qThreadStopInfo_has_valid_thread_names_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qThreadStopInfo_has_valid_thread_names(self.THREAD_COUNT, "a.out")
+
+    # test requires OS with set, equal thread names by default.
+    @skipUnlessPlatform(["linux"])
+    @llgs_test
+    def test_qThreadStopInfo_has_valid_thread_names_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qThreadStopInfo_has_valid_thread_names(self.THREAD_COUNT, "a.out")

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemote_vCont.py

+from __future__ import print_function
+
+import gdbremote_testcase
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestGdbRemote_vCont(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def vCont_supports_mode(self, mode, inferior_args=None):
+        # Setup the stub and set the gdb remote command stream.
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=inferior_args)
+        self.add_vCont_query_packets()
+
+        # Run the gdb remote command stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Pull out supported modes.
+        supported_vCont_modes = self.parse_vCont_query_response(context)
+        self.assertIsNotNone(supported_vCont_modes)
+
+        # Verify we support the given mode.
+        self.assertTrue(mode in supported_vCont_modes)
+
+    def vCont_supports_c(self):
+        self.vCont_supports_mode("c")
+
+    def vCont_supports_C(self):
+        self.vCont_supports_mode("C")
+
+    def vCont_supports_s(self):
+        self.vCont_supports_mode("s")
+
+    def vCont_supports_S(self):
+        self.vCont_supports_mode("S")
+
+    @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://27005337")
+    @debugserver_test
+    def test_vCont_supports_c_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.vCont_supports_c()
+
+    @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://27005337")
+    @llgs_test
+    def test_vCont_supports_c_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.vCont_supports_c()
+
+    @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://27005337")
+    @debugserver_test
+    def test_vCont_supports_C_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.vCont_supports_C()
+
+    @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://27005337")
+    @llgs_test
+    def test_vCont_supports_C_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.vCont_supports_C()
+
+    @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://27005337")
+    @debugserver_test
+    def test_vCont_supports_s_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.vCont_supports_s()
+
+    @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://27005337")
+    @llgs_test
+    def test_vCont_supports_s_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.vCont_supports_s()
+
+    @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://27005337")
+    @debugserver_test
+    def test_vCont_supports_S_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.vCont_supports_S()
+
+    @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://27005337")
+    @llgs_test
+    def test_vCont_supports_S_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.vCont_supports_S()
+
+    @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://27005337")
+    @debugserver_test
+    def test_single_step_only_steps_one_instruction_with_Hc_vCont_s_debugserver(
+            self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.single_step_only_steps_one_instruction(
+            use_Hc_packet=True, step_instruction="vCont;s")
+
+    @llgs_test
+    @expectedFailureAndroid(
+        bugnumber="llvm.org/pr24739",
+        archs=[
+            "arm",
+            "aarch64"])
+    @expectedFailureAll(
+        oslist=["linux"],
+        archs=[
+            "arm",
+            "aarch64"],
+        bugnumber="llvm.org/pr24739")
+    @skipIf(triple='^mips')
+    @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://27005337")
+    def test_single_step_only_steps_one_instruction_with_Hc_vCont_s_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.single_step_only_steps_one_instruction(
+            use_Hc_packet=True, step_instruction="vCont;s")
+
+    @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://27005337")
+    @debugserver_test
+    def test_single_step_only_steps_one_instruction_with_vCont_s_thread_debugserver(
+            self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.single_step_only_steps_one_instruction(
+            use_Hc_packet=False, step_instruction="vCont;s:{thread}")
+
+    @llgs_test
+    @expectedFailureAndroid(
+        bugnumber="llvm.org/pr24739",
+        archs=[
+            "arm",
+            "aarch64"])
+    @expectedFailureAll(
+        oslist=["linux"],
+        archs=[
+            "arm",
+            "aarch64"],
+        bugnumber="llvm.org/pr24739")
+    @skipIf(triple='^mips')
+    @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://27005337")
+    def test_single_step_only_steps_one_instruction_with_vCont_s_thread_llgs(
+            self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.single_step_only_steps_one_instruction(
+            use_Hc_packet=False, step_instruction="vCont;s:{thread}")

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestLldbGdbServer.py

+"""
+Test case for testing the gdbremote protocol.
+
+Tests run against debugserver and lldb-server (llgs).
+lldb-server tests run where the lldb-server exe is
+available.
+
+This class will be broken into smaller test case classes by
+gdb remote packet functional areas.  For now it contains
+the initial set of tests implemented.
+"""
+
+from __future__ import division, print_function
+
+
+import unittest2
+import gdbremote_testcase
+import lldbgdbserverutils
+import platform
+import signal
+from lldbsuite.support import seven
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.lldbdwarf import *
+from lldbsuite.test import lldbutil
+
+
+class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_exe_starts_debugserver(self):
+        self.init_debugserver_test()
+        server = self.connect_to_debug_monitor()
+
+    @llgs_test
+    def test_exe_starts_llgs(self):
+        self.init_llgs_test()
+        server = self.connect_to_debug_monitor()
+
+    def start_no_ack_mode(self):
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        self.add_no_ack_remote_stream()
+        self.expect_gdbremote_sequence()
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_start_no_ack_mode_debugserver(self):
+        self.init_debugserver_test()
+        self.start_no_ack_mode()
+
+    @llgs_test
+    def test_start_no_ack_mode_llgs(self):
+        self.init_llgs_test()
+        self.start_no_ack_mode()
+
+    def thread_suffix_supported(self):
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        self.add_no_ack_remote_stream()
+        self.test_sequence.add_log_lines(
+            ["lldb-server <  26> read packet: $QThreadSuffixSupported#e4",
+             "lldb-server <   6> send packet: $OK#9a"],
+            True)
+
+        self.expect_gdbremote_sequence()
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_thread_suffix_supported_debugserver(self):
+        self.init_debugserver_test()
+        self.thread_suffix_supported()
+
+    @llgs_test
+    def test_thread_suffix_supported_llgs(self):
+        self.init_llgs_test()
+        self.thread_suffix_supported()
+
+    def list_threads_in_stop_reply_supported(self):
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        self.add_no_ack_remote_stream()
+        self.test_sequence.add_log_lines(
+            ["lldb-server <  27> read packet: $QListThreadsInStopReply#21",
+             "lldb-server <   6> send packet: $OK#9a"],
+            True)
+        self.expect_gdbremote_sequence()
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_list_threads_in_stop_reply_supported_debugserver(self):
+        self.init_debugserver_test()
+        self.list_threads_in_stop_reply_supported()
+
+    @llgs_test
+    def test_list_threads_in_stop_reply_supported_llgs(self):
+        self.init_llgs_test()
+        self.list_threads_in_stop_reply_supported()
+
+    def c_packet_works(self):
+        launch_args = self.install_and_create_launch_args()
+
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        self.add_no_ack_remote_stream()
+        self.add_verified_launch_packets(launch_args)
+        self.test_sequence.add_log_lines(
+            ["read packet: $c#63",
+             "send packet: $W00#00"],
+            True)
+
+        self.expect_gdbremote_sequence()
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_c_packet_works_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.c_packet_works()
+
+    @llgs_test
+    def test_c_packet_works_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.c_packet_works()
+
+    def inferior_print_exit(self):
+        launch_args = self.install_and_create_launch_args()
+
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        # build launch args
+        launch_args += ["hello, world"]
+
+        self.add_no_ack_remote_stream()
+        self.add_verified_launch_packets(launch_args)
+        self.test_sequence.add_log_lines(
+            ["read packet: $vCont;c#a8",
+             {"type": "output_match", "regex": self.maybe_strict_output_regex(r"hello, world\r\n")},
+             "send packet: $W00#00"],
+            True)
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_inferior_print_exit_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.inferior_print_exit()
+
+    @llgs_test
+    @expectedFlakeyLinux("llvm.org/pr25652")
+    def test_inferior_print_exit_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.inferior_print_exit()
+
+    def first_launch_stop_reply_thread_matches_first_qC(self):
+        launch_args = self.install_and_create_launch_args()
+
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        # build launch args
+        launch_args += ["hello, world"]
+
+        self.add_no_ack_remote_stream()
+        self.add_verified_launch_packets(launch_args)
+        self.test_sequence.add_log_lines(["read packet: $qC#00",
+                                          {"direction": "send",
+                                           "regex": r"^\$QC([0-9a-fA-F]+)#",
+                                           "capture": {1: "thread_id"}},
+                                          "read packet: $?#00",
+                                          {"direction": "send",
+                                              "regex": r"^\$T[0-9a-fA-F]{2}thread:([0-9a-fA-F]+)",
+                                              "expect_captures": {1: "thread_id"}}],
+                                         True)
+        self.expect_gdbremote_sequence()
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_first_launch_stop_reply_thread_matches_first_qC_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.first_launch_stop_reply_thread_matches_first_qC()
+
+    @llgs_test
+    def test_first_launch_stop_reply_thread_matches_first_qC_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.first_launch_stop_reply_thread_matches_first_qC()
+
+    def attach_commandline_continue_app_exits(self):
+        procs = self.prep_debug_monitor_and_inferior()
+        self.test_sequence.add_log_lines(
+            ["read packet: $vCont;c#a8",
+             "send packet: $W00#00"],
+            True)
+        self.expect_gdbremote_sequence()
+
+        # Wait a moment for completed and now-detached inferior process to
+        # clear.
+        time.sleep(1)
+
+        if not lldb.remote_platform:
+            # Process should be dead now. Reap results.
+            poll_result = procs["inferior"].poll()
+            self.assertIsNotNone(poll_result)
+
+        # Where possible, verify at the system level that the process is not
+        # running.
+        self.assertFalse(
+            lldbgdbserverutils.process_is_running(
+                procs["inferior"].pid, False))
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_attach_commandline_continue_app_exits_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_attach()
+        self.attach_commandline_continue_app_exits()
+
+    @llgs_test
+    def test_attach_commandline_continue_app_exits_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_attach()
+        self.attach_commandline_continue_app_exits()
+
+    def qRegisterInfo_returns_one_valid_result(self):
+        launch_args = self.install_and_create_launch_args()
+
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        # Build the expected protocol stream
+        self.add_no_ack_remote_stream()
+        self.add_verified_launch_packets(launch_args)
+        self.test_sequence.add_log_lines(
+            ["read packet: $qRegisterInfo0#00",
+             {"direction": "send", "regex": r"^\$(.+);#[0-9A-Fa-f]{2}", "capture": {1: "reginfo_0"}}],
+            True)
+
+        # Run the stream
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        reg_info_packet = context.get("reginfo_0")
+        self.assertIsNotNone(reg_info_packet)
+        self.assert_valid_reg_info(
+            lldbgdbserverutils.parse_reg_info_response(reg_info_packet))
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qRegisterInfo_returns_one_valid_result_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.qRegisterInfo_returns_one_valid_result()
+
+    @llgs_test
+    def test_qRegisterInfo_returns_one_valid_result_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.qRegisterInfo_returns_one_valid_result()
+
+    def qRegisterInfo_returns_all_valid_results(self):
+        launch_args = self.install_and_create_launch_args()
+
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        # Build the expected protocol stream.
+        self.add_no_ack_remote_stream()
+        self.add_verified_launch_packets(launch_args)
+        self.add_register_info_collection_packets()
+
+        # Run the stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Validate that each register info returned validates.
+        for reg_info in self.parse_register_info_packets(context):
+            self.assert_valid_reg_info(reg_info)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qRegisterInfo_returns_all_valid_results_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.qRegisterInfo_returns_all_valid_results()
+
+    @llgs_test
+    def test_qRegisterInfo_returns_all_valid_results_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.qRegisterInfo_returns_all_valid_results()
+
+    def qRegisterInfo_contains_required_generics(self):
+        launch_args = self.install_and_create_launch_args()
+
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        # Build the expected protocol stream
+        self.add_no_ack_remote_stream()
+        self.add_verified_launch_packets(launch_args)
+        self.add_register_info_collection_packets()
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Gather register info entries.
+        reg_infos = self.parse_register_info_packets(context)
+
+        # Collect all generic registers found.
+        generic_regs = {
+            reg_info['generic']: 1 for reg_info in reg_infos if 'generic' in reg_info}
+
+        # Ensure we have a program counter register.
+        self.assertTrue('pc' in generic_regs)
+
+        # Ensure we have a frame pointer register. PPC64le's FP is the same as SP
+        if self.getArchitecture() != 'powerpc64le':
+            self.assertTrue('fp' in generic_regs)
+
+        # Ensure we have a stack pointer register.
+        self.assertTrue('sp' in generic_regs)
+
+        # Ensure we have a flags register.
+        self.assertTrue('flags' in generic_regs)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qRegisterInfo_contains_required_generics_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.qRegisterInfo_contains_required_generics()
+
+    @llgs_test
+    def test_qRegisterInfo_contains_required_generics_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.qRegisterInfo_contains_required_generics()
+
+    def qRegisterInfo_contains_at_least_one_register_set(self):
+        launch_args = self.install_and_create_launch_args()
+
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        # Build the expected protocol stream
+        self.add_no_ack_remote_stream()
+        self.add_verified_launch_packets(launch_args)
+        self.add_register_info_collection_packets()
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Gather register info entries.
+        reg_infos = self.parse_register_info_packets(context)
+
+        # Collect all register sets found.
+        register_sets = {
+            reg_info['set']: 1 for reg_info in reg_infos if 'set' in reg_info}
+        self.assertTrue(len(register_sets) >= 1)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qRegisterInfo_contains_at_least_one_register_set_debugserver(
+            self):
+        self.init_debugserver_test()
+        self.build()
+        self.qRegisterInfo_contains_at_least_one_register_set()
+
+    @llgs_test
+    def test_qRegisterInfo_contains_at_least_one_register_set_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.qRegisterInfo_contains_at_least_one_register_set()
+
+    def targetHasAVX(self):
+        triple = self.dbg.GetSelectedPlatform().GetTriple()
+
+        # TODO other platforms, please implement this function
+        if not re.match(".*-.*-linux", triple):
+            return True
+
+        # Need to do something different for non-Linux/Android targets
+        if lldb.remote_platform:
+            self.runCmd('platform get-file "/proc/cpuinfo" "cpuinfo"')
+            cpuinfo_path = "cpuinfo"
+            self.addTearDownHook(lambda: os.unlink("cpuinfo"))
+        else:
+            cpuinfo_path = "/proc/cpuinfo"
+
+        f = open(cpuinfo_path, 'r')
+        cpuinfo = f.read()
+        f.close()
+        return " avx " in cpuinfo
+
+    def qRegisterInfo_contains_avx_registers(self):
+        launch_args = self.install_and_create_launch_args()
+
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        # Build the expected protocol stream
+        self.add_no_ack_remote_stream()
+        self.add_verified_launch_packets(launch_args)
+        self.add_register_info_collection_packets()
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Gather register info entries.
+        reg_infos = self.parse_register_info_packets(context)
+
+        # Collect all generics found.
+        register_sets = {
+            reg_info['set']: 1 for reg_info in reg_infos if 'set' in reg_info}
+        self.assertEqual(
+            self.targetHasAVX(),
+            "Advanced Vector Extensions" in register_sets)
+
+    @llgs_test
+    def test_qRegisterInfo_contains_avx_registers_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.qRegisterInfo_contains_avx_registers()
+
+    def qThreadInfo_contains_thread(self):
+        procs = self.prep_debug_monitor_and_inferior()
+        self.add_threadinfo_collection_packets()
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Gather threadinfo entries.
+        threads = self.parse_threadinfo_packets(context)
+        self.assertIsNotNone(threads)
+
+        # We should have exactly one thread.
+        self.assertEqual(len(threads), 1)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qThreadInfo_contains_thread_launch_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qThreadInfo_contains_thread()
+
+    @llgs_test
+    def test_qThreadInfo_contains_thread_launch_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qThreadInfo_contains_thread()
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qThreadInfo_contains_thread_attach_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_attach()
+        self.qThreadInfo_contains_thread()
+
+    @llgs_test
+    def test_qThreadInfo_contains_thread_attach_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_attach()
+        self.qThreadInfo_contains_thread()
+
+    def qThreadInfo_matches_qC(self):
+        procs = self.prep_debug_monitor_and_inferior()
+
+        self.add_threadinfo_collection_packets()
+        self.test_sequence.add_log_lines(
+            ["read packet: $qC#00",
+             {"direction": "send", "regex": r"^\$QC([0-9a-fA-F]+)#", "capture": {1: "thread_id"}}
+             ], True)
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Gather threadinfo entries.
+        threads = self.parse_threadinfo_packets(context)
+        self.assertIsNotNone(threads)
+
+        # We should have exactly one thread from threadinfo.
+        self.assertEqual(len(threads), 1)
+
+        # We should have a valid thread_id from $QC.
+        QC_thread_id_hex = context.get("thread_id")
+        self.assertIsNotNone(QC_thread_id_hex)
+        QC_thread_id = int(QC_thread_id_hex, 16)
+
+        # Those two should be the same.
+        self.assertEqual(threads[0], QC_thread_id)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qThreadInfo_matches_qC_launch_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qThreadInfo_matches_qC()
+
+    @llgs_test
+    def test_qThreadInfo_matches_qC_launch_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qThreadInfo_matches_qC()
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qThreadInfo_matches_qC_attach_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_attach()
+        self.qThreadInfo_matches_qC()
+
+    @llgs_test
+    def test_qThreadInfo_matches_qC_attach_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_attach()
+        self.qThreadInfo_matches_qC()
+
+    def p_returns_correct_data_size_for_each_qRegisterInfo(self):
+        procs = self.prep_debug_monitor_and_inferior()
+        self.add_register_info_collection_packets()
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Gather register info entries.
+        reg_infos = self.parse_register_info_packets(context)
+        self.assertIsNotNone(reg_infos)
+        self.assertTrue(len(reg_infos) > 0)
+
+        byte_order = self.get_target_byte_order()
+
+        # Read value for each register.
+        reg_index = 0
+        for reg_info in reg_infos:
+            # Skip registers that don't have a register set.  For x86, these are
+            # the DRx registers, which have no LLDB-kind register number and thus
+            # cannot be read via normal
+            # NativeRegisterContext::ReadRegister(reg_info,...) calls.
+            if not "set" in reg_info:
+                continue
+
+            # Clear existing packet expectations.
+            self.reset_test_sequence()
+
+            # Run the register query
+            self.test_sequence.add_log_lines(
+                ["read packet: $p{0:x}#00".format(reg_index),
+                 {"direction": "send", "regex": r"^\$([0-9a-fA-F]+)#", "capture": {1: "p_response"}}],
+                True)
+            context = self.expect_gdbremote_sequence()
+            self.assertIsNotNone(context)
+
+            # Verify the response length.
+            p_response = context.get("p_response")
+            self.assertIsNotNone(p_response)
+
+            if "dynamic_size_dwarf_expr_bytes" in reg_info:
+                self.updateRegInfoBitsize(reg_info, byte_order)
+            self.assertEqual(len(p_response), 2 * int(reg_info["bitsize"]) / 8)
+
+            # Increment loop
+            reg_index += 1
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_p_returns_correct_data_size_for_each_qRegisterInfo_launch_debugserver(
+            self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.p_returns_correct_data_size_for_each_qRegisterInfo()
+
+    @llgs_test
+    def test_p_returns_correct_data_size_for_each_qRegisterInfo_launch_llgs(
+            self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.p_returns_correct_data_size_for_each_qRegisterInfo()
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_p_returns_correct_data_size_for_each_qRegisterInfo_attach_debugserver(
+            self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_attach()
+        self.p_returns_correct_data_size_for_each_qRegisterInfo()
+
+    @llgs_test
+    def test_p_returns_correct_data_size_for_each_qRegisterInfo_attach_llgs(
+            self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_attach()
+        self.p_returns_correct_data_size_for_each_qRegisterInfo()
+
+    def Hg_switches_to_3_threads(self):
+        # Startup the inferior with three threads (main + 2 new ones).
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=["thread:new", "thread:new"])
+
+        # Let the inferior process have a few moments to start up the thread
+        # when launched.  (The launch scenario has no time to run, so threads
+        # won't be there yet.)
+        self.run_process_then_stop(run_seconds=1)
+
+        # Wait at most x seconds for 3 threads to be present.
+        threads = self.wait_for_thread_count(3, timeout_seconds=5)
+        self.assertEqual(len(threads), 3)
+
+        # verify we can $H to each thead, and $qC matches the thread we set.
+        for thread in threads:
+            # Change to each thread, verify current thread id.
+            self.reset_test_sequence()
+            self.test_sequence.add_log_lines(
+                ["read packet: $Hg{0:x}#00".format(thread),  # Set current thread.
+                 "send packet: $OK#00",
+                 "read packet: $qC#00",
+                 {"direction": "send", "regex": r"^\$QC([0-9a-fA-F]+)#", "capture": {1: "thread_id"}}],
+                True)
+
+            context = self.expect_gdbremote_sequence()
+            self.assertIsNotNone(context)
+
+            # Verify the thread id.
+            self.assertIsNotNone(context.get("thread_id"))
+            self.assertEqual(int(context.get("thread_id"), 16), thread)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_Hg_switches_to_3_threads_launch_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.Hg_switches_to_3_threads()
+
+    @llgs_test
+    def test_Hg_switches_to_3_threads_launch_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.Hg_switches_to_3_threads()
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_Hg_switches_to_3_threads_attach_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_attach()
+        self.Hg_switches_to_3_threads()
+
+    @llgs_test
+    def test_Hg_switches_to_3_threads_attach_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_attach()
+        self.Hg_switches_to_3_threads()
+
+    def Hc_then_Csignal_signals_correct_thread(self, segfault_signo):
+        # NOTE only run this one in inferior-launched mode: we can't grab inferior stdout when running attached,
+        # and the test requires getting stdout from the exe.
+
+        NUM_THREADS = 3
+
+        # Startup the inferior with three threads (main + NUM_THREADS-1 worker threads).
+        # inferior_args=["thread:print-ids"]
+        inferior_args = ["thread:segfault"]
+        for i in range(NUM_THREADS - 1):
+            # if i > 0:
+                # Give time between thread creation/segfaulting for the handler to work.
+                # inferior_args.append("sleep:1")
+            inferior_args.append("thread:new")
+        inferior_args.append("sleep:10")
+
+        # Launch/attach.  (In our case, this should only ever be launched since
+        # we need inferior stdout/stderr).
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=inferior_args)
+        self.test_sequence.add_log_lines(["read packet: $c#63"], True)
+        context = self.expect_gdbremote_sequence()
+
+        # Let the inferior process have a few moments to start up the thread when launched.
+        # context = self.run_process_then_stop(run_seconds=1)
+
+        # Wait at most x seconds for all threads to be present.
+        # threads = self.wait_for_thread_count(NUM_THREADS, timeout_seconds=5)
+        # self.assertEquals(len(threads), NUM_THREADS)
+
+        signaled_tids = {}
+        print_thread_ids = {}
+
+        # Switch to each thread, deliver a signal, and verify signal delivery
+        for i in range(NUM_THREADS - 1):
+            # Run until SIGSEGV comes in.
+            self.reset_test_sequence()
+            self.test_sequence.add_log_lines([{"direction": "send",
+                                               "regex": r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);",
+                                               "capture": {1: "signo",
+                                                            2: "thread_id"}}],
+                                             True)
+
+            context = self.expect_gdbremote_sequence(timeout_seconds=10)
+            self.assertIsNotNone(context)
+            signo = context.get("signo")
+            self.assertEqual(int(signo, 16), segfault_signo)
+
+            # Ensure we haven't seen this tid yet.
+            thread_id = int(context.get("thread_id"), 16)
+            self.assertFalse(thread_id in signaled_tids)
+            signaled_tids[thread_id] = 1
+
+            # Send SIGUSR1 to the thread that signaled the SIGSEGV.
+            self.reset_test_sequence()
+            self.test_sequence.add_log_lines(
+                [
+                    # Set the continue thread.
+                    # Set current thread.
+                    "read packet: $Hc{0:x}#00".format(thread_id),
+                    "send packet: $OK#00",
+
+                    # Continue sending the signal number to the continue thread.
+                    # The commented out packet is a way to do this same operation without using
+                    # a $Hc (but this test is testing $Hc, so we'll stick with the former).
+                    "read packet: $C{0:x}#00".format(lldbutil.get_signal_number('SIGUSR1')),
+                    # "read packet: $vCont;C{0:x}:{1:x};c#00".format(lldbutil.get_signal_number('SIGUSR1'), thread_id),
+
+                    # FIXME: Linux does not report the thread stop on the delivered signal (SIGUSR1 here).  MacOSX debugserver does.
+                    # But MacOSX debugserver isn't guaranteeing the thread the signal handler runs on, so currently its an XFAIL.
+                    # Need to rectify behavior here.  The linux behavior is more intuitive to me since we're essentially swapping out
+                    # an about-to-be-delivered signal (for which we already sent a stop packet) to a different signal.
+                    # {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} },
+                    #  "read packet: $c#63",
+                    {"type": "output_match", "regex": r"^received SIGUSR1 on thread id: ([0-9a-fA-F]+)\r\nthread ([0-9a-fA-F]+): past SIGSEGV\r\n", "capture": {1: "print_thread_id", 2: "post_handle_thread_id"}},
+                ],
+                True)
+
+            # Run the sequence.
+            context = self.expect_gdbremote_sequence(timeout_seconds=10)
+            self.assertIsNotNone(context)
+
+            # Ensure the stop signal is the signal we delivered.
+            # stop_signo = context.get("stop_signo")
+            # self.assertIsNotNone(stop_signo)
+            # self.assertEquals(int(stop_signo,16), lldbutil.get_signal_number('SIGUSR1'))
+
+            # Ensure the stop thread is the thread to which we delivered the signal.
+            # stop_thread_id = context.get("stop_thread_id")
+            # self.assertIsNotNone(stop_thread_id)
+            # self.assertEquals(int(stop_thread_id,16), thread_id)
+
+            # Ensure we haven't seen this thread id yet.  The inferior's
+            # self-obtained thread ids are not guaranteed to match the stub
+            # tids (at least on MacOSX).
+            print_thread_id = context.get("print_thread_id")
+            self.assertIsNotNone(print_thread_id)
+            print_thread_id = int(print_thread_id, 16)
+            self.assertFalse(print_thread_id in print_thread_ids)
+
+            # Now remember this print (i.e. inferior-reflected) thread id and
+            # ensure we don't hit it again.
+            print_thread_ids[print_thread_id] = 1
+
+            # Ensure post signal-handle thread id matches the thread that
+            # initially raised the SIGSEGV.
+            post_handle_thread_id = context.get("post_handle_thread_id")
+            self.assertIsNotNone(post_handle_thread_id)
+            post_handle_thread_id = int(post_handle_thread_id, 16)
+            self.assertEqual(post_handle_thread_id, print_thread_id)
+
+    @unittest2.expectedFailure()
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_Hc_then_Csignal_signals_correct_thread_launch_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        # Darwin debugserver translates some signals like SIGSEGV into some gdb
+        # expectations about fixed signal numbers.
+        self.Hc_then_Csignal_signals_correct_thread(self.TARGET_EXC_BAD_ACCESS)
+
+    @llgs_test
+    def test_Hc_then_Csignal_signals_correct_thread_launch_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.Hc_then_Csignal_signals_correct_thread(
+            lldbutil.get_signal_number('SIGSEGV'))
+
+    def m_packet_reads_memory(self):
+        # This is the memory we will write into the inferior and then ensure we
+        # can read back with $m.
+        MEMORY_CONTENTS = "Test contents 0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz"
+
+        # Start up the inferior.
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=[
+                "set-message:%s" %
+                MEMORY_CONTENTS,
+                "get-data-address-hex:g_message",
+                "sleep:5"])
+
+        # Run the process
+        self.test_sequence.add_log_lines(
+            [
+                # Start running after initial stop.
+                "read packet: $c#63",
+                # Match output line that prints the memory address of the message buffer within the inferior.
+                # Note we require launch-only testing so we can get inferior otuput.
+                {"type": "output_match", "regex": self.maybe_strict_output_regex(r"data address: 0x([0-9a-fA-F]+)\r\n"),
+                 "capture": {1: "message_address"}},
+                # Now stop the inferior.
+                "read packet: {}".format(chr(3)),
+                # And wait for the stop notification.
+                {"direction": "send", "regex": r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture": {1: "stop_signo", 2: "stop_thread_id"}}],
+            True)
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Grab the message address.
+        self.assertIsNotNone(context.get("message_address"))
+        message_address = int(context.get("message_address"), 16)
+
+        # Grab contents from the inferior.
+        self.reset_test_sequence()
+        self.test_sequence.add_log_lines(
+            ["read packet: $m{0:x},{1:x}#00".format(message_address, len(MEMORY_CONTENTS)),
+             {"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$", "capture": {1: "read_contents"}}],
+            True)
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Ensure what we read from inferior memory is what we wrote.
+        self.assertIsNotNone(context.get("read_contents"))
+        read_contents = seven.unhexlify(context.get("read_contents"))
+        self.assertEqual(read_contents, MEMORY_CONTENTS)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_m_packet_reads_memory_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.m_packet_reads_memory()
+
+    @llgs_test
+    def test_m_packet_reads_memory_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.m_packet_reads_memory()
+
+    def qMemoryRegionInfo_is_supported(self):
+        # Start up the inferior.
+        procs = self.prep_debug_monitor_and_inferior()
+
+        # Ask if it supports $qMemoryRegionInfo.
+        self.test_sequence.add_log_lines(
+            ["read packet: $qMemoryRegionInfo#00",
+             "send packet: $OK#00"
+             ], True)
+        self.expect_gdbremote_sequence()
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qMemoryRegionInfo_is_supported_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qMemoryRegionInfo_is_supported()
+
+    @llgs_test
+    def test_qMemoryRegionInfo_is_supported_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qMemoryRegionInfo_is_supported()
+
+    def qMemoryRegionInfo_reports_code_address_as_executable(self):
+        # Start up the inferior.
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=["get-code-address-hex:hello", "sleep:5"])
+
+        # Run the process
+        self.test_sequence.add_log_lines(
+            [
+                # Start running after initial stop.
+                "read packet: $c#63",
+                # Match output line that prints the memory address of the message buffer within the inferior.
+                # Note we require launch-only testing so we can get inferior otuput.
+                {"type": "output_match", "regex": self.maybe_strict_output_regex(r"code address: 0x([0-9a-fA-F]+)\r\n"),
+                 "capture": {1: "code_address"}},
+                # Now stop the inferior.
+                "read packet: {}".format(chr(3)),
+                # And wait for the stop notification.
+                {"direction": "send", "regex": r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture": {1: "stop_signo", 2: "stop_thread_id"}}],
+            True)
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Grab the code address.
+        self.assertIsNotNone(context.get("code_address"))
+        code_address = int(context.get("code_address"), 16)
+
+        # Grab memory region info from the inferior.
+        self.reset_test_sequence()
+        self.add_query_memory_region_packets(code_address)
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+        mem_region_dict = self.parse_memory_region_packet(context)
+
+        # Ensure there are no errors reported.
+        self.assertFalse("error" in mem_region_dict)
+
+        # Ensure code address is readable and executable.
+        self.assertTrue("permissions" in mem_region_dict)
+        self.assertTrue("r" in mem_region_dict["permissions"])
+        self.assertTrue("x" in mem_region_dict["permissions"])
+
+        # Ensure the start address and size encompass the address we queried.
+        self.assert_address_within_memory_region(code_address, mem_region_dict)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qMemoryRegionInfo_reports_code_address_as_executable_debugserver(
+            self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qMemoryRegionInfo_reports_code_address_as_executable()
+
+    @llgs_test
+    def test_qMemoryRegionInfo_reports_code_address_as_executable_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qMemoryRegionInfo_reports_code_address_as_executable()
+
+    def qMemoryRegionInfo_reports_stack_address_as_readable_writeable(self):
+        # Start up the inferior.
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=["get-stack-address-hex:", "sleep:5"])
+
+        # Run the process
+        self.test_sequence.add_log_lines(
+            [
+                # Start running after initial stop.
+                "read packet: $c#63",
+                # Match output line that prints the memory address of the message buffer within the inferior.
+                # Note we require launch-only testing so we can get inferior otuput.
+                {"type": "output_match", "regex": self.maybe_strict_output_regex(r"stack address: 0x([0-9a-fA-F]+)\r\n"),
+                 "capture": {1: "stack_address"}},
+                # Now stop the inferior.
+                "read packet: {}".format(chr(3)),
+                # And wait for the stop notification.
+                {"direction": "send", "regex": r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture": {1: "stop_signo", 2: "stop_thread_id"}}],
+            True)
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Grab the address.
+        self.assertIsNotNone(context.get("stack_address"))
+        stack_address = int(context.get("stack_address"), 16)
+
+        # Grab memory region info from the inferior.
+        self.reset_test_sequence()
+        self.add_query_memory_region_packets(stack_address)
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+        mem_region_dict = self.parse_memory_region_packet(context)
+
+        # Ensure there are no errors reported.
+        self.assertFalse("error" in mem_region_dict)
+
+        # Ensure address is readable and executable.
+        self.assertTrue("permissions" in mem_region_dict)
+        self.assertTrue("r" in mem_region_dict["permissions"])
+        self.assertTrue("w" in mem_region_dict["permissions"])
+
+        # Ensure the start address and size encompass the address we queried.
+        self.assert_address_within_memory_region(
+            stack_address, mem_region_dict)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qMemoryRegionInfo_reports_stack_address_as_readable_writeable_debugserver(
+            self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qMemoryRegionInfo_reports_stack_address_as_readable_writeable()
+
+    @llgs_test
+    def test_qMemoryRegionInfo_reports_stack_address_as_readable_writeable_llgs(
+            self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qMemoryRegionInfo_reports_stack_address_as_readable_writeable()
+
+    def qMemoryRegionInfo_reports_heap_address_as_readable_writeable(self):
+        # Start up the inferior.
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=["get-heap-address-hex:", "sleep:5"])
+
+        # Run the process
+        self.test_sequence.add_log_lines(
+            [
+                # Start running after initial stop.
+                "read packet: $c#63",
+                # Match output line that prints the memory address of the message buffer within the inferior.
+                # Note we require launch-only testing so we can get inferior otuput.
+                {"type": "output_match", "regex": self.maybe_strict_output_regex(r"heap address: 0x([0-9a-fA-F]+)\r\n"),
+                 "capture": {1: "heap_address"}},
+                # Now stop the inferior.
+                "read packet: {}".format(chr(3)),
+                # And wait for the stop notification.
+                {"direction": "send", "regex": r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture": {1: "stop_signo", 2: "stop_thread_id"}}],
+            True)
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Grab the address.
+        self.assertIsNotNone(context.get("heap_address"))
+        heap_address = int(context.get("heap_address"), 16)
+
+        # Grab memory region info from the inferior.
+        self.reset_test_sequence()
+        self.add_query_memory_region_packets(heap_address)
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+        mem_region_dict = self.parse_memory_region_packet(context)
+
+        # Ensure there are no errors reported.
+        self.assertFalse("error" in mem_region_dict)
+
+        # Ensure address is readable and executable.
+        self.assertTrue("permissions" in mem_region_dict)
+        self.assertTrue("r" in mem_region_dict["permissions"])
+        self.assertTrue("w" in mem_region_dict["permissions"])
+
+        # Ensure the start address and size encompass the address we queried.
+        self.assert_address_within_memory_region(heap_address, mem_region_dict)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qMemoryRegionInfo_reports_heap_address_as_readable_writeable_debugserver(
+            self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qMemoryRegionInfo_reports_heap_address_as_readable_writeable()
+
+    @llgs_test
+    def test_qMemoryRegionInfo_reports_heap_address_as_readable_writeable_llgs(
+            self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qMemoryRegionInfo_reports_heap_address_as_readable_writeable()
+
+    def breakpoint_set_and_remove_work(self, want_hardware=False):
+        # Start up the inferior.
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=[
+                "get-code-address-hex:hello",
+                "sleep:1",
+                "call-function:hello"])
+
+        # Run the process
+        self.add_register_info_collection_packets()
+        self.add_process_info_collection_packets()
+        self.test_sequence.add_log_lines(
+            [  # Start running after initial stop.
+                "read packet: $c#63",
+                # Match output line that prints the memory address of the function call entry point.
+                # Note we require launch-only testing so we can get inferior otuput.
+                {"type": "output_match", "regex": self.maybe_strict_output_regex(r"code address: 0x([0-9a-fA-F]+)\r\n"),
+                 "capture": {1: "function_address"}},
+                # Now stop the inferior.
+                "read packet: {}".format(chr(3)),
+                # And wait for the stop notification.
+                {"direction": "send", "regex": r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture": {1: "stop_signo", 2: "stop_thread_id"}}],
+            True)
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Gather process info - we need endian of target to handle register
+        # value conversions.
+        process_info = self.parse_process_info_response(context)
+        endian = process_info.get("endian")
+        self.assertIsNotNone(endian)
+
+        # Gather register info entries.
+        reg_infos = self.parse_register_info_packets(context)
+        (pc_lldb_reg_index, pc_reg_info) = self.find_pc_reg_info(reg_infos)
+        self.assertIsNotNone(pc_lldb_reg_index)
+        self.assertIsNotNone(pc_reg_info)
+
+        # Grab the function address.
+        self.assertIsNotNone(context.get("function_address"))
+        function_address = int(context.get("function_address"), 16)
+
+        # Get current target architecture
+        target_arch = self.getArchitecture()
+
+        # Set the breakpoint.
+        if (target_arch == "arm") or (target_arch == "aarch64"):
+            # TODO: Handle case when setting breakpoint in thumb code
+            BREAKPOINT_KIND = 4
+        else:
+            BREAKPOINT_KIND = 1
+
+        # Set default packet type to Z0 (software breakpoint)
+        z_packet_type = 0
+
+        # If hardware breakpoint is requested set packet type to Z1
+        if want_hardware == True:
+            z_packet_type = 1
+
+        self.reset_test_sequence()
+        self.add_set_breakpoint_packets(
+            function_address,
+            z_packet_type,
+            do_continue=True,
+            breakpoint_kind=BREAKPOINT_KIND)
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Verify the stop signal reported was the breakpoint signal number.
+        stop_signo = context.get("stop_signo")
+        self.assertIsNotNone(stop_signo)
+        self.assertEqual(int(stop_signo, 16),
+                         lldbutil.get_signal_number('SIGTRAP'))
+
+        # Ensure we did not receive any output.  If the breakpoint was not set, we would
+        # see output (from a launched process with captured stdio) printing a hello, world message.
+        # That would indicate the breakpoint didn't take.
+        self.assertEqual(len(context["O_content"]), 0)
+
+        # Verify that the PC for the main thread is where we expect it - right at the breakpoint address.
+        # This acts as a another validation on the register reading code.
+        self.reset_test_sequence()
+        self.test_sequence.add_log_lines(
+            [
+                # Print the PC.  This should match the breakpoint address.
+                "read packet: $p{0:x}#00".format(pc_lldb_reg_index),
+                # Capture $p results.
+                {"direction": "send",
+                 "regex": r"^\$([0-9a-fA-F]+)#",
+                 "capture": {1: "p_response"}},
+            ], True)
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Verify the PC is where we expect.  Note response is in endianness of
+        # the inferior.
+        p_response = context.get("p_response")
+        self.assertIsNotNone(p_response)
+
+        # Convert from target endian to int.
+        returned_pc = lldbgdbserverutils.unpack_register_hex_unsigned(
+            endian, p_response)
+        self.assertEqual(returned_pc, function_address)
+
+        # Verify that a breakpoint remove and continue gets us the expected
+        # output.
+        self.reset_test_sequence()
+
+        # Add breakpoint remove packets
+        self.add_remove_breakpoint_packets(
+            function_address,
+            z_packet_type,
+            breakpoint_kind=BREAKPOINT_KIND)
+
+        self.test_sequence.add_log_lines(
+            [
+                # Continue running.
+                "read packet: $c#63",
+                # We should now receive the output from the call.
+                {"type": "output_match", "regex": r"^hello, world\r\n$"},
+                # And wait for program completion.
+                {"direction": "send", "regex": r"^\$W00(.*)#[0-9a-fA-F]{2}$"},
+            ], True)
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_software_breakpoint_set_and_remove_work_debugserver(self):
+        self.init_debugserver_test()
+        if self.getArchitecture() == "arm":
+            # TODO: Handle case when setting breakpoint in thumb code
+            self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
+        else:
+            self.build()
+        self.set_inferior_startup_launch()
+        self.breakpoint_set_and_remove_work(want_hardware=False)
+
+    @llgs_test
+    @expectedFlakeyLinux("llvm.org/pr25652")
+    def test_software_breakpoint_set_and_remove_work_llgs(self):
+        self.init_llgs_test()
+        if self.getArchitecture() == "arm":
+            # TODO: Handle case when setting breakpoint in thumb code
+            self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
+        else:
+            self.build()
+        self.set_inferior_startup_launch()
+        self.breakpoint_set_and_remove_work(want_hardware=False)
+
+    @debugserver_test
+    @skipUnlessPlatform(oslist=['linux'])
+    @expectedFailureAndroid
+    @skipIf(archs=no_match(['arm', 'aarch64']))
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_hardware_breakpoint_set_and_remove_work_debugserver(self):
+        self.init_debugserver_test()
+        if self.getArchitecture() == "arm":
+            # TODO: Handle case when setting breakpoint in thumb code
+            self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
+        else:
+            self.build()
+        self.set_inferior_startup_launch()
+        self.breakpoint_set_and_remove_work(want_hardware=True)
+
+    @llgs_test
+    @skipUnlessPlatform(oslist=['linux'])
+    @expectedFailureAndroid
+    @skipIf(archs=no_match(['arm', 'aarch64']))
+    def test_hardware_breakpoint_set_and_remove_work_llgs(self):
+        self.init_llgs_test()
+        if self.getArchitecture() == "arm":
+            # TODO: Handle case when setting breakpoint in thumb code
+            self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
+        else:
+            self.build()
+        self.set_inferior_startup_launch()
+        self.breakpoint_set_and_remove_work(want_hardware=True)
+
+    def qSupported_returns_known_stub_features(self):
+        # Start up the stub and start/prep the inferior.
+        procs = self.prep_debug_monitor_and_inferior()
+        self.add_qSupported_packets()
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Retrieve the qSupported features.
+        supported_dict = self.parse_qSupported_response(context)
+        self.assertIsNotNone(supported_dict)
+        self.assertTrue(len(supported_dict) > 0)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_qSupported_returns_known_stub_features_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qSupported_returns_known_stub_features()
+
+    @llgs_test
+    def test_qSupported_returns_known_stub_features_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.qSupported_returns_known_stub_features()
+
+    def written_M_content_reads_back_correctly(self):
+        TEST_MESSAGE = "Hello, memory"
+
+        # Start up the stub and start/prep the inferior.
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=[
+                "set-message:xxxxxxxxxxxxxX",
+                "get-data-address-hex:g_message",
+                "sleep:1",
+                "print-message:"])
+        self.test_sequence.add_log_lines(
+            [
+                # Start running after initial stop.
+                "read packet: $c#63",
+                # Match output line that prints the memory address of the message buffer within the inferior.
+                # Note we require launch-only testing so we can get inferior otuput.
+                {"type": "output_match", "regex": self.maybe_strict_output_regex(r"data address: 0x([0-9a-fA-F]+)\r\n"),
+                 "capture": {1: "message_address"}},
+                # Now stop the inferior.
+                "read packet: {}".format(chr(3)),
+                # And wait for the stop notification.
+                {"direction": "send", "regex": r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture": {1: "stop_signo", 2: "stop_thread_id"}}],
+            True)
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Grab the message address.
+        self.assertIsNotNone(context.get("message_address"))
+        message_address = int(context.get("message_address"), 16)
+
+        # Hex-encode the test message, adding null termination.
+        hex_encoded_message = seven.hexlify(TEST_MESSAGE)
+
+        # Write the message to the inferior. Verify that we can read it with the hex-encoded (m)
+        # and binary (x) memory read packets.
+        self.reset_test_sequence()
+        self.test_sequence.add_log_lines(
+            ["read packet: $M{0:x},{1:x}:{2}#00".format(message_address, len(TEST_MESSAGE), hex_encoded_message),
+             "send packet: $OK#00",
+             "read packet: $m{0:x},{1:x}#00".format(message_address, len(TEST_MESSAGE)),
+             "send packet: ${0}#00".format(hex_encoded_message),
+             "read packet: $x{0:x},{1:x}#00".format(message_address, len(TEST_MESSAGE)),
+             "send packet: ${0}#00".format(TEST_MESSAGE),
+             "read packet: $m{0:x},4#00".format(message_address),
+             "send packet: ${0}#00".format(hex_encoded_message[0:8]),
+             "read packet: $x{0:x},4#00".format(message_address),
+             "send packet: ${0}#00".format(TEST_MESSAGE[0:4]),
+             "read packet: $c#63",
+             {"type": "output_match", "regex": r"^message: (.+)\r\n$", "capture": {1: "printed_message"}},
+             "send packet: $W00#00",
+             ], True)
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Ensure what we read from inferior memory is what we wrote.
+        printed_message = context.get("printed_message")
+        self.assertIsNotNone(printed_message)
+        self.assertEqual(printed_message, TEST_MESSAGE + "X")
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_written_M_content_reads_back_correctly_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.written_M_content_reads_back_correctly()
+
+    @llgs_test
+    @expectedFlakeyLinux("llvm.org/pr25652")
+    def test_written_M_content_reads_back_correctly_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.written_M_content_reads_back_correctly()
+
+    def P_writes_all_gpr_registers(self):
+        # Start inferior debug session, grab all register info.
+        procs = self.prep_debug_monitor_and_inferior(inferior_args=["sleep:2"])
+        self.add_register_info_collection_packets()
+        self.add_process_info_collection_packets()
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Process register infos.
+        reg_infos = self.parse_register_info_packets(context)
+        self.assertIsNotNone(reg_infos)
+        self.add_lldb_register_index(reg_infos)
+
+        # Process endian.
+        process_info = self.parse_process_info_response(context)
+        endian = process_info.get("endian")
+        self.assertIsNotNone(endian)
+
+        # Pull out the register infos that we think we can bit flip
+        # successfully,.
+        gpr_reg_infos = [
+            reg_info for reg_info in reg_infos if self.is_bit_flippable_register(reg_info)]
+        self.assertTrue(len(gpr_reg_infos) > 0)
+
+        # Write flipped bit pattern of existing value to each register.
+        (successful_writes, failed_writes) = self.flip_all_bits_in_each_register_value(
+            gpr_reg_infos, endian)
+        # print("successful writes: {}, failed writes: {}".format(successful_writes, failed_writes))
+        self.assertTrue(successful_writes > 0)
+
+    # Note: as of this moment, a hefty number of the GPR writes are failing with E32 (everything except rax-rdx, rdi, rsi, rbp).
+    # Come back to this.  I have the test rigged to verify that at least some
+    # of the bit-flip writes work.
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_P_writes_all_gpr_registers_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.P_writes_all_gpr_registers()
+
+    @llgs_test
+    def test_P_writes_all_gpr_registers_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.P_writes_all_gpr_registers()
+
+    def P_and_p_thread_suffix_work(self):
+        # Startup the inferior with three threads.
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=["thread:new", "thread:new"])
+        self.add_thread_suffix_request_packets()
+        self.add_register_info_collection_packets()
+        self.add_process_info_collection_packets()
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        process_info = self.parse_process_info_response(context)
+        self.assertIsNotNone(process_info)
+        endian = process_info.get("endian")
+        self.assertIsNotNone(endian)
+
+        reg_infos = self.parse_register_info_packets(context)
+        self.assertIsNotNone(reg_infos)
+        self.add_lldb_register_index(reg_infos)
+
+        reg_index = self.select_modifiable_register(reg_infos)
+        self.assertIsNotNone(reg_index)
+        reg_byte_size = int(reg_infos[reg_index]["bitsize"]) // 8
+        self.assertTrue(reg_byte_size > 0)
+
+        # Run the process a bit so threads can start up, and collect register
+        # info.
+        context = self.run_process_then_stop(run_seconds=1)
+        self.assertIsNotNone(context)
+
+        # Wait for 3 threads to be present.
+        threads = self.wait_for_thread_count(3, timeout_seconds=5)
+        self.assertEqual(len(threads), 3)
+
+        expected_reg_values = []
+        register_increment = 1
+        next_value = None
+
+        # Set the same register in each of 3 threads to a different value.
+        # Verify each one has the unique value.
+        for thread in threads:
+            # If we don't have a next value yet, start it with the initial read
+            # value + 1
+            if not next_value:
+                # Read pre-existing register value.
+                self.reset_test_sequence()
+                self.test_sequence.add_log_lines(
+                    ["read packet: $p{0:x};thread:{1:x}#00".format(reg_index, thread),
+                     {"direction": "send", "regex": r"^\$([0-9a-fA-F]+)#", "capture": {1: "p_response"}},
+                     ], True)
+                context = self.expect_gdbremote_sequence()
+                self.assertIsNotNone(context)
+
+                # Set the next value to use for writing as the increment plus
+                # current value.
+                p_response = context.get("p_response")
+                self.assertIsNotNone(p_response)
+                next_value = lldbgdbserverutils.unpack_register_hex_unsigned(
+                    endian, p_response)
+
+            # Set new value using P and thread suffix.
+            self.reset_test_sequence()
+            self.test_sequence.add_log_lines(
+                [
+                    "read packet: $P{0:x}={1};thread:{2:x}#00".format(
+                        reg_index,
+                        lldbgdbserverutils.pack_register_hex(
+                            endian,
+                            next_value,
+                            byte_size=reg_byte_size),
+                        thread),
+                    "send packet: $OK#00",
+                ],
+                True)
+            context = self.expect_gdbremote_sequence()
+            self.assertIsNotNone(context)
+
+            # Save the value we set.
+            expected_reg_values.append(next_value)
+
+            # Increment value for next thread to use (we want them all
+            # different so we can verify they wrote to each thread correctly
+            # next.)
+            next_value += register_increment
+
+        # Revisit each thread and verify they have the expected value set for
+        # the register we wrote.
+        thread_index = 0
+        for thread in threads:
+            # Read pre-existing register value.
+            self.reset_test_sequence()
+            self.test_sequence.add_log_lines(
+                ["read packet: $p{0:x};thread:{1:x}#00".format(reg_index, thread),
+                 {"direction": "send", "regex": r"^\$([0-9a-fA-F]+)#", "capture": {1: "p_response"}},
+                 ], True)
+            context = self.expect_gdbremote_sequence()
+            self.assertIsNotNone(context)
+
+            # Get the register value.
+            p_response = context.get("p_response")
+            self.assertIsNotNone(p_response)
+            read_value = lldbgdbserverutils.unpack_register_hex_unsigned(
+                endian, p_response)
+
+            # Make sure we read back what we wrote.
+            self.assertEqual(read_value, expected_reg_values[thread_index])
+            thread_index += 1
+
+    # Note: as of this moment, a hefty number of the GPR writes are failing
+    # with E32 (everything except rax-rdx, rdi, rsi, rbp).
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_P_and_p_thread_suffix_work_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.P_and_p_thread_suffix_work()
+
+    @llgs_test
+    def test_P_and_p_thread_suffix_work_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.P_and_p_thread_suffix_work()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/commandline/TestStubReverseConnect.py

+from __future__ import print_function
+
+import gdbremote_testcase
+import lldbgdbserverutils
+import re
+import select
+import socket
+import time
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestStubReverseConnect(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    _DEFAULT_TIMEOUT = 20
+
+    def setUp(self):
+        # Set up the test.
+        gdbremote_testcase.GdbRemoteTestCaseBase.setUp(self)
+
+        # Create a listener on a local port.
+        self.listener_socket = self.create_listener_socket()
+        self.assertIsNotNone(self.listener_socket)
+        self.listener_port = self.listener_socket.getsockname()[1]
+
+    def create_listener_socket(self, timeout_seconds=_DEFAULT_TIMEOUT):
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.assertIsNotNone(sock)
+
+        sock.settimeout(timeout_seconds)
+        sock.bind(("127.0.0.1", 0))
+        sock.listen(1)
+
+        def tear_down_listener():
+            try:
+                sock.shutdown(socket.SHUT_RDWR)
+            except:
+                # ignore
+                None
+
+        self.addTearDownHook(tear_down_listener)
+        return sock
+
+    def reverse_connect_works(self):
+        # Indicate stub startup should do a reverse connect.
+        appended_stub_args = ["--reverse-connect"]
+        if self.debug_monitor_extra_args:
+            self.debug_monitor_extra_args += appended_stub_args
+        else:
+            self.debug_monitor_extra_args = appended_stub_args
+
+        self.stub_hostname = "127.0.0.1"
+        self.port = self.listener_port
+
+        triple = self.dbg.GetSelectedPlatform().GetTriple()
+        if re.match(".*-.*-.*-android", triple):
+            self.forward_adb_port(
+                self.port,
+                self.port,
+                "reverse",
+                self.stub_device)
+
+        # Start the stub.
+        server = self.launch_debug_monitor(logfile=sys.stdout)
+        self.assertIsNotNone(server)
+        self.assertTrue(
+            lldbgdbserverutils.process_is_running(
+                server.pid, True))
+
+        # Listen for the stub's connection to us.
+        (stub_socket, address) = self.listener_socket.accept()
+        self.assertIsNotNone(stub_socket)
+        self.assertIsNotNone(address)
+        print("connected to stub {} on {}".format(
+            address, stub_socket.getsockname()))
+
+        # Verify we can do the handshake.  If that works, we'll call it good.
+        self.do_handshake(stub_socket, timeout_seconds=self._DEFAULT_TIMEOUT)
+
+        # Clean up.
+        stub_socket.shutdown(socket.SHUT_RDWR)
+
+    @debugserver_test
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def test_reverse_connect_works_debugserver(self):
+        self.init_debugserver_test(use_named_pipe=False)
+        self.set_inferior_startup_launch()
+        self.reverse_connect_works()
+
+    @llgs_test
+    @skipIfRemote  # reverse connect is not a supported use case for now
+    def test_reverse_connect_works_llgs(self):
+        self.init_llgs_test(use_named_pipe=False)
+        self.set_inferior_startup_launch()
+        self.reverse_connect_works()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/commandline/TestStubSetSID.py

+from __future__ import print_function
+
+
+import gdbremote_testcase
+import lldbgdbserverutils
+import os
+import select
+import tempfile
+import time
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestStubSetSIDTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def get_stub_sid(self, extra_stub_args=None):
+        # Launch debugserver
+        if extra_stub_args:
+            self.debug_monitor_extra_args += extra_stub_args
+
+        server = self.launch_debug_monitor()
+        self.assertIsNotNone(server)
+        self.assertTrue(
+            lldbgdbserverutils.process_is_running(
+                server.pid, True))
+
+        # Get the process id for the stub.
+        return os.getsid(server.pid)
+
+    def sid_is_same_without_setsid(self):
+        stub_sid = self.get_stub_sid()
+        self.assertEqual(stub_sid, os.getsid(0))
+
+    def sid_is_different_with_setsid(self):
+        stub_sid = self.get_stub_sid(["--setsid"])
+        self.assertNotEqual(stub_sid, os.getsid(0))
+
+    def sid_is_different_with_S(self):
+        stub_sid = self.get_stub_sid(["-S"])
+        self.assertNotEqual(stub_sid, os.getsid(0))
+
+    @debugserver_test
+    @skipIfRemote  # --setsid not used on remote platform and currently it is also impossible to get the sid of lldb-platform running on a remote target
+    def test_sid_is_same_without_setsid_debugserver(self):
+        self.init_debugserver_test()
+        self.set_inferior_startup_launch()
+        self.sid_is_same_without_setsid()
+
+    @llgs_test
+    @skipIfRemote  # --setsid not used on remote platform and currently it is also impossible to get the sid of lldb-platform running on a remote target
+    @expectedFailureAll(oslist=['freebsd'])
+    def test_sid_is_same_without_setsid_llgs(self):
+        self.init_llgs_test()
+        self.set_inferior_startup_launch()
+        self.sid_is_same_without_setsid()
+
+    @debugserver_test
+    @skipIfRemote  # --setsid not used on remote platform and currently it is also impossible to get the sid of lldb-platform running on a remote target
+    def test_sid_is_different_with_setsid_debugserver(self):
+        self.init_debugserver_test()
+        self.set_inferior_startup_launch()
+        self.sid_is_different_with_setsid()
+
+    @llgs_test
+    @skipIfRemote  # --setsid not used on remote platform and currently it is also impossible to get the sid of lldb-platform running on a remote target
+    def test_sid_is_different_with_setsid_llgs(self):
+        self.init_llgs_test()
+        self.set_inferior_startup_launch()
+        self.sid_is_different_with_setsid()
+
+    @debugserver_test
+    @skipIfRemote  # --setsid not used on remote platform and currently it is also impossible to get the sid of lldb-platform running on a remote target
+    def test_sid_is_different_with_S_debugserver(self):
+        self.init_debugserver_test()
+        self.set_inferior_startup_launch()
+        self.sid_is_different_with_S()
+
+    @llgs_test
+    @skipIfRemote  # --setsid not used on remote platform and currently it is also impossible to get the sid of lldb-platform running on a remote target
+    def test_sid_is_different_with_S_llgs(self):
+        self.init_llgs_test()
+        self.set_inferior_startup_launch()
+        self.sid_is_different_with_S()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

+"""
+Base class for gdb-remote test cases.
+"""
+
+from __future__ import division, print_function
+
+
+import errno
+import os
+import os.path
+import platform
+import random
+import re
+import select
+import signal
+import socket
+import subprocess
+import sys
+import tempfile
+import time
+from lldbsuite.test import configuration
+from lldbsuite.test.lldbtest import *
+from lldbsuite.support import seven
+from lldbgdbserverutils import *
+import logging
+
+
+class _ConnectionRefused(IOError):
+    pass
+
+
+class GdbRemoteTestCaseBase(TestBase):
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    _TIMEOUT_SECONDS = 120
+
+    _GDBREMOTE_KILL_PACKET = "$k#6b"
+
+    # Start the inferior separately, attach to the inferior on the stub
+    # command line.
+    _STARTUP_ATTACH = "attach"
+    # Start the inferior separately, start the stub without attaching, allow
+    # the test to attach to the inferior however it wants (e.g. $vAttach;pid).
+    _STARTUP_ATTACH_MANUALLY = "attach_manually"
+    # Start the stub, and launch the inferior with an $A packet via the
+    # initial packet stream.
+    _STARTUP_LAUNCH = "launch"
+
+    # GDB Signal numbers that are not target-specific used for common
+    # exceptions
+    TARGET_EXC_BAD_ACCESS = 0x91
+    TARGET_EXC_BAD_INSTRUCTION = 0x92
+    TARGET_EXC_ARITHMETIC = 0x93
+    TARGET_EXC_EMULATION = 0x94
+    TARGET_EXC_SOFTWARE = 0x95
+    TARGET_EXC_BREAKPOINT = 0x96
+
+    _verbose_log_handler = None
+    _log_formatter = logging.Formatter(
+        fmt='%(asctime)-15s %(levelname)-8s %(message)s')
+
+    def setUpBaseLogging(self):
+        self.logger = logging.getLogger(__name__)
+
+        if len(self.logger.handlers) > 0:
+            return  # We have set up this handler already
+
+        self.logger.propagate = False
+        self.logger.setLevel(logging.DEBUG)
+
+        # log all warnings to stderr
+        handler = logging.StreamHandler()
+        handler.setLevel(logging.WARNING)
+        handler.setFormatter(self._log_formatter)
+        self.logger.addHandler(handler)
+
+    def isVerboseLoggingRequested(self):
+        # We will report our detailed logs if the user requested that the "gdb-remote" channel is
+        # logged.
+        return any(("gdb-remote" in channel)
+                   for channel in lldbtest_config.channels)
+
+    def setUp(self):
+        TestBase.setUp(self)
+
+        self.setUpBaseLogging()
+        self.debug_monitor_extra_args = []
+        self._pump_queues = socket_packet_pump.PumpQueues()
+
+        if self.isVerboseLoggingRequested():
+            # If requested, full logs go to a log file
+            self._verbose_log_handler = logging.FileHandler(
+                self.log_basename + "-host.log")
+            self._verbose_log_handler.setFormatter(self._log_formatter)
+            self._verbose_log_handler.setLevel(logging.DEBUG)
+            self.logger.addHandler(self._verbose_log_handler)
+
+        self.test_sequence = GdbRemoteTestSequence(self.logger)
+        self.set_inferior_startup_launch()
+        self.port = self.get_next_port()
+        self.named_pipe_path = None
+        self.named_pipe = None
+        self.named_pipe_fd = None
+        self.stub_sends_two_stop_notifications_on_kill = False
+        if configuration.lldb_platform_url:
+            if configuration.lldb_platform_url.startswith('unix-'):
+                url_pattern = '(.+)://\[?(.+?)\]?/.*'
+            else:
+                url_pattern = '(.+)://(.+):\d+'
+            scheme, host = re.match(
+                url_pattern, configuration.lldb_platform_url).groups()
+            if configuration.lldb_platform_name == 'remote-android' and host != 'localhost':
+                self.stub_device = host
+                self.stub_hostname = 'localhost'
+            else:
+                self.stub_device = None
+                self.stub_hostname = host
+        else:
+            self.stub_hostname = "localhost"
+
+    def tearDown(self):
+        self._pump_queues.verify_queues_empty()
+
+        self.logger.removeHandler(self._verbose_log_handler)
+        self._verbose_log_handler = None
+        TestBase.tearDown(self)
+
+    def getLocalServerLogFile(self):
+        return self.log_basename + "-server.log"
+
+    def setUpServerLogging(self, is_llgs):
+        if len(lldbtest_config.channels) == 0:
+            return  # No logging requested
+
+        if lldb.remote_platform:
+            log_file = lldbutil.join_remote_paths(
+                lldb.remote_platform.GetWorkingDirectory(), "server.log")
+        else:
+            log_file = self.getLocalServerLogFile()
+
+        if is_llgs:
+            self.debug_monitor_extra_args.append("--log-file=" + log_file)
+            self.debug_monitor_extra_args.append(
+                "--log-channels={}".format(":".join(lldbtest_config.channels)))
+        else:
+            self.debug_monitor_extra_args = [
+                "--log-file=" + log_file, "--log-flags=0x800000"]
+
+    def get_next_port(self):
+        return 12000 + random.randint(0, 3999)
+
+    def reset_test_sequence(self):
+        self.test_sequence = GdbRemoteTestSequence(self.logger)
+
+    def create_named_pipe(self):
+        # Create a temp dir and name for a pipe.
+        temp_dir = tempfile.mkdtemp()
+        named_pipe_path = os.path.join(temp_dir, "stub_port_number")
+
+        # Create the named pipe.
+        os.mkfifo(named_pipe_path)
+
+        # Open the read side of the pipe in non-blocking mode.  This will
+        # return right away, ready or not.
+        named_pipe_fd = os.open(named_pipe_path, os.O_RDONLY | os.O_NONBLOCK)
+
+        # Create the file for the named pipe.  Note this will follow semantics of
+        # a non-blocking read side of a named pipe, which has different semantics
+        # than a named pipe opened for read in non-blocking mode.
+        named_pipe = os.fdopen(named_pipe_fd, "r")
+        self.assertIsNotNone(named_pipe)
+
+        def shutdown_named_pipe():
+            # Close the pipe.
+            try:
+                named_pipe.close()
+            except:
+                print("failed to close named pipe")
+                None
+
+            # Delete the pipe.
+            try:
+                os.remove(named_pipe_path)
+            except:
+                print("failed to delete named pipe: {}".format(named_pipe_path))
+                None
+
+            # Delete the temp directory.
+            try:
+                os.rmdir(temp_dir)
+            except:
+                print(
+                    "failed to delete temp dir: {}, directory contents: '{}'".format(
+                        temp_dir, os.listdir(temp_dir)))
+                None
+
+        # Add the shutdown hook to clean up the named pipe.
+        self.addTearDownHook(shutdown_named_pipe)
+
+        # Clear the port so the stub selects a port number.
+        self.port = 0
+
+        return (named_pipe_path, named_pipe, named_pipe_fd)
+
+    def get_stub_port_from_named_socket(self, read_timeout_seconds=5):
+        # Wait for something to read with a max timeout.
+        (ready_readers, _, _) = select.select(
+            [self.named_pipe_fd], [], [], read_timeout_seconds)
+        self.assertIsNotNone(
+            ready_readers,
+            "write side of pipe has not written anything - stub isn't writing to pipe.")
+        self.assertNotEqual(
+            len(ready_readers),
+            0,
+            "write side of pipe has not written anything - stub isn't writing to pipe.")
+
+        # Read the port from the named pipe.
+        stub_port_raw = self.named_pipe.read()
+        self.assertIsNotNone(stub_port_raw)
+        self.assertNotEqual(
+            len(stub_port_raw),
+            0,
+            "no content to read on pipe")
+
+        # Trim null byte, convert to int.
+        stub_port_raw = stub_port_raw[:-1]
+        stub_port = int(stub_port_raw)
+        self.assertTrue(stub_port > 0)
+
+        return stub_port
+
+    def init_llgs_test(self, use_named_pipe=True):
+        if lldb.remote_platform:
+            # Remote platforms don't support named pipe based port negotiation
+            use_named_pipe = False
+
+            # Grab the ppid from /proc/[shell pid]/stat
+            err, retcode, shell_stat = self.run_platform_command(
+                "cat /proc/$$/stat")
+            self.assertTrue(
+                err.Success() and retcode == 0,
+                "Failed to read file /proc/$$/stat: %s, retcode: %d" %
+                (err.GetCString(),
+                 retcode))
+
+            # [pid] ([executable]) [state] [*ppid*]
+            pid = re.match(r"^\d+ \(.+\) . (\d+)", shell_stat).group(1)
+            err, retcode, ls_output = self.run_platform_command(
+                "ls -l /proc/%s/exe" % pid)
+            self.assertTrue(
+                err.Success() and retcode == 0,
+                "Failed to read file /proc/%s/exe: %s, retcode: %d" %
+                (pid,
+                 err.GetCString(),
+                 retcode))
+            exe = ls_output.split()[-1]
+
+            # If the binary has been deleted, the link name has " (deleted)" appended.
+            # Remove if it's there.
+            self.debug_monitor_exe = re.sub(r' \(deleted\)$', '', exe)
+        else:
+            self.debug_monitor_exe = get_lldb_server_exe()
+            if not self.debug_monitor_exe:
+                self.skipTest("lldb-server exe not found")
+
+        self.debug_monitor_extra_args = ["gdbserver"]
+        self.setUpServerLogging(is_llgs=True)
+
+        if use_named_pipe:
+            (self.named_pipe_path, self.named_pipe,
+             self.named_pipe_fd) = self.create_named_pipe()
+
+    def init_debugserver_test(self, use_named_pipe=True):
+        self.debug_monitor_exe = get_debugserver_exe()
+        if not self.debug_monitor_exe:
+            self.skipTest("debugserver exe not found")
+        self.setUpServerLogging(is_llgs=False)
+        if use_named_pipe:
+            (self.named_pipe_path, self.named_pipe,
+             self.named_pipe_fd) = self.create_named_pipe()
+        # The debugserver stub has a race on handling the 'k' command, so it sends an X09 right away, then sends the real X notification
+        # when the process truly dies.
+        self.stub_sends_two_stop_notifications_on_kill = True
+
+    def forward_adb_port(self, source, target, direction, device):
+        adb = ['adb'] + (['-s', device] if device else []) + [direction]
+
+        def remove_port_forward():
+            subprocess.call(adb + ["--remove", "tcp:%d" % source])
+
+        subprocess.call(adb + ["tcp:%d" % source, "tcp:%d" % target])
+        self.addTearDownHook(remove_port_forward)
+
+    def _verify_socket(self, sock):
+        # Normally, when the remote stub is not ready, we will get ECONNREFUSED during the
+        # connect() attempt. However, due to the way how ADB forwarding works, on android targets
+        # the connect() will always be successful, but the connection will be immediately dropped
+        # if ADB could not connect on the remote side. This function tries to detect this
+        # situation, and report it as "connection refused" so that the upper layers attempt the
+        # connection again.
+        triple = self.dbg.GetSelectedPlatform().GetTriple()
+        if not re.match(".*-.*-.*-android", triple):
+            return  # Not android.
+        can_read, _, _ = select.select([sock], [], [], 0.1)
+        if sock not in can_read:
+            return  # Data is not available, but the connection is alive.
+        if len(sock.recv(1, socket.MSG_PEEK)) == 0:
+            raise _ConnectionRefused()  # Got EOF, connection dropped.
+
+    def create_socket(self):
+        sock = socket.socket()
+        logger = self.logger
+
+        triple = self.dbg.GetSelectedPlatform().GetTriple()
+        if re.match(".*-.*-.*-android", triple):
+            self.forward_adb_port(
+                self.port,
+                self.port,
+                "forward",
+                self.stub_device)
+
+        logger.info(
+            "Connecting to debug monitor on %s:%d",
+            self.stub_hostname,
+            self.port)
+        connect_info = (self.stub_hostname, self.port)
+        try:
+            sock.connect(connect_info)
+        except socket.error as serr:
+            if serr.errno == errno.ECONNREFUSED:
+                raise _ConnectionRefused()
+            raise serr
+
+        def shutdown_socket():
+            if sock:
+                try:
+                    # send the kill packet so lldb-server shuts down gracefully
+                    sock.sendall(GdbRemoteTestCaseBase._GDBREMOTE_KILL_PACKET)
+                except:
+                    logger.warning(
+                        "failed to send kill packet to debug monitor: {}; ignoring".format(
+                            sys.exc_info()[0]))
+
+                try:
+                    sock.close()
+                except:
+                    logger.warning(
+                        "failed to close socket to debug monitor: {}; ignoring".format(
+                            sys.exc_info()[0]))
+
+        self.addTearDownHook(shutdown_socket)
+
+        self._verify_socket(sock)
+
+        return sock
+
+    def set_inferior_startup_launch(self):
+        self._inferior_startup = self._STARTUP_LAUNCH
+
+    def set_inferior_startup_attach(self):
+        self._inferior_startup = self._STARTUP_ATTACH
+
+    def set_inferior_startup_attach_manually(self):
+        self._inferior_startup = self._STARTUP_ATTACH_MANUALLY
+
+    def get_debug_monitor_command_line_args(self, attach_pid=None):
+        if lldb.remote_platform:
+            commandline_args = self.debug_monitor_extra_args + \
+                ["*:{}".format(self.port)]
+        else:
+            commandline_args = self.debug_monitor_extra_args + \
+                ["127.0.0.1:{}".format(self.port)]
+
+        if attach_pid:
+            commandline_args += ["--attach=%d" % attach_pid]
+        if self.named_pipe_path:
+            commandline_args += ["--named-pipe", self.named_pipe_path]
+        return commandline_args
+
+    def get_target_byte_order(self):
+        inferior_exe_path = self.getBuildArtifact("a.out")
+        target = self.dbg.CreateTarget(inferior_exe_path)
+        return target.GetByteOrder()
+
+    def launch_debug_monitor(self, attach_pid=None, logfile=None):
+        # Create the command line.
+        commandline_args = self.get_debug_monitor_command_line_args(
+            attach_pid=attach_pid)
+
+        # Start the server.
+        server = self.spawnSubprocess(
+            self.debug_monitor_exe,
+            commandline_args,
+            install_remote=False)
+        self.addTearDownHook(self.cleanupSubprocesses)
+        self.assertIsNotNone(server)
+
+        # If we're receiving the stub's listening port from the named pipe, do
+        # that here.
+        if self.named_pipe:
+            self.port = self.get_stub_port_from_named_socket()
+
+        return server
+
+    def connect_to_debug_monitor(self, attach_pid=None):
+        if self.named_pipe:
+            # Create the stub.
+            server = self.launch_debug_monitor(attach_pid=attach_pid)
+            self.assertIsNotNone(server)
+
+            def shutdown_debug_monitor():
+                try:
+                    server.terminate()
+                except:
+                    logger.warning(
+                        "failed to terminate server for debug monitor: {}; ignoring".format(
+                            sys.exc_info()[0]))
+            self.addTearDownHook(shutdown_debug_monitor)
+
+            # Schedule debug monitor to be shut down during teardown.
+            logger = self.logger
+
+            # Attach to the stub and return a socket opened to it.
+            self.sock = self.create_socket()
+            return server
+
+        # We're using a random port algorithm to try not to collide with other ports,
+        # and retry a max # times.
+        attempts = 0
+        MAX_ATTEMPTS = 20
+
+        while attempts < MAX_ATTEMPTS:
+            server = self.launch_debug_monitor(attach_pid=attach_pid)
+
+            # Schedule debug monitor to be shut down during teardown.
+            logger = self.logger
+
+            def shutdown_debug_monitor():
+                try:
+                    server.terminate()
+                except:
+                    logger.warning(
+                        "failed to terminate server for debug monitor: {}; ignoring".format(
+                            sys.exc_info()[0]))
+            self.addTearDownHook(shutdown_debug_monitor)
+
+            connect_attemps = 0
+            MAX_CONNECT_ATTEMPTS = 10
+
+            while connect_attemps < MAX_CONNECT_ATTEMPTS:
+                # Create a socket to talk to the server
+                try:
+                    logger.info("Connect attempt %d", connect_attemps + 1)
+                    self.sock = self.create_socket()
+                    return server
+                except _ConnectionRefused as serr:
+                    # Ignore, and try again.
+                    pass
+                time.sleep(0.5)
+                connect_attemps += 1
+
+            # We should close the server here to be safe.
+            server.terminate()
+
+            # Increment attempts.
+            print(
+                "connect to debug monitor on port %d failed, attempt #%d of %d" %
+                (self.port, attempts + 1, MAX_ATTEMPTS))
+            attempts += 1
+
+            # And wait a random length of time before next attempt, to avoid
+            # collisions.
+            time.sleep(random.randint(1, 5))
+
+            # Now grab a new port number.
+            self.port = self.get_next_port()
+
+        raise Exception(
+            "failed to create a socket to the launched debug monitor after %d tries" %
+            attempts)
+
+    def launch_process_for_attach(
+            self,
+            inferior_args=None,
+            sleep_seconds=3,
+            exe_path=None):
+        # We're going to start a child process that the debug monitor stub can later attach to.
+        # This process needs to be started so that it just hangs around for a while.  We'll
+        # have it sleep.
+        if not exe_path:
+            exe_path = self.getBuildArtifact("a.out")
+
+        args = []
+        if inferior_args:
+            args.extend(inferior_args)
+        if sleep_seconds:
+            args.append("sleep:%d" % sleep_seconds)
+
+        inferior = self.spawnSubprocess(exe_path, args)
+
+        def shutdown_process_for_attach():
+            try:
+                inferior.terminate()
+            except:
+                logger.warning(
+                    "failed to terminate inferior process for attach: {}; ignoring".format(
+                        sys.exc_info()[0]))
+        self.addTearDownHook(shutdown_process_for_attach)
+        return inferior
+
+    def prep_debug_monitor_and_inferior(
+            self,
+            inferior_args=None,
+            inferior_sleep_seconds=3,
+            inferior_exe_path=None):
+        """Prep the debug monitor, the inferior, and the expected packet stream.
+
+        Handle the separate cases of using the debug monitor in attach-to-inferior mode
+        and in launch-inferior mode.
+
+        For attach-to-inferior mode, the inferior process is first started, then
+        the debug monitor is started in attach to pid mode (using --attach on the
+        stub command line), and the no-ack-mode setup is appended to the packet
+        stream.  The packet stream is not yet executed, ready to have more expected
+        packet entries added to it.
+
+        For launch-inferior mode, the stub is first started, then no ack mode is
+        setup on the expected packet stream, then the verified launch packets are added
+        to the expected socket stream.  The packet stream is not yet executed, ready
+        to have more expected packet entries added to it.
+
+        The return value is:
+        {inferior:<inferior>, server:<server>}
+        """
+        inferior = None
+        attach_pid = None
+
+        if self._inferior_startup == self._STARTUP_ATTACH or self._inferior_startup == self._STARTUP_ATTACH_MANUALLY:
+            # Launch the process that we'll use as the inferior.
+            inferior = self.launch_process_for_attach(
+                inferior_args=inferior_args,
+                sleep_seconds=inferior_sleep_seconds,
+                exe_path=inferior_exe_path)
+            self.assertIsNotNone(inferior)
+            self.assertTrue(inferior.pid > 0)
+            if self._inferior_startup == self._STARTUP_ATTACH:
+                # In this case, we want the stub to attach via the command
+                # line, so set the command line attach pid here.
+                attach_pid = inferior.pid
+
+        if self._inferior_startup == self._STARTUP_LAUNCH:
+            # Build launch args
+            if not inferior_exe_path:
+                inferior_exe_path = self.getBuildArtifact("a.out")
+
+            if lldb.remote_platform:
+                remote_path = lldbutil.append_to_process_working_directory(self,
+                    os.path.basename(inferior_exe_path))
+                remote_file_spec = lldb.SBFileSpec(remote_path, False)
+                err = lldb.remote_platform.Install(lldb.SBFileSpec(
+                    inferior_exe_path, True), remote_file_spec)
+                if err.Fail():
+                    raise Exception(
+                        "remote_platform.Install('%s', '%s') failed: %s" %
+                        (inferior_exe_path, remote_path, err))
+                inferior_exe_path = remote_path
+
+            launch_args = [inferior_exe_path]
+            if inferior_args:
+                launch_args.extend(inferior_args)
+
+        # Launch the debug monitor stub, attaching to the inferior.
+        server = self.connect_to_debug_monitor(attach_pid=attach_pid)
+        self.assertIsNotNone(server)
+
+        # Build the expected protocol stream
+        self.add_no_ack_remote_stream()
+        if self._inferior_startup == self._STARTUP_LAUNCH:
+            self.add_verified_launch_packets(launch_args)
+
+        return {"inferior": inferior, "server": server}
+
+    def expect_socket_recv(
+            self,
+            sock,
+            expected_content_regex,
+            timeout_seconds):
+        response = ""
+        timeout_time = time.time() + timeout_seconds
+
+        while not expected_content_regex.match(
+                response) and time.time() < timeout_time:
+            can_read, _, _ = select.select([sock], [], [], timeout_seconds)
+            if can_read and sock in can_read:
+                recv_bytes = sock.recv(4096)
+                if recv_bytes:
+                    response += seven.bitcast_to_string(recv_bytes)
+
+        self.assertTrue(expected_content_regex.match(response))
+
+    def expect_socket_send(self, sock, content, timeout_seconds):
+        request_bytes_remaining = content
+        timeout_time = time.time() + timeout_seconds
+
+        while len(request_bytes_remaining) > 0 and time.time() < timeout_time:
+            _, can_write, _ = select.select([], [sock], [], timeout_seconds)
+            if can_write and sock in can_write:
+                written_byte_count = sock.send(request_bytes_remaining.encode())
+                request_bytes_remaining = request_bytes_remaining[
+                    written_byte_count:]
+        self.assertEqual(len(request_bytes_remaining), 0)
+
+    def do_handshake(self, stub_socket, timeout_seconds=5):
+        # Write the ack.
+        self.expect_socket_send(stub_socket, "+", timeout_seconds)
+
+        # Send the start no ack mode packet.
+        NO_ACK_MODE_REQUEST = "$QStartNoAckMode#b0"
+        bytes_sent = stub_socket.send(NO_ACK_MODE_REQUEST.encode())
+        self.assertEqual(bytes_sent, len(NO_ACK_MODE_REQUEST))
+
+        # Receive the ack and "OK"
+        self.expect_socket_recv(stub_socket, re.compile(
+            r"^\+\$OK#[0-9a-fA-F]{2}$"), timeout_seconds)
+
+        # Send the final ack.
+        self.expect_socket_send(stub_socket, "+", timeout_seconds)
+
+    def add_no_ack_remote_stream(self):
+        self.test_sequence.add_log_lines(
+            ["read packet: +",
+             "read packet: $QStartNoAckMode#b0",
+             "send packet: +",
+             "send packet: $OK#9a",
+             "read packet: +"],
+            True)
+
+    def add_verified_launch_packets(self, launch_args):
+        self.test_sequence.add_log_lines(
+            ["read packet: %s" % build_gdbremote_A_packet(launch_args),
+             "send packet: $OK#00",
+             "read packet: $qLaunchSuccess#a5",
+             "send packet: $OK#00"],
+            True)
+
+    def add_thread_suffix_request_packets(self):
+        self.test_sequence.add_log_lines(
+            ["read packet: $QThreadSuffixSupported#e4",
+             "send packet: $OK#00",
+             ], True)
+
+    def add_process_info_collection_packets(self):
+        self.test_sequence.add_log_lines(
+            ["read packet: $qProcessInfo#dc",
+             {"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$", "capture": {1: "process_info_raw"}}],
+            True)
+
+    _KNOWN_PROCESS_INFO_KEYS = [
+        "pid",
+        "parent-pid",
+        "real-uid",
+        "real-gid",
+        "effective-uid",
+        "effective-gid",
+        "cputype",
+        "cpusubtype",
+        "ostype",
+        "triple",
+        "vendor",
+        "endian",
+        "elf_abi",
+        "ptrsize"
+    ]
+
+    def parse_process_info_response(self, context):
+        # Ensure we have a process info response.
+        self.assertIsNotNone(context)
+        process_info_raw = context.get("process_info_raw")
+        self.assertIsNotNone(process_info_raw)
+
+        # Pull out key:value; pairs.
+        process_info_dict = {
+            match.group(1): match.group(2) for match in re.finditer(
+                r"([^:]+):([^;]+);", process_info_raw)}
+
+        # Validate keys are known.
+        for (key, val) in list(process_info_dict.items()):
+            self.assertTrue(key in self._KNOWN_PROCESS_INFO_KEYS)
+            self.assertIsNotNone(val)
+
+        return process_info_dict
+
+    def add_register_info_collection_packets(self):
+        self.test_sequence.add_log_lines(
+            [{"type": "multi_response", "query": "qRegisterInfo", "append_iteration_suffix": True,
+                "end_regex": re.compile(r"^\$(E\d+)?#[0-9a-fA-F]{2}$"),
+                "save_key": "reg_info_responses"}],
+            True)
+
+    def parse_register_info_packets(self, context):
+        """Return an array of register info dictionaries, one per register info."""
+        reg_info_responses = context.get("reg_info_responses")
+        self.assertIsNotNone(reg_info_responses)
+
+        # Parse register infos.
+        return [parse_reg_info_response(reg_info_response)
+                for reg_info_response in reg_info_responses]
+
+    def expect_gdbremote_sequence(self, timeout_seconds=None):
+        if not timeout_seconds:
+            timeout_seconds = self._TIMEOUT_SECONDS
+        return expect_lldb_gdbserver_replay(
+            self,
+            self.sock,
+            self.test_sequence,
+            self._pump_queues,
+            timeout_seconds,
+            self.logger)
+
+    _KNOWN_REGINFO_KEYS = [
+        "name",
+        "alt-name",
+        "bitsize",
+        "offset",
+        "encoding",
+        "format",
+        "set",
+        "gcc",
+        "ehframe",
+        "dwarf",
+        "generic",
+        "container-regs",
+        "invalidate-regs",
+        "dynamic_size_dwarf_expr_bytes",
+        "dynamic_size_dwarf_len"
+    ]
+
+    def assert_valid_reg_info(self, reg_info):
+        # Assert we know about all the reginfo keys parsed.
+        for key in reg_info:
+            self.assertTrue(key in self._KNOWN_REGINFO_KEYS)
+
+        # Check the bare-minimum expected set of register info keys.
+        self.assertTrue("name" in reg_info)
+        self.assertTrue("bitsize" in reg_info)
+        self.assertTrue("offset" in reg_info)
+        self.assertTrue("encoding" in reg_info)
+        self.assertTrue("format" in reg_info)
+
+    def find_pc_reg_info(self, reg_infos):
+        lldb_reg_index = 0
+        for reg_info in reg_infos:
+            if ("generic" in reg_info) and (reg_info["generic"] == "pc"):
+                return (lldb_reg_index, reg_info)
+            lldb_reg_index += 1
+
+        return (None, None)
+
+    def add_lldb_register_index(self, reg_infos):
+        """Add a "lldb_register_index" key containing the 0-baed index of each reg_infos entry.
+
+        We'll use this when we want to call packets like P/p with a register index but do so
+        on only a subset of the full register info set.
+        """
+        self.assertIsNotNone(reg_infos)
+
+        reg_index = 0
+        for reg_info in reg_infos:
+            reg_info["lldb_register_index"] = reg_index
+            reg_index += 1
+
+    def add_query_memory_region_packets(self, address):
+        self.test_sequence.add_log_lines(
+            ["read packet: $qMemoryRegionInfo:{0:x}#00".format(address),
+             {"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$", "capture": {1: "memory_region_response"}}],
+            True)
+
+    def parse_key_val_dict(self, key_val_text, allow_dupes=True):
+        self.assertIsNotNone(key_val_text)
+        kv_dict = {}
+        for match in re.finditer(r";?([^:]+):([^;]+)", key_val_text):
+            key = match.group(1)
+            val = match.group(2)
+            if key in kv_dict:
+                if allow_dupes:
+                    if isinstance(kv_dict[key], list):
+                        kv_dict[key].append(val)
+                    else:
+                        # Promote to list
+                        kv_dict[key] = [kv_dict[key], val]
+                else:
+                    self.fail(
+                        "key '{}' already present when attempting to add value '{}' (text='{}', dict={})".format(
+                            key, val, key_val_text, kv_dict))
+            else:
+                kv_dict[key] = val
+        return kv_dict
+
+    def parse_memory_region_packet(self, context):
+        # Ensure we have a context.
+        self.assertIsNotNone(context.get("memory_region_response"))
+
+        # Pull out key:value; pairs.
+        mem_region_dict = self.parse_key_val_dict(
+            context.get("memory_region_response"))
+
+        # Validate keys are known.
+        for (key, val) in list(mem_region_dict.items()):
+            self.assertTrue(
+                key in [
+                    "start",
+                    "size",
+                    "permissions",
+                    "name",
+                    "error"])
+            self.assertIsNotNone(val)
+
+        # Return the dictionary of key-value pairs for the memory region.
+        return mem_region_dict
+
+    def assert_address_within_memory_region(
+            self, test_address, mem_region_dict):
+        self.assertIsNotNone(mem_region_dict)
+        self.assertTrue("start" in mem_region_dict)
+        self.assertTrue("size" in mem_region_dict)
+
+        range_start = int(mem_region_dict["start"], 16)
+        range_size = int(mem_region_dict["size"], 16)
+        range_end = range_start + range_size
+
+        if test_address < range_start:
+            self.fail(
+                "address 0x{0:x} comes before range 0x{1:x} - 0x{2:x} (size 0x{3:x})".format(
+                    test_address,
+                    range_start,
+                    range_end,
+                    range_size))
+        elif test_address >= range_end:
+            self.fail(
+                "address 0x{0:x} comes after range 0x{1:x} - 0x{2:x} (size 0x{3:x})".format(
+                    test_address,
+                    range_start,
+                    range_end,
+                    range_size))
+
+    def add_threadinfo_collection_packets(self):
+        self.test_sequence.add_log_lines(
+            [{"type": "multi_response", "first_query": "qfThreadInfo", "next_query": "qsThreadInfo",
+                "append_iteration_suffix": False, "end_regex": re.compile(r"^\$(l)?#[0-9a-fA-F]{2}$"),
+                "save_key": "threadinfo_responses"}],
+            True)
+
+    def parse_threadinfo_packets(self, context):
+        """Return an array of thread ids (decimal ints), one per thread."""
+        threadinfo_responses = context.get("threadinfo_responses")
+        self.assertIsNotNone(threadinfo_responses)
+
+        thread_ids = []
+        for threadinfo_response in threadinfo_responses:
+            new_thread_infos = parse_threadinfo_response(threadinfo_response)
+            thread_ids.extend(new_thread_infos)
+        return thread_ids
+
+    def wait_for_thread_count(self, thread_count, timeout_seconds=3):
+        start_time = time.time()
+        timeout_time = start_time + timeout_seconds
+
+        actual_thread_count = 0
+        while actual_thread_count < thread_count:
+            self.reset_test_sequence()
+            self.add_threadinfo_collection_packets()
+
+            context = self.expect_gdbremote_sequence()
+            self.assertIsNotNone(context)
+
+            threads = self.parse_threadinfo_packets(context)
+            self.assertIsNotNone(threads)
+
+            actual_thread_count = len(threads)
+
+            if time.time() > timeout_time:
+                raise Exception(
+                    'timed out after {} seconds while waiting for theads: waiting for at least {} threads, found {}'.format(
+                        timeout_seconds, thread_count, actual_thread_count))
+
+        return threads
+
+    def add_set_breakpoint_packets(
+            self,
+            address,
+            z_packet_type=0,
+            do_continue=True,
+            breakpoint_kind=1):
+        self.test_sequence.add_log_lines(
+            [  # Set the breakpoint.
+                "read packet: $Z{2},{0:x},{1}#00".format(
+                    address, breakpoint_kind, z_packet_type),
+                # Verify the stub could set it.
+                "send packet: $OK#00",
+            ], True)
+
+        if (do_continue):
+            self.test_sequence.add_log_lines(
+                [  # Continue the inferior.
+                    "read packet: $c#63",
+                    # Expect a breakpoint stop report.
+                    {"direction": "send",
+                     "regex": r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);",
+                     "capture": {1: "stop_signo",
+                                 2: "stop_thread_id"}},
+                ], True)
+
+    def add_remove_breakpoint_packets(
+            self,
+            address,
+            z_packet_type=0,
+            breakpoint_kind=1):
+        self.test_sequence.add_log_lines(
+            [  # Remove the breakpoint.
+                "read packet: $z{2},{0:x},{1}#00".format(
+                    address, breakpoint_kind, z_packet_type),
+                # Verify the stub could unset it.
+                "send packet: $OK#00",
+            ], True)
+
+    def add_qSupported_packets(self):
+        self.test_sequence.add_log_lines(
+            ["read packet: $qSupported#00",
+             {"direction": "send", "regex": r"^\$(.*)#[0-9a-fA-F]{2}", "capture": {1: "qSupported_response"}},
+             ], True)
+
+    _KNOWN_QSUPPORTED_STUB_FEATURES = [
+        "augmented-libraries-svr4-read",
+        "PacketSize",
+        "QStartNoAckMode",
+        "QThreadSuffixSupported",
+        "QListThreadsInStopReply",
+        "qXfer:auxv:read",
+        "qXfer:libraries:read",
+        "qXfer:libraries-svr4:read",
+        "qXfer:features:read",
+        "qEcho",
+        "QPassSignals"
+    ]
+
+    def parse_qSupported_response(self, context):
+        self.assertIsNotNone(context)
+
+        raw_response = context.get("qSupported_response")
+        self.assertIsNotNone(raw_response)
+
+        # For values with key=val, the dict key and vals are set as expected.  For feature+, feature- and feature?, the
+        # +,-,? is stripped from the key and set as the value.
+        supported_dict = {}
+        for match in re.finditer(r";?([^=;]+)(=([^;]+))?", raw_response):
+            key = match.group(1)
+            val = match.group(3)
+
+            # key=val: store as is
+            if val and len(val) > 0:
+                supported_dict[key] = val
+            else:
+                if len(key) < 2:
+                    raise Exception(
+                        "singular stub feature is too short: must be stub_feature{+,-,?}")
+                supported_type = key[-1]
+                key = key[:-1]
+                if not supported_type in ["+", "-", "?"]:
+                    raise Exception(
+                        "malformed stub feature: final character {} not in expected set (+,-,?)".format(supported_type))
+                supported_dict[key] = supported_type
+            # Ensure we know the supported element
+            if key not in self._KNOWN_QSUPPORTED_STUB_FEATURES:
+                raise Exception(
+                    "unknown qSupported stub feature reported: %s" %
+                    key)
+
+        return supported_dict
+
+    def run_process_then_stop(self, run_seconds=1):
+        # Tell the stub to continue.
+        self.test_sequence.add_log_lines(
+            ["read packet: $vCont;c#a8"],
+            True)
+        context = self.expect_gdbremote_sequence()
+
+        # Wait for run_seconds.
+        time.sleep(run_seconds)
+
+        # Send an interrupt, capture a T response.
+        self.reset_test_sequence()
+        self.test_sequence.add_log_lines(
+            ["read packet: {}".format(chr(3)),
+             {"direction": "send", "regex": r"^\$T([0-9a-fA-F]+)([^#]+)#[0-9a-fA-F]{2}$", "capture": {1: "stop_result"}}],
+            True)
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+        self.assertIsNotNone(context.get("stop_result"))
+
+        return context
+
+    def select_modifiable_register(self, reg_infos):
+        """Find a register that can be read/written freely."""
+        PREFERRED_REGISTER_NAMES = set(["rax", ])
+
+        # First check for the first register from the preferred register name
+        # set.
+        alternative_register_index = None
+
+        self.assertIsNotNone(reg_infos)
+        for reg_info in reg_infos:
+            if ("name" in reg_info) and (
+                    reg_info["name"] in PREFERRED_REGISTER_NAMES):
+                # We found a preferred register.  Use it.
+                return reg_info["lldb_register_index"]
+            if ("generic" in reg_info) and (reg_info["generic"] == "fp" or
+                    reg_info["generic"] == "arg1"):
+                # A frame pointer or first arg register will do as a
+                # register to modify temporarily.
+                alternative_register_index = reg_info["lldb_register_index"]
+
+        # We didn't find a preferred register.  Return whatever alternative register
+        # we found, if any.
+        return alternative_register_index
+
+    def extract_registers_from_stop_notification(self, stop_key_vals_text):
+        self.assertIsNotNone(stop_key_vals_text)
+        kv_dict = self.parse_key_val_dict(stop_key_vals_text)
+
+        registers = {}
+        for (key, val) in list(kv_dict.items()):
+            if re.match(r"^[0-9a-fA-F]+$", key):
+                registers[int(key, 16)] = val
+        return registers
+
+    def gather_register_infos(self):
+        self.reset_test_sequence()
+        self.add_register_info_collection_packets()
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        reg_infos = self.parse_register_info_packets(context)
+        self.assertIsNotNone(reg_infos)
+        self.add_lldb_register_index(reg_infos)
+
+        return reg_infos
+
+    def find_generic_register_with_name(self, reg_infos, generic_name):
+        self.assertIsNotNone(reg_infos)
+        for reg_info in reg_infos:
+            if ("generic" in reg_info) and (
+                    reg_info["generic"] == generic_name):
+                return reg_info
+        return None
+
+    def decode_gdbremote_binary(self, encoded_bytes):
+        decoded_bytes = ""
+        i = 0
+        while i < len(encoded_bytes):
+            if encoded_bytes[i] == "}":
+                # Handle escaped char.
+                self.assertTrue(i + 1 < len(encoded_bytes))
+                decoded_bytes += chr(ord(encoded_bytes[i + 1]) ^ 0x20)
+                i += 2
+            elif encoded_bytes[i] == "*":
+                # Handle run length encoding.
+                self.assertTrue(len(decoded_bytes) > 0)
+                self.assertTrue(i + 1 < len(encoded_bytes))
+                repeat_count = ord(encoded_bytes[i + 1]) - 29
+                decoded_bytes += decoded_bytes[-1] * repeat_count
+                i += 2
+            else:
+                decoded_bytes += encoded_bytes[i]
+                i += 1
+        return decoded_bytes
+
+    def build_auxv_dict(self, endian, word_size, auxv_data):
+        self.assertIsNotNone(endian)
+        self.assertIsNotNone(word_size)
+        self.assertIsNotNone(auxv_data)
+
+        auxv_dict = {}
+
+        # PowerPC64le's auxvec has a special key that must be ignored.
+        # This special key may be used multiple times, resulting in
+        # multiple key/value pairs with the same key, which would otherwise
+        # break this test check for repeated keys.
+        #
+        # AT_IGNOREPPC = 22
+        ignored_keys_for_arch = { 'powerpc64le' : [22] }
+        arch = self.getArchitecture()
+        ignore_keys = None
+        if arch in ignored_keys_for_arch:
+            ignore_keys = ignored_keys_for_arch[arch]
+
+        while len(auxv_data) > 0:
+            # Chop off key.
+            raw_key = auxv_data[:word_size]
+            auxv_data = auxv_data[word_size:]
+
+            # Chop of value.
+            raw_value = auxv_data[:word_size]
+            auxv_data = auxv_data[word_size:]
+
+            # Convert raw text from target endian.
+            key = unpack_endian_binary_string(endian, raw_key)
+            value = unpack_endian_binary_string(endian, raw_value)
+
+            if ignore_keys and key in ignore_keys:
+                continue
+
+            # Handle ending entry.
+            if key == 0:
+                self.assertEqual(value, 0)
+                return auxv_dict
+
+            # The key should not already be present.
+            self.assertFalse(key in auxv_dict)
+            auxv_dict[key] = value
+
+        self.fail(
+            "should not reach here - implies required double zero entry not found")
+        return auxv_dict
+
+    def read_binary_data_in_chunks(self, command_prefix, chunk_length):
+        """Collect command_prefix{offset:x},{chunk_length:x} until a single 'l' or 'l' with data is returned."""
+        offset = 0
+        done = False
+        decoded_data = ""
+
+        while not done:
+            # Grab the next iteration of data.
+            self.reset_test_sequence()
+            self.test_sequence.add_log_lines(
+                [
+                    "read packet: ${}{:x},{:x}:#00".format(
+                        command_prefix,
+                        offset,
+                        chunk_length),
+                    {
+                        "direction": "send",
+                        "regex": re.compile(
+                            r"^\$([^E])(.*)#[0-9a-fA-F]{2}$",
+                            re.MULTILINE | re.DOTALL),
+                        "capture": {
+                            1: "response_type",
+                            2: "content_raw"}}],
+                True)
+
+            context = self.expect_gdbremote_sequence()
+            self.assertIsNotNone(context)
+
+            response_type = context.get("response_type")
+            self.assertIsNotNone(response_type)
+            self.assertTrue(response_type in ["l", "m"])
+
+            # Move offset along.
+            offset += chunk_length
+
+            # Figure out if we're done.  We're done if the response type is l.
+            done = response_type == "l"
+
+            # Decode binary data.
+            content_raw = context.get("content_raw")
+            if content_raw and len(content_raw) > 0:
+                self.assertIsNotNone(content_raw)
+                decoded_data += self.decode_gdbremote_binary(content_raw)
+        return decoded_data
+
+    def add_interrupt_packets(self):
+        self.test_sequence.add_log_lines([
+            # Send the intterupt.
+            "read packet: {}".format(chr(3)),
+            # And wait for the stop notification.
+            {"direction": "send",
+             "regex": r"^\$T([0-9a-fA-F]{2})(.*)#[0-9a-fA-F]{2}$",
+             "capture": {1: "stop_signo",
+                         2: "stop_key_val_text"}},
+        ], True)
+
+    def parse_interrupt_packets(self, context):
+        self.assertIsNotNone(context.get("stop_signo"))
+        self.assertIsNotNone(context.get("stop_key_val_text"))
+        return (int(context["stop_signo"], 16), self.parse_key_val_dict(
+            context["stop_key_val_text"]))
+
+    def add_QSaveRegisterState_packets(self, thread_id):
+        if thread_id:
+            # Use the thread suffix form.
+            request = "read packet: $QSaveRegisterState;thread:{:x}#00".format(
+                thread_id)
+        else:
+            request = "read packet: $QSaveRegisterState#00"
+
+        self.test_sequence.add_log_lines([request,
+                                          {"direction": "send",
+                                           "regex": r"^\$(E?.*)#[0-9a-fA-F]{2}$",
+                                           "capture": {1: "save_response"}},
+                                          ],
+                                         True)
+
+    def parse_QSaveRegisterState_response(self, context):
+        self.assertIsNotNone(context)
+
+        save_response = context.get("save_response")
+        self.assertIsNotNone(save_response)
+
+        if len(save_response) < 1 or save_response[0] == "E":
+            # error received
+            return (False, None)
+        else:
+            return (True, int(save_response))
+
+    def add_QRestoreRegisterState_packets(self, save_id, thread_id=None):
+        if thread_id:
+            # Use the thread suffix form.
+            request = "read packet: $QRestoreRegisterState:{};thread:{:x}#00".format(
+                save_id, thread_id)
+        else:
+            request = "read packet: $QRestoreRegisterState:{}#00".format(
+                save_id)
+
+        self.test_sequence.add_log_lines([
+            request,
+            "send packet: $OK#00"
+        ], True)
+
+    def flip_all_bits_in_each_register_value(
+            self, reg_infos, endian, thread_id=None):
+        self.assertIsNotNone(reg_infos)
+
+        successful_writes = 0
+        failed_writes = 0
+
+        for reg_info in reg_infos:
+            # Use the lldb register index added to the reg info.  We're not necessarily
+            # working off a full set of register infos, so an inferred register
+            # index could be wrong.
+            reg_index = reg_info["lldb_register_index"]
+            self.assertIsNotNone(reg_index)
+
+            reg_byte_size = int(reg_info["bitsize"]) // 8
+            self.assertTrue(reg_byte_size > 0)
+
+            # Handle thread suffix.
+            if thread_id:
+                p_request = "read packet: $p{:x};thread:{:x}#00".format(
+                    reg_index, thread_id)
+            else:
+                p_request = "read packet: $p{:x}#00".format(reg_index)
+
+            # Read the existing value.
+            self.reset_test_sequence()
+            self.test_sequence.add_log_lines([
+                p_request,
+                {"direction": "send", "regex": r"^\$([0-9a-fA-F]+)#", "capture": {1: "p_response"}},
+            ], True)
+            context = self.expect_gdbremote_sequence()
+            self.assertIsNotNone(context)
+
+            # Verify the response length.
+            p_response = context.get("p_response")
+            self.assertIsNotNone(p_response)
+            initial_reg_value = unpack_register_hex_unsigned(
+                endian, p_response)
+
+            # Flip the value by xoring with all 1s
+            all_one_bits_raw = "ff" * (int(reg_info["bitsize"]) // 8)
+            flipped_bits_int = initial_reg_value ^ int(all_one_bits_raw, 16)
+            # print("reg (index={}, name={}): val={}, flipped bits (int={}, hex={:x})".format(reg_index, reg_info["name"], initial_reg_value, flipped_bits_int, flipped_bits_int))
+
+            # Handle thread suffix for P.
+            if thread_id:
+                P_request = "read packet: $P{:x}={};thread:{:x}#00".format(
+                    reg_index, pack_register_hex(
+                        endian, flipped_bits_int, byte_size=reg_byte_size), thread_id)
+            else:
+                P_request = "read packet: $P{:x}={}#00".format(
+                    reg_index, pack_register_hex(
+                        endian, flipped_bits_int, byte_size=reg_byte_size))
+
+            # Write the flipped value to the register.
+            self.reset_test_sequence()
+            self.test_sequence.add_log_lines([P_request,
+                                              {"direction": "send",
+                                               "regex": r"^\$(OK|E[0-9a-fA-F]+)#[0-9a-fA-F]{2}",
+                                               "capture": {1: "P_response"}},
+                                              ],
+                                             True)
+            context = self.expect_gdbremote_sequence()
+            self.assertIsNotNone(context)
+
+            # Determine if the write succeeded.  There are a handful of registers that can fail, or partially fail
+            # (e.g. flags, segment selectors, etc.) due to register value restrictions.  Don't worry about them
+            # all flipping perfectly.
+            P_response = context.get("P_response")
+            self.assertIsNotNone(P_response)
+            if P_response == "OK":
+                successful_writes += 1
+            else:
+                failed_writes += 1
+                # print("reg (index={}, name={}) write FAILED (error: {})".format(reg_index, reg_info["name"], P_response))
+
+            # Read back the register value, ensure it matches the flipped
+            # value.
+            if P_response == "OK":
+                self.reset_test_sequence()
+                self.test_sequence.add_log_lines([
+                    p_request,
+                    {"direction": "send", "regex": r"^\$([0-9a-fA-F]+)#", "capture": {1: "p_response"}},
+                ], True)
+                context = self.expect_gdbremote_sequence()
+                self.assertIsNotNone(context)
+
+                verify_p_response_raw = context.get("p_response")
+                self.assertIsNotNone(verify_p_response_raw)
+                verify_bits = unpack_register_hex_unsigned(
+                    endian, verify_p_response_raw)
+
+                if verify_bits != flipped_bits_int:
+                    # Some registers, like mxcsrmask and others, will permute what's written.  Adjust succeed/fail counts.
+                    # print("reg (index={}, name={}): read verify FAILED: wrote {:x}, verify read back {:x}".format(reg_index, reg_info["name"], flipped_bits_int, verify_bits))
+                    successful_writes -= 1
+                    failed_writes += 1
+
+        return (successful_writes, failed_writes)
+
+    def is_bit_flippable_register(self, reg_info):
+        if not reg_info:
+            return False
+        if not "set" in reg_info:
+            return False
+        if reg_info["set"] != "General Purpose Registers":
+            return False
+        if ("container-regs" in reg_info) and (
+                len(reg_info["container-regs"]) > 0):
+            # Don't try to bit flip registers contained in another register.
+            return False
+        if re.match("^.s$", reg_info["name"]):
+            # This is a 2-letter register name that ends in "s", like a segment register.
+            # Don't try to bit flip these.
+            return False
+        if re.match("^(c|)psr$", reg_info["name"]):
+            # This is an ARM program status register; don't flip it.
+            return False
+        # Okay, this looks fine-enough.
+        return True
+
+    def read_register_values(self, reg_infos, endian, thread_id=None):
+        self.assertIsNotNone(reg_infos)
+        values = {}
+
+        for reg_info in reg_infos:
+            # We append a register index when load reg infos so we can work
+            # with subsets.
+            reg_index = reg_info.get("lldb_register_index")
+            self.assertIsNotNone(reg_index)
+
+            # Handle thread suffix.
+            if thread_id:
+                p_request = "read packet: $p{:x};thread:{:x}#00".format(
+                    reg_index, thread_id)
+            else:
+                p_request = "read packet: $p{:x}#00".format(reg_index)
+
+            # Read it with p.
+            self.reset_test_sequence()
+            self.test_sequence.add_log_lines([
+                p_request,
+                {"direction": "send", "regex": r"^\$([0-9a-fA-F]+)#", "capture": {1: "p_response"}},
+            ], True)
+            context = self.expect_gdbremote_sequence()
+            self.assertIsNotNone(context)
+
+            # Convert value from target endian to integral.
+            p_response = context.get("p_response")
+            self.assertIsNotNone(p_response)
+            self.assertTrue(len(p_response) > 0)
+            self.assertFalse(p_response[0] == "E")
+
+            values[reg_index] = unpack_register_hex_unsigned(
+                endian, p_response)
+
+        return values
+
+    def add_vCont_query_packets(self):
+        self.test_sequence.add_log_lines(["read packet: $vCont?#49",
+                                          {"direction": "send",
+                                           "regex": r"^\$(vCont)?(.*)#[0-9a-fA-F]{2}$",
+                                           "capture": {2: "vCont_query_response"}},
+                                          ],
+                                         True)
+
+    def parse_vCont_query_response(self, context):
+        self.assertIsNotNone(context)
+        vCont_query_response = context.get("vCont_query_response")
+
+        # Handle case of no vCont support at all - in which case the capture
+        # group will be none or zero length.
+        if not vCont_query_response or len(vCont_query_response) == 0:
+            return {}
+
+        return {key: 1 for key in vCont_query_response.split(
+            ";") if key and len(key) > 0}
+
+    def count_single_steps_until_true(
+            self,
+            thread_id,
+            predicate,
+            args,
+            max_step_count=100,
+            use_Hc_packet=True,
+            step_instruction="s"):
+        """Used by single step test that appears in a few different contexts."""
+        single_step_count = 0
+
+        while single_step_count < max_step_count:
+            self.assertIsNotNone(thread_id)
+
+            # Build the packet for the single step instruction.  We replace
+            # {thread}, if present, with the thread_id.
+            step_packet = "read packet: ${}#00".format(
+                re.sub(r"{thread}", "{:x}".format(thread_id), step_instruction))
+            # print("\nstep_packet created: {}\n".format(step_packet))
+
+            # Single step.
+            self.reset_test_sequence()
+            if use_Hc_packet:
+                self.test_sequence.add_log_lines(
+                    [  # Set the continue thread.
+                        "read packet: $Hc{0:x}#00".format(thread_id),
+                        "send packet: $OK#00",
+                    ], True)
+            self.test_sequence.add_log_lines([
+                # Single step.
+                step_packet,
+                # "read packet: $vCont;s:{0:x}#00".format(thread_id),
+                # Expect a breakpoint stop report.
+                {"direction": "send",
+                 "regex": r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);",
+                 "capture": {1: "stop_signo",
+                             2: "stop_thread_id"}},
+            ], True)
+            context = self.expect_gdbremote_sequence()
+            self.assertIsNotNone(context)
+            self.assertIsNotNone(context.get("stop_signo"))
+            self.assertEqual(int(context.get("stop_signo"), 16),
+                             lldbutil.get_signal_number('SIGTRAP'))
+
+            single_step_count += 1
+
+            # See if the predicate is true.  If so, we're done.
+            if predicate(args):
+                return (True, single_step_count)
+
+        # The predicate didn't return true within the runaway step count.
+        return (False, single_step_count)
+
+    def g_c1_c2_contents_are(self, args):
+        """Used by single step test that appears in a few different contexts."""
+        g_c1_address = args["g_c1_address"]
+        g_c2_address = args["g_c2_address"]
+        expected_g_c1 = args["expected_g_c1"]
+        expected_g_c2 = args["expected_g_c2"]
+
+        # Read g_c1 and g_c2 contents.
+        self.reset_test_sequence()
+        self.test_sequence.add_log_lines(
+            ["read packet: $m{0:x},{1:x}#00".format(g_c1_address, 1),
+             {"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$", "capture": {1: "g_c1_contents"}},
+             "read packet: $m{0:x},{1:x}#00".format(g_c2_address, 1),
+             {"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$", "capture": {1: "g_c2_contents"}}],
+            True)
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Check if what we read from inferior memory is what we are expecting.
+        self.assertIsNotNone(context.get("g_c1_contents"))
+        self.assertIsNotNone(context.get("g_c2_contents"))
+
+        return (seven.unhexlify(context.get("g_c1_contents")) == expected_g_c1) and (
+            seven.unhexlify(context.get("g_c2_contents")) == expected_g_c2)
+
+    def single_step_only_steps_one_instruction(
+            self, use_Hc_packet=True, step_instruction="s"):
+        """Used by single step test that appears in a few different contexts."""
+        # Start up the inferior.
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=[
+                "get-code-address-hex:swap_chars",
+                "get-data-address-hex:g_c1",
+                "get-data-address-hex:g_c2",
+                "sleep:1",
+                "call-function:swap_chars",
+                "sleep:5"])
+
+        # Run the process
+        self.test_sequence.add_log_lines(
+            [  # Start running after initial stop.
+                "read packet: $c#63",
+                # Match output line that prints the memory address of the function call entry point.
+                # Note we require launch-only testing so we can get inferior otuput.
+                {"type": "output_match", "regex": r"^code address: 0x([0-9a-fA-F]+)\r\ndata address: 0x([0-9a-fA-F]+)\r\ndata address: 0x([0-9a-fA-F]+)\r\n$",
+                 "capture": {1: "function_address", 2: "g_c1_address", 3: "g_c2_address"}},
+                # Now stop the inferior.
+                "read packet: {}".format(chr(3)),
+                # And wait for the stop notification.
+                {"direction": "send", "regex": r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture": {1: "stop_signo", 2: "stop_thread_id"}}],
+            True)
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Grab the main thread id.
+        self.assertIsNotNone(context.get("stop_thread_id"))
+        main_thread_id = int(context.get("stop_thread_id"), 16)
+
+        # Grab the function address.
+        self.assertIsNotNone(context.get("function_address"))
+        function_address = int(context.get("function_address"), 16)
+
+        # Grab the data addresses.
+        self.assertIsNotNone(context.get("g_c1_address"))
+        g_c1_address = int(context.get("g_c1_address"), 16)
+
+        self.assertIsNotNone(context.get("g_c2_address"))
+        g_c2_address = int(context.get("g_c2_address"), 16)
+
+        # Set a breakpoint at the given address.
+        if self.getArchitecture() == "arm":
+            # TODO: Handle case when setting breakpoint in thumb code
+            BREAKPOINT_KIND = 4
+        else:
+            BREAKPOINT_KIND = 1
+        self.reset_test_sequence()
+        self.add_set_breakpoint_packets(
+            function_address,
+            do_continue=True,
+            breakpoint_kind=BREAKPOINT_KIND)
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Remove the breakpoint.
+        self.reset_test_sequence()
+        self.add_remove_breakpoint_packets(
+            function_address, breakpoint_kind=BREAKPOINT_KIND)
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Verify g_c1 and g_c2 match expected initial state.
+        args = {}
+        args["g_c1_address"] = g_c1_address
+        args["g_c2_address"] = g_c2_address
+        args["expected_g_c1"] = "0"
+        args["expected_g_c2"] = "1"
+
+        self.assertTrue(self.g_c1_c2_contents_are(args))
+
+        # Verify we take only a small number of steps to hit the first state.
+        # Might need to work through function entry prologue code.
+        args["expected_g_c1"] = "1"
+        args["expected_g_c2"] = "1"
+        (state_reached,
+         step_count) = self.count_single_steps_until_true(main_thread_id,
+                                                          self.g_c1_c2_contents_are,
+                                                          args,
+                                                          max_step_count=25,
+                                                          use_Hc_packet=use_Hc_packet,
+                                                          step_instruction=step_instruction)
+        self.assertTrue(state_reached)
+
+        # Verify we hit the next state.
+        args["expected_g_c1"] = "1"
+        args["expected_g_c2"] = "0"
+        (state_reached,
+         step_count) = self.count_single_steps_until_true(main_thread_id,
+                                                          self.g_c1_c2_contents_are,
+                                                          args,
+                                                          max_step_count=5,
+                                                          use_Hc_packet=use_Hc_packet,
+                                                          step_instruction=step_instruction)
+        self.assertTrue(state_reached)
+        expected_step_count = 1
+        arch = self.getArchitecture()
+
+        # MIPS required "3" (ADDIU, SB, LD) machine instructions for updation
+        # of variable value
+        if re.match("mips", arch):
+            expected_step_count = 3
+        # S390X requires "2" (LARL, MVI) machine instructions for updation of
+        # variable value
+        if re.match("s390x", arch):
+            expected_step_count = 2
+        self.assertEqual(step_count, expected_step_count)
+
+        # Verify we hit the next state.
+        args["expected_g_c1"] = "0"
+        args["expected_g_c2"] = "0"
+        (state_reached,
+         step_count) = self.count_single_steps_until_true(main_thread_id,
+                                                          self.g_c1_c2_contents_are,
+                                                          args,
+                                                          max_step_count=5,
+                                                          use_Hc_packet=use_Hc_packet,
+                                                          step_instruction=step_instruction)
+        self.assertTrue(state_reached)
+        self.assertEqual(step_count, expected_step_count)
+
+        # Verify we hit the next state.
+        args["expected_g_c1"] = "0"
+        args["expected_g_c2"] = "1"
+        (state_reached,
+         step_count) = self.count_single_steps_until_true(main_thread_id,
+                                                          self.g_c1_c2_contents_are,
+                                                          args,
+                                                          max_step_count=5,
+                                                          use_Hc_packet=use_Hc_packet,
+                                                          step_instruction=step_instruction)
+        self.assertTrue(state_reached)
+        self.assertEqual(step_count, expected_step_count)
+
+    def maybe_strict_output_regex(self, regex):
+        return '.*' + regex + \
+            '.*' if lldbplatformutil.hasChattyStderr(self) else '^' + regex + '$'
+
+    def install_and_create_launch_args(self):
+        exe_path = self.getBuildArtifact("a.out")
+        if not lldb.remote_platform:
+            return [exe_path]
+        remote_path = lldbutil.append_to_process_working_directory(self,
+            os.path.basename(exe_path))
+        remote_file_spec = lldb.SBFileSpec(remote_path, False)
+        err = lldb.remote_platform.Install(lldb.SBFileSpec(exe_path, True),
+                                           remote_file_spec)
+        if err.Fail():
+            raise Exception("remote_platform.Install('%s', '%s') failed: %s" %
+                            (exe_path, remote_path, err))
+        return [remote_path]

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/inferior-crash/Makefile

+LEVEL = ../../../make
+
+CFLAGS_EXTRAS += -D__STDC_LIMIT_MACROS -D__STDC_FORMAT_MACROS -std=c++11
+# LD_EXTRAS := -lpthread
+CXX_SOURCES := main.cpp
+MAKE_DSYM :=NO
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/inferior-crash/TestGdbRemoteAbort.py

+from __future__ import print_function
+
+
+import gdbremote_testcase
+import signal
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestGdbRemoteAbort(gdbremote_testcase.GdbRemoteTestCaseBase):
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def inferior_abort_received(self):
+        procs = self.prep_debug_monitor_and_inferior(inferior_args=["abort"])
+        self.assertIsNotNone(procs)
+
+        self.test_sequence.add_log_lines(["read packet: $vCont;c#a8",
+                                          {"direction": "send",
+                                           "regex": r"^\$T([0-9a-fA-F]{2}).*#[0-9a-fA-F]{2}$",
+                                           "capture": {1: "hex_exit_code"}},
+                                          ],
+                                         True)
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        hex_exit_code = context.get("hex_exit_code")
+        self.assertIsNotNone(hex_exit_code)
+        self.assertEqual(int(hex_exit_code, 16),
+                         lldbutil.get_signal_number('SIGABRT'))
+
+    @debugserver_test
+    def test_inferior_abort_received_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.inferior_abort_received()
+
+    @llgs_test
+    # std::abort() on <= API 16 raises SIGSEGV - b.android.com/179836
+    @expectedFailureAndroid(api_levels=list(range(16 + 1)))
+    def test_inferior_abort_received_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.inferior_abort_received()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/inferior-crash/TestGdbRemoteSegFault.py

+from __future__ import print_function
+
+
+import gdbremote_testcase
+import signal
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestGdbRemoteSegFault(gdbremote_testcase.GdbRemoteTestCaseBase):
+    mydir = TestBase.compute_mydir(__file__)
+
+    GDB_REMOTE_STOP_CODE_BAD_ACCESS = 0x91
+
+    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    def inferior_seg_fault_received(self, expected_signo):
+        procs = self.prep_debug_monitor_and_inferior(
+            inferior_args=["segfault"])
+        self.assertIsNotNone(procs)
+
+        self.test_sequence.add_log_lines(["read packet: $vCont;c#a8",
+                                          {"direction": "send",
+                                           "regex": r"^\$T([0-9a-fA-F]{2}).*#[0-9a-fA-F]{2}$",
+                                           "capture": {1: "hex_exit_code"}},
+                                          ],
+                                         True)
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        hex_exit_code = context.get("hex_exit_code")
+        self.assertIsNotNone(hex_exit_code)
+        self.assertEqual(int(hex_exit_code, 16), expected_signo)
+
+    @debugserver_test
+    def test_inferior_seg_fault_received_debugserver(self):
+        self.init_debugserver_test()
+        self.build()
+        self.inferior_seg_fault_received(self.GDB_REMOTE_STOP_CODE_BAD_ACCESS)
+
+    @llgs_test
+    def test_inferior_seg_fault_received_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.inferior_seg_fault_received(lldbutil.get_signal_number('SIGSEGV'))

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/inferior-crash/main.cpp

+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+
+namespace {
+const char *const SEGFAULT_COMMAND = "segfault";
+const char *const ABORT_COMMAND = "abort";
+}
+
+int main(int argc, char **argv) {
+  if (argc < 2) {
+    std::cout << "expected at least one command provided on the command line"
+              << std::endl;
+  }
+
+  // Process command line args.
+  for (int i = 1; i < argc; ++i) {
+    const char *const command = argv[i];
+    if (std::strstr(command, SEGFAULT_COMMAND)) {
+      // Perform a null pointer access.
+      int *const null_int_ptr = nullptr;
+      *null_int_ptr = 0xDEAD;
+    } else if (std::strstr(command, ABORT_COMMAND)) {
+      std::abort();
+    } else {
+      std::cout << "Unsupported command: " << command << std::endl;
+    }
+  }
+
+  return 0;
+}

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/lldbgdbserverutils.py

+"""Module for supporting unit testing of the lldb-server debug monitor exe.
+"""
+
+from __future__ import division, print_function
+
+
+import os
+import os.path
+import platform
+import re
+import six
+import socket_packet_pump
+import subprocess
+import time
+from lldbsuite.test.lldbtest import *
+
+from six.moves import queue
+
+
+def _get_debug_monitor_from_lldb(lldb_exe, debug_monitor_basename):
+    """Return the debug monitor exe path given the lldb exe path.
+
+    This method attempts to construct a valid debug monitor exe name
+    from a given lldb exe name.  It will return None if the synthesized
+    debug monitor name is not found to exist.
+
+    The debug monitor exe path is synthesized by taking the directory
+    of the lldb exe, and replacing the portion of the base name that
+    matches "lldb" (case insensitive) and replacing with the value of
+    debug_monitor_basename.
+
+    Args:
+        lldb_exe: the path to an lldb executable.
+
+        debug_monitor_basename: the base name portion of the debug monitor
+            that will replace 'lldb'.
+
+    Returns:
+        A path to the debug monitor exe if it is found to exist; otherwise,
+        returns None.
+
+    """
+    if not lldb_exe:
+        return None
+
+    exe_dir = os.path.dirname(lldb_exe)
+    exe_base = os.path.basename(lldb_exe)
+
+    # we'll rebuild the filename by replacing lldb with
+    # the debug monitor basename, keeping any prefix or suffix in place.
+    regex = re.compile(r"lldb", re.IGNORECASE)
+    new_base = regex.sub(debug_monitor_basename, exe_base)
+
+    debug_monitor_exe = os.path.join(exe_dir, new_base)
+    if os.path.exists(debug_monitor_exe):
+        return debug_monitor_exe
+
+    new_base = regex.sub(
+        'LLDB.framework/Versions/A/Resources/' +
+        debug_monitor_basename,
+        exe_base)
+    debug_monitor_exe = os.path.join(exe_dir, new_base)
+    if os.path.exists(debug_monitor_exe):
+        return debug_monitor_exe
+
+    return None
+
+
+def get_lldb_server_exe():
+    """Return the lldb-server exe path.
+
+    Returns:
+        A path to the lldb-server exe if it is found to exist; otherwise,
+        returns None.
+    """
+    if "LLDB_DEBUGSERVER_PATH" in os.environ:
+        return os.environ["LLDB_DEBUGSERVER_PATH"]
+
+    return _get_debug_monitor_from_lldb(
+        lldbtest_config.lldbExec, "lldb-server")
+
+
+def get_debugserver_exe():
+    """Return the debugserver exe path.
+
+    Returns:
+        A path to the debugserver exe if it is found to exist; otherwise,
+        returns None.
+    """
+    if "LLDB_DEBUGSERVER_PATH" in os.environ:
+        return os.environ["LLDB_DEBUGSERVER_PATH"]
+
+    return _get_debug_monitor_from_lldb(
+        lldbtest_config.lldbExec, "debugserver")
+
+_LOG_LINE_REGEX = re.compile(r'^(lldb-server|debugserver)\s+<\s*(\d+)>' +
+                             '\s+(read|send)\s+packet:\s+(.+)$')
+
+
+def _is_packet_lldb_gdbserver_input(packet_type, llgs_input_is_read):
+    """Return whether a given packet is input for lldb-gdbserver.
+
+    Args:
+        packet_type: a string indicating 'send' or 'receive', from a
+            gdbremote packet protocol log.
+
+        llgs_input_is_read: true if lldb-gdbserver input (content sent to
+            lldb-gdbserver) is listed as 'read' or 'send' in the packet
+            log entry.
+
+    Returns:
+        True if the packet should be considered input for lldb-gdbserver; False
+        otherwise.
+    """
+    if packet_type == 'read':
+        # when llgs is the read side, then a read packet is meant for
+        # input to llgs (when captured from the llgs/debugserver exe).
+        return llgs_input_is_read
+    elif packet_type == 'send':
+        # when llgs is the send side, then a send packet is meant to
+        # be input to llgs (when captured from the lldb exe).
+        return not llgs_input_is_read
+    else:
+        # don't understand what type of packet this is
+        raise "Unknown packet type: {}".format(packet_type)
+
+
+def handle_O_packet(context, packet_contents, logger):
+    """Handle O packets."""
+    if (not packet_contents) or (len(packet_contents) < 1):
+        return False
+    elif packet_contents[0] != "O":
+        return False
+    elif packet_contents == "OK":
+        return False
+
+    new_text = gdbremote_hex_decode_string(packet_contents[1:])
+    context["O_content"] += new_text
+    context["O_count"] += 1
+
+    if logger:
+        logger.debug(
+            "text: new \"{}\", cumulative: \"{}\"".format(
+                new_text, context["O_content"]))
+
+    return True
+
+_STRIP_CHECKSUM_REGEX = re.compile(r'#[0-9a-fA-F]{2}$')
+_STRIP_COMMAND_PREFIX_REGEX = re.compile(r"^\$")
+_STRIP_COMMAND_PREFIX_M_REGEX = re.compile(r"^\$m")
+
+
+def assert_packets_equal(asserter, actual_packet, expected_packet):
+    # strip off the checksum digits of the packet.  When we're in
+    # no-ack mode, the # checksum is ignored, and should not be cause
+    # for a mismatched packet.
+    actual_stripped = _STRIP_CHECKSUM_REGEX.sub('', actual_packet)
+    expected_stripped = _STRIP_CHECKSUM_REGEX.sub('', expected_packet)
+    asserter.assertEqual(actual_stripped, expected_stripped)
+
+
+def expect_lldb_gdbserver_replay(
+        asserter,
+        sock,
+        test_sequence,
+        pump_queues,
+        timeout_seconds,
+        logger=None):
+    """Replay socket communication with lldb-gdbserver and verify responses.
+
+    Args:
+        asserter: the object providing assertEqual(first, second, msg=None), e.g. TestCase instance.
+
+        sock: the TCP socket connected to the lldb-gdbserver exe.
+
+        test_sequence: a GdbRemoteTestSequence instance that describes
+            the messages sent to the gdb remote and the responses
+            expected from it.
+
+        timeout_seconds: any response taking more than this number of
+           seconds will cause an exception to be raised.
+
+        logger: a Python logger instance.
+
+    Returns:
+        The context dictionary from running the given gdbremote
+        protocol sequence.  This will contain any of the capture
+        elements specified to any GdbRemoteEntry instances in
+        test_sequence.
+
+        The context will also contain an entry, context["O_content"]
+        which contains the text from the inferior received via $O
+        packets.  $O packets should not attempt to be matched
+        directly since they are not entirely deterministic as to
+        how many arrive and how much text is in each one.
+
+        context["O_count"] will contain an integer of the number of
+        O packets received.
+    """
+
+    # Ensure we have some work to do.
+    if len(test_sequence.entries) < 1:
+        return {}
+
+    context = {"O_count": 0, "O_content": ""}
+    with socket_packet_pump.SocketPacketPump(sock, pump_queues, logger) as pump:
+        # Grab the first sequence entry.
+        sequence_entry = test_sequence.entries.pop(0)
+
+        # While we have an active sequence entry, send messages
+        # destined for the stub and collect/match/process responses
+        # expected from the stub.
+        while sequence_entry:
+            if sequence_entry.is_send_to_remote():
+                # This is an entry to send to the remote debug monitor.
+                send_packet = sequence_entry.get_send_packet()
+                if logger:
+                    if len(send_packet) == 1 and send_packet[0] == chr(3):
+                        packet_desc = "^C"
+                    else:
+                        packet_desc = send_packet
+                    logger.info(
+                        "sending packet to remote: {}".format(packet_desc))
+                sock.sendall(send_packet.encode())
+            else:
+                # This is an entry expecting to receive content from the remote
+                # debug monitor.
+
+                # We'll pull from (and wait on) the queue appropriate for the type of matcher.
+                # We keep separate queues for process output (coming from non-deterministic
+                # $O packet division) and for all other packets.
+                if sequence_entry.is_output_matcher():
+                    try:
+                        # Grab next entry from the output queue.
+                        content = pump_queues.output_queue().get(True, timeout_seconds)
+                    except queue.Empty:
+                        if logger:
+                            logger.warning(
+                                "timeout waiting for stub output (accumulated output:{})".format(
+                                    pump.get_accumulated_output()))
+                        raise Exception(
+                            "timed out while waiting for output match (accumulated output: {})".format(
+                                pump.get_accumulated_output()))
+                else:
+                    try:
+                        content = pump_queues.packet_queue().get(True, timeout_seconds)
+                    except queue.Empty:
+                        if logger:
+                            logger.warning(
+                                "timeout waiting for packet match (receive buffer: {})".format(
+                                    pump.get_receive_buffer()))
+                        raise Exception(
+                            "timed out while waiting for packet match (receive buffer: {})".format(
+                                pump.get_receive_buffer()))
+
+                # Give the sequence entry the opportunity to match the content.
+                # Output matchers might match or pass after more output accumulates.
+                # Other packet types generally must match.
+                asserter.assertIsNotNone(content)
+                context = sequence_entry.assert_match(
+                    asserter, content, context=context)
+
+            # Move on to next sequence entry as needed.  Some sequence entries support executing multiple
+            # times in different states (for looping over query/response
+            # packets).
+            if sequence_entry.is_consumed():
+                if len(test_sequence.entries) > 0:
+                    sequence_entry = test_sequence.entries.pop(0)
+                else:
+                    sequence_entry = None
+
+        # Fill in the O_content entries.
+        context["O_count"] = 1
+        context["O_content"] = pump.get_accumulated_output()
+
+    return context
+
+
+def gdbremote_hex_encode_string(str):
+    output = ''
+    for c in str:
+        output += '{0:02x}'.format(ord(c))
+    return output
+
+
+def gdbremote_hex_decode_string(str):
+    return str.decode("hex")
+
+
+def gdbremote_packet_encode_string(str):
+    checksum = 0
+    for c in str:
+        checksum += ord(c)
+    return '$' + str + '#{0:02x}'.format(checksum % 256)
+
+
+def build_gdbremote_A_packet(args_list):
+    """Given a list of args, create a properly-formed $A packet containing each arg.
+    """
+    payload = "A"
+
+    # build the arg content
+    arg_index = 0
+    for arg in args_list:
+        # Comma-separate the args.
+        if arg_index > 0:
+            payload += ','
+
+        # Hex-encode the arg.
+        hex_arg = gdbremote_hex_encode_string(arg)
+
+        # Build the A entry.
+        payload += "{},{},{}".format(len(hex_arg), arg_index, hex_arg)
+
+        # Next arg index, please.
+        arg_index += 1
+
+    # return the packetized payload
+    return gdbremote_packet_encode_string(payload)
+
+
+def parse_reg_info_response(response_packet):
+    if not response_packet:
+        raise Exception("response_packet cannot be None")
+
+    # Strip off prefix $ and suffix #xx if present.
+    response_packet = _STRIP_COMMAND_PREFIX_REGEX.sub("", response_packet)
+    response_packet = _STRIP_CHECKSUM_REGEX.sub("", response_packet)
+
+    # Build keyval pairs
+    values = {}
+    for kv in response_packet.split(";"):
+        if len(kv) < 1:
+            continue
+        (key, val) = kv.split(':')
+        values[key] = val
+
+    return values
+
+
+def parse_threadinfo_response(response_packet):
+    if not response_packet:
+        raise Exception("response_packet cannot be None")
+
+    # Strip off prefix $ and suffix #xx if present.
+    response_packet = _STRIP_COMMAND_PREFIX_M_REGEX.sub("", response_packet)
+    response_packet = _STRIP_CHECKSUM_REGEX.sub("", response_packet)
+
+    # Return list of thread ids
+    return [int(thread_id_hex, 16) for thread_id_hex in response_packet.split(
+        ",") if len(thread_id_hex) > 0]
+
+
+def unpack_endian_binary_string(endian, value_string):
+    """Unpack a gdb-remote binary (post-unescaped, i.e. not escaped) response to an unsigned int given endianness of the inferior."""
+    if not endian:
+        raise Exception("endian cannot be None")
+    if not value_string or len(value_string) < 1:
+        raise Exception("value_string cannot be None or empty")
+
+    if endian == 'little':
+        value = 0
+        i = 0
+        while len(value_string) > 0:
+            value += (ord(value_string[0]) << i)
+            value_string = value_string[1:]
+            i += 8
+        return value
+    elif endian == 'big':
+        value = 0
+        while len(value_string) > 0:
+            value = (value << 8) + ord(value_string[0])
+            value_string = value_string[1:]
+        return value
+    else:
+        # pdp is valid but need to add parse code once needed.
+        raise Exception("unsupported endian:{}".format(endian))
+
+
+def unpack_register_hex_unsigned(endian, value_string):
+    """Unpack a gdb-remote $p-style response to an unsigned int given endianness of inferior."""
+    if not endian:
+        raise Exception("endian cannot be None")
+    if not value_string or len(value_string) < 1:
+        raise Exception("value_string cannot be None or empty")
+
+    if endian == 'little':
+        value = 0
+        i = 0
+        while len(value_string) > 0:
+            value += (int(value_string[0:2], 16) << i)
+            value_string = value_string[2:]
+            i += 8
+        return value
+    elif endian == 'big':
+        return int(value_string, 16)
+    else:
+        # pdp is valid but need to add parse code once needed.
+        raise Exception("unsupported endian:{}".format(endian))
+
+
+def pack_register_hex(endian, value, byte_size=None):
+    """Unpack a gdb-remote $p-style response to an unsigned int given endianness of inferior."""
+    if not endian:
+        raise Exception("endian cannot be None")
+
+    if endian == 'little':
+        # Create the litt-endian return value.
+        retval = ""
+        while value != 0:
+            retval = retval + "{:02x}".format(value & 0xff)
+            value = value >> 8
+        if byte_size:
+            # Add zero-fill to the right/end (MSB side) of the value.
+            retval += "00" * (byte_size - len(retval) // 2)
+        return retval
+
+    elif endian == 'big':
+        retval = ""
+        while value != 0:
+            retval = "{:02x}".format(value & 0xff) + retval
+            value = value >> 8
+        if byte_size:
+            # Add zero-fill to the left/front (MSB side) of the value.
+            retval = ("00" * (byte_size - len(retval) // 2)) + retval
+        return retval
+
+    else:
+        # pdp is valid but need to add parse code once needed.
+        raise Exception("unsupported endian:{}".format(endian))
+
+
+class GdbRemoteEntryBase(object):
+
+    def is_output_matcher(self):
+        return False
+
+
+class GdbRemoteEntry(GdbRemoteEntryBase):
+
+    def __init__(
+            self,
+            is_send_to_remote=True,
+            exact_payload=None,
+            regex=None,
+            capture=None,
+            expect_captures=None):
+        """Create an entry representing one piece of the I/O to/from a gdb remote debug monitor.
+
+        Args:
+
+            is_send_to_remote: True if this entry is a message to be
+                sent to the gdbremote debug monitor; False if this
+                entry represents text to be matched against the reply
+                from the gdbremote debug monitor.
+
+            exact_payload: if not None, then this packet is an exact
+                send (when sending to the remote) or an exact match of
+                the response from the gdbremote. The checksums are
+                ignored on exact match requests since negotiation of
+                no-ack makes the checksum content essentially
+                undefined.
+
+            regex: currently only valid for receives from gdbremote.
+                When specified (and only if exact_payload is None),
+                indicates the gdbremote response must match the given
+                regex. Match groups in the regex can be used for two
+                different purposes: saving the match (see capture
+                arg), or validating that a match group matches a
+                previously established value (see expect_captures). It
+                is perfectly valid to have just a regex arg and to
+                specify neither capture or expect_captures args. This
+                arg only makes sense if exact_payload is not
+                specified.
+
+            capture: if specified, is a dictionary of regex match
+                group indices (should start with 1) to variable names
+                that will store the capture group indicated by the
+                index. For example, {1:"thread_id"} will store capture
+                group 1's content in the context dictionary where
+                "thread_id" is the key and the match group value is
+                the value. The value stored off can be used later in a
+                expect_captures expression. This arg only makes sense
+                when regex is specified.
+
+            expect_captures: if specified, is a dictionary of regex
+                match group indices (should start with 1) to variable
+                names, where the match group should match the value
+                existing in the context at the given variable name.
+                For example, {2:"thread_id"} indicates that the second
+                match group must match the value stored under the
+                context's previously stored "thread_id" key. This arg
+                only makes sense when regex is specified.
+        """
+        self._is_send_to_remote = is_send_to_remote
+        self.exact_payload = exact_payload
+        self.regex = regex
+        self.capture = capture
+        self.expect_captures = expect_captures
+
+    def is_send_to_remote(self):
+        return self._is_send_to_remote
+
+    def is_consumed(self):
+        # For now, all packets are consumed after first use.
+        return True
+
+    def get_send_packet(self):
+        if not self.is_send_to_remote():
+            raise Exception(
+                "get_send_packet() called on GdbRemoteEntry that is not a send-to-remote packet")
+        if not self.exact_payload:
+            raise Exception(
+                "get_send_packet() called on GdbRemoteEntry but it doesn't have an exact payload")
+        return self.exact_payload
+
+    def _assert_exact_payload_match(self, asserter, actual_packet):
+        assert_packets_equal(asserter, actual_packet, self.exact_payload)
+        return None
+
+    def _assert_regex_match(self, asserter, actual_packet, context):
+        # Ensure the actual packet matches from the start of the actual packet.
+        match = self.regex.match(actual_packet)
+        if not match:
+            asserter.fail(
+                "regex '{}' failed to match against content '{}'".format(
+                    self.regex.pattern, actual_packet))
+
+        if self.capture:
+            # Handle captures.
+            for group_index, var_name in list(self.capture.items()):
+                capture_text = match.group(group_index)
+                # It is okay for capture text to be None - which it will be if it is a group that can match nothing.
+                # The user must be okay with it since the regex itself matched
+                # above.
+                context[var_name] = capture_text
+
+        if self.expect_captures:
+            # Handle comparing matched groups to context dictionary entries.
+            for group_index, var_name in list(self.expect_captures.items()):
+                capture_text = match.group(group_index)
+                if not capture_text:
+                    raise Exception(
+                        "No content to expect for group index {}".format(group_index))
+                asserter.assertEqual(capture_text, context[var_name])
+
+        return context
+
+    def assert_match(self, asserter, actual_packet, context=None):
+        # This only makes sense for matching lines coming from the
+        # remote debug monitor.
+        if self.is_send_to_remote():
+            raise Exception(
+                "Attempted to match a packet being sent to the remote debug monitor, doesn't make sense.")
+
+        # Create a new context if needed.
+        if not context:
+            context = {}
+
+        # If this is an exact payload, ensure they match exactly,
+        # ignoring the packet checksum which is optional for no-ack
+        # mode.
+        if self.exact_payload:
+            self._assert_exact_payload_match(asserter, actual_packet)
+            return context
+        elif self.regex:
+            return self._assert_regex_match(asserter, actual_packet, context)
+        else:
+            raise Exception(
+                "Don't know how to match a remote-sent packet when exact_payload isn't specified.")
+
+
+class MultiResponseGdbRemoteEntry(GdbRemoteEntryBase):
+    """Represents a query/response style packet.
+
+    Assumes the first item is sent to the gdb remote.
+    An end sequence regex indicates the end of the query/response
+    packet sequence.  All responses up through (but not including) the
+    end response are stored in a context variable.
+
+    Settings accepted from params:
+
+        next_query or query: required.  The typical query packet without the $ prefix or #xx suffix.
+            If there is a special first packet to start the iteration query, see the
+            first_query key.
+
+        first_query: optional. If the first query requires a special query command, specify
+            it with this key.  Do not specify the $ prefix or #xx suffix.
+
+        append_iteration_suffix: defaults to False.  Specify True if the 0-based iteration
+            index should be appended as a suffix to the command.  e.g. qRegisterInfo with
+            this key set true will generate query packets of qRegisterInfo0, qRegisterInfo1,
+            etc.
+
+        end_regex: required. Specifies a compiled regex object that will match the full text
+            of any response that signals an end to the iteration.  It must include the
+            initial $ and ending #xx and must match the whole packet.
+
+        save_key: required.  Specifies the key within the context where an array will be stored.
+            Each packet received from the gdb remote that does not match the end_regex will get
+            appended to the array stored within the context at that key.
+
+        runaway_response_count: optional. Defaults to 10000. If this many responses are retrieved,
+            assume there is something wrong with either the response collection or the ending
+            detection regex and throw an exception.
+    """
+
+    def __init__(self, params):
+        self._next_query = params.get("next_query", params.get("query"))
+        if not self._next_query:
+            raise "either next_query or query key must be specified for MultiResponseGdbRemoteEntry"
+
+        self._first_query = params.get("first_query", self._next_query)
+        self._append_iteration_suffix = params.get(
+            "append_iteration_suffix", False)
+        self._iteration = 0
+        self._end_regex = params["end_regex"]
+        self._save_key = params["save_key"]
+        self._runaway_response_count = params.get(
+            "runaway_response_count", 10000)
+        self._is_send_to_remote = True
+        self._end_matched = False
+
+    def is_send_to_remote(self):
+        return self._is_send_to_remote
+
+    def get_send_packet(self):
+        if not self.is_send_to_remote():
+            raise Exception(
+                "get_send_packet() called on MultiResponseGdbRemoteEntry that is not in the send state")
+        if self._end_matched:
+            raise Exception(
+                "get_send_packet() called on MultiResponseGdbRemoteEntry but end of query/response sequence has already been seen.")
+
+        # Choose the first or next query for the base payload.
+        if self._iteration == 0 and self._first_query:
+            payload = self._first_query
+        else:
+            payload = self._next_query
+
+        # Append the suffix as needed.
+        if self._append_iteration_suffix:
+            payload += "%x" % self._iteration
+
+        # Keep track of the iteration.
+        self._iteration += 1
+
+        # Now that we've given the query packet, flip the mode to
+        # receive/match.
+        self._is_send_to_remote = False
+
+        # Return the result, converted to packet form.
+        return gdbremote_packet_encode_string(payload)
+
+    def is_consumed(self):
+        return self._end_matched
+
+    def assert_match(self, asserter, actual_packet, context=None):
+        # This only makes sense for matching lines coming from the remote debug
+        # monitor.
+        if self.is_send_to_remote():
+            raise Exception(
+                "assert_match() called on MultiResponseGdbRemoteEntry but state is set to send a query packet.")
+
+        if self._end_matched:
+            raise Exception(
+                "assert_match() called on MultiResponseGdbRemoteEntry but end of query/response sequence has already been seen.")
+
+        # Set up a context as needed.
+        if not context:
+            context = {}
+
+        # Check if the packet matches the end condition.
+        match = self._end_regex.match(actual_packet)
+        if match:
+            # We're done iterating.
+            self._end_matched = True
+            return context
+
+        # Not done iterating - save the packet.
+        context[self._save_key] = context.get(self._save_key, [])
+        context[self._save_key].append(actual_packet)
+
+        # Check for a runaway response cycle.
+        if len(context[self._save_key]) >= self._runaway_response_count:
+            raise Exception(
+                "runaway query/response cycle detected: %d responses captured so far. Last response: %s" %
+                (len(
+                    context[
+                        self._save_key]), context[
+                    self._save_key][
+                    -1]))
+
+        # Flip the mode to send for generating the query.
+        self._is_send_to_remote = True
+        return context
+
+
+class MatchRemoteOutputEntry(GdbRemoteEntryBase):
+    """Waits for output from the debug monitor to match a regex or time out.
+
+    This entry type tries to match each time new gdb remote output is accumulated
+    using a provided regex.  If the output does not match the regex within the
+    given timeframe, the command fails the playback session.  If the regex does
+    match, any capture fields are recorded in the context.
+
+    Settings accepted from params:
+
+        regex: required. Specifies a compiled regex object that must either succeed
+            with re.match or re.search (see regex_mode below) within the given timeout
+            (see timeout_seconds below) or cause the playback to fail.
+
+        regex_mode: optional. Available values: "match" or "search". If "match", the entire
+            stub output as collected so far must match the regex.  If search, then the regex
+            must match starting somewhere within the output text accumulated thus far.
+            Default: "match" (i.e. the regex must match the entirety of the accumulated output
+            buffer, so unexpected text will generally fail the match).
+
+        capture: optional.  If specified, is a dictionary of regex match group indices (should start
+            with 1) to variable names that will store the capture group indicated by the
+            index. For example, {1:"thread_id"} will store capture group 1's content in the
+            context dictionary where "thread_id" is the key and the match group value is
+            the value. The value stored off can be used later in a expect_captures expression.
+            This arg only makes sense when regex is specified.
+    """
+
+    def __init__(self, regex=None, regex_mode="match", capture=None):
+        self._regex = regex
+        self._regex_mode = regex_mode
+        self._capture = capture
+        self._matched = False
+
+        if not self._regex:
+            raise Exception("regex cannot be None")
+
+        if not self._regex_mode in ["match", "search"]:
+            raise Exception(
+                "unsupported regex mode \"{}\": must be \"match\" or \"search\"".format(
+                    self._regex_mode))
+
+    def is_output_matcher(self):
+        return True
+
+    def is_send_to_remote(self):
+        # This is always a "wait for remote" command.
+        return False
+
+    def is_consumed(self):
+        return self._matched
+
+    def assert_match(self, asserter, accumulated_output, context):
+        # Validate args.
+        if not accumulated_output:
+            raise Exception("accumulated_output cannot be none")
+        if not context:
+            raise Exception("context cannot be none")
+
+        # Validate that we haven't already matched.
+        if self._matched:
+            raise Exception(
+                "invalid state - already matched, attempting to match again")
+
+        # If we don't have any content yet, we don't match.
+        if len(accumulated_output) < 1:
+            return context
+
+        # Check if we match
+        if self._regex_mode == "match":
+            match = self._regex.match(accumulated_output)
+        elif self._regex_mode == "search":
+            match = self._regex.search(accumulated_output)
+        else:
+            raise Exception(
+                "Unexpected regex mode: {}".format(
+                    self._regex_mode))
+
+        # If we don't match, wait to try again after next $O content, or time
+        # out.
+        if not match:
+            # print("re pattern \"{}\" did not match against \"{}\"".format(self._regex.pattern, accumulated_output))
+            return context
+
+        # We do match.
+        self._matched = True
+        # print("re pattern \"{}\" matched against \"{}\"".format(self._regex.pattern, accumulated_output))
+
+        # Collect up any captures into the context.
+        if self._capture:
+            # Handle captures.
+            for group_index, var_name in list(self._capture.items()):
+                capture_text = match.group(group_index)
+                if not capture_text:
+                    raise Exception(
+                        "No content for group index {}".format(group_index))
+                context[var_name] = capture_text
+
+        return context
+
+
+class GdbRemoteTestSequence(object):
+
+    _LOG_LINE_REGEX = re.compile(r'^.*(read|send)\s+packet:\s+(.+)$')
+
+    def __init__(self, logger):
+        self.entries = []
+        self.logger = logger
+
+    def add_log_lines(self, log_lines, remote_input_is_read):
+        for line in log_lines:
+            if isinstance(line, str):
+                # Handle log line import
+                # if self.logger:
+                #     self.logger.debug("processing log line: {}".format(line))
+                match = self._LOG_LINE_REGEX.match(line)
+                if match:
+                    playback_packet = match.group(2)
+                    direction = match.group(1)
+                    if _is_packet_lldb_gdbserver_input(
+                            direction, remote_input_is_read):
+                        # Handle as something to send to the remote debug monitor.
+                        # if self.logger:
+                        #     self.logger.info("processed packet to send to remote: {}".format(playback_packet))
+                        self.entries.append(
+                            GdbRemoteEntry(
+                                is_send_to_remote=True,
+                                exact_payload=playback_packet))
+                    else:
+                        # Log line represents content to be expected from the remote debug monitor.
+                        # if self.logger:
+                        #     self.logger.info("receiving packet from llgs, should match: {}".format(playback_packet))
+                        self.entries.append(
+                            GdbRemoteEntry(
+                                is_send_to_remote=False,
+                                exact_payload=playback_packet))
+                else:
+                    raise Exception(
+                        "failed to interpret log line: {}".format(line))
+            elif isinstance(line, dict):
+                entry_type = line.get("type", "regex_capture")
+                if entry_type == "regex_capture":
+                    # Handle more explicit control over details via dictionary.
+                    direction = line.get("direction", None)
+                    regex = line.get("regex", None)
+                    capture = line.get("capture", None)
+                    expect_captures = line.get("expect_captures", None)
+
+                    # Compile the regex.
+                    if regex and (isinstance(regex, str)):
+                        regex = re.compile(regex)
+
+                    if _is_packet_lldb_gdbserver_input(
+                            direction, remote_input_is_read):
+                        # Handle as something to send to the remote debug monitor.
+                        # if self.logger:
+                        #     self.logger.info("processed dict sequence to send to remote")
+                        self.entries.append(
+                            GdbRemoteEntry(
+                                is_send_to_remote=True,
+                                regex=regex,
+                                capture=capture,
+                                expect_captures=expect_captures))
+                    else:
+                        # Log line represents content to be expected from the remote debug monitor.
+                        # if self.logger:
+                        #     self.logger.info("processed dict sequence to match receiving from remote")
+                        self.entries.append(
+                            GdbRemoteEntry(
+                                is_send_to_remote=False,
+                                regex=regex,
+                                capture=capture,
+                                expect_captures=expect_captures))
+                elif entry_type == "multi_response":
+                    self.entries.append(MultiResponseGdbRemoteEntry(line))
+                elif entry_type == "output_match":
+
+                    regex = line.get("regex", None)
+                    # Compile the regex.
+                    if regex and (isinstance(regex, str)):
+                        regex = re.compile(regex, re.DOTALL)
+
+                    regex_mode = line.get("regex_mode", "match")
+                    capture = line.get("capture", None)
+                    self.entries.append(
+                        MatchRemoteOutputEntry(
+                            regex=regex,
+                            regex_mode=regex_mode,
+                            capture=capture))
+                else:
+                    raise Exception("unknown entry type \"%s\"" % entry_type)
+
+
+def process_is_running(pid, unknown_value=True):
+    """If possible, validate that the given pid represents a running process on the local system.
+
+    Args:
+
+        pid: an OS-specific representation of a process id.  Should be an integral value.
+
+        unknown_value: value used when we cannot determine how to check running local
+        processes on the OS.
+
+    Returns:
+
+        If we can figure out how to check running process ids on the given OS:
+        return True if the process is running, or False otherwise.
+
+        If we don't know how to check running process ids on the given OS:
+        return the value provided by the unknown_value arg.
+    """
+    if not isinstance(pid, six.integer_types):
+        raise Exception(
+            "pid must be an integral type (actual type: %s)" % str(
+                type(pid)))
+
+    process_ids = []
+
+    if lldb.remote_platform:
+        # Don't know how to get list of running process IDs on a remote
+        # platform
+        return unknown_value
+    elif platform.system() in ['Darwin', 'Linux', 'FreeBSD', 'NetBSD']:
+        # Build the list of running process ids
+        output = subprocess.check_output(
+            "ps ax | awk '{ print $1; }'", shell=True).decode("utf-8")
+        text_process_ids = output.split('\n')[1:]
+        # Convert text pids to ints
+        process_ids = [int(text_pid)
+                       for text_pid in text_process_ids if text_pid != '']
+    # elif {your_platform_here}:
+    #   fill in process_ids as a list of int type process IDs running on
+    #   the local system.
+    else:
+        # Don't know how to get list of running process IDs on this
+        # OS, so return the "don't know" value.
+        return unknown_value
+
+    # Check if the pid is in the process_ids
+    return pid in process_ids
+
+if __name__ == '__main__':
+    EXE_PATH = get_lldb_server_exe()
+    if EXE_PATH:
+        print("lldb-server path detected: {}".format(EXE_PATH))
+    else:
+        print("lldb-server could not be found")

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/main.cpp

+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <atomic>
+#include <chrono>
+#include <cstdlib>
+#include <cstring>
+#include <errno.h>
+#include <inttypes.h>
+#include <memory>
+#include <mutex>
+#if !defined(_WIN32)
+#include <pthread.h>
+#include <signal.h>
+#include <unistd.h>
+#endif
+#include <setjmp.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <thread>
+#include <time.h>
+#include <vector>
+
+#if defined(__APPLE__)
+__OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2)
+int pthread_threadid_np(pthread_t, __uint64_t *);
+#elif defined(__linux__)
+#include <sys/syscall.h>
+#elif defined(__NetBSD__)
+#include <lwp.h>
+#elif defined(_WIN32)
+#include <windows.h>
+#endif
+
+static const char *const RETVAL_PREFIX = "retval:";
+static const char *const SLEEP_PREFIX = "sleep:";
+static const char *const STDERR_PREFIX = "stderr:";
+static const char *const SET_MESSAGE_PREFIX = "set-message:";
+static const char *const PRINT_MESSAGE_COMMAND = "print-message:";
+static const char *const GET_DATA_ADDRESS_PREFIX = "get-data-address-hex:";
+static const char *const GET_STACK_ADDRESS_COMMAND = "get-stack-address-hex:";
+static const char *const GET_HEAP_ADDRESS_COMMAND = "get-heap-address-hex:";
+
+static const char *const GET_CODE_ADDRESS_PREFIX = "get-code-address-hex:";
+static const char *const CALL_FUNCTION_PREFIX = "call-function:";
+
+static const char *const THREAD_PREFIX = "thread:";
+static const char *const THREAD_COMMAND_NEW = "new";
+static const char *const THREAD_COMMAND_PRINT_IDS = "print-ids";
+static const char *const THREAD_COMMAND_SEGFAULT = "segfault";
+
+static const char *const PRINT_PID_COMMAND = "print-pid";
+
+static bool g_print_thread_ids = false;
+static std::mutex g_print_mutex;
+static bool g_threads_do_segfault = false;
+
+static std::mutex g_jump_buffer_mutex;
+static jmp_buf g_jump_buffer;
+static bool g_is_segfaulting = false;
+
+static char g_message[256];
+
+static volatile char g_c1 = '0';
+static volatile char g_c2 = '1';
+
+static void print_pid() {
+#if defined(_WIN32)
+  fprintf(stderr, "PID: %d\n", ::GetCurrentProcessId());
+#else
+  fprintf(stderr, "PID: %d\n", getpid());
+#endif
+}
+
+static void print_thread_id() {
+// Put in the right magic here for your platform to spit out the thread id (tid)
+// that debugserver/lldb-gdbserver would see as a TID. Otherwise, let the else
+// clause print out the unsupported text so that the unit test knows to skip
+// verifying thread ids.
+#if defined(__APPLE__)
+  __uint64_t tid = 0;
+  pthread_threadid_np(pthread_self(), &tid);
+  printf("%" PRIx64, tid);
+#elif defined(__linux__)
+  // This is a call to gettid() via syscall.
+  printf("%" PRIx64, static_cast<uint64_t>(syscall(__NR_gettid)));
+#elif defined(__NetBSD__)
+  // Technically lwpid_t is 32-bit signed integer
+  printf("%" PRIx64, static_cast<uint64_t>(_lwp_self()));
+#elif defined(_WIN32)
+  printf("%" PRIx64, static_cast<uint64_t>(::GetCurrentThreadId()));
+#else
+  printf("{no-tid-support}");
+#endif
+}
+
+static void signal_handler(int signo) {
+#if defined(_WIN32)
+  // No signal support on Windows.
+#else
+  const char *signal_name = nullptr;
+  switch (signo) {
+  case SIGUSR1:
+    signal_name = "SIGUSR1";
+    break;
+  case SIGSEGV:
+    signal_name = "SIGSEGV";
+    break;
+  default:
+    signal_name = nullptr;
+  }
+
+  // Print notice that we received the signal on a given thread.
+  {
+    std::lock_guard<std::mutex> lock(g_print_mutex);
+    if (signal_name)
+      printf("received %s on thread id: ", signal_name);
+    else
+      printf("received signo %d (%s) on thread id: ", signo, strsignal(signo));
+    print_thread_id();
+    printf("\n");
+  }
+
+  // Reset the signal handler if we're one of the expected signal handlers.
+  switch (signo) {
+  case SIGSEGV:
+    if (g_is_segfaulting) {
+      // Fix up the pointer we're writing to.  This needs to happen if nothing
+      // intercepts the SIGSEGV (i.e. if somebody runs this from the command
+      // line).
+      longjmp(g_jump_buffer, 1);
+    }
+    break;
+  case SIGUSR1:
+    if (g_is_segfaulting) {
+      // Fix up the pointer we're writing to.  This is used to test gdb remote
+      // signal delivery. A SIGSEGV will be raised when the thread is created,
+      // switched out for a SIGUSR1, and then this code still needs to fix the
+      // seg fault. (i.e. if somebody runs this from the command line).
+      longjmp(g_jump_buffer, 1);
+    }
+    break;
+  }
+
+  // Reset the signal handler.
+  sig_t sig_result = signal(signo, signal_handler);
+  if (sig_result == SIG_ERR) {
+    fprintf(stderr, "failed to set signal handler: errno=%d\n", errno);
+    exit(1);
+  }
+#endif
+}
+
+static void swap_chars() {
+  g_c1 = '1';
+  g_c2 = '0';
+
+  g_c1 = '0';
+  g_c2 = '1';
+}
+
+static void hello() {
+  std::lock_guard<std::mutex> lock(g_print_mutex);
+  printf("hello, world\n");
+}
+
+static void *thread_func(void *arg) {
+  static std::atomic<int> s_thread_index(1);
+  const int this_thread_index = s_thread_index++;
+  if (g_print_thread_ids) {
+    std::lock_guard<std::mutex> lock(g_print_mutex);
+    printf("thread %d id: ", this_thread_index);
+    print_thread_id();
+    printf("\n");
+  }
+
+  if (g_threads_do_segfault) {
+    // Sleep for a number of seconds based on the thread index.
+    // TODO add ability to send commands to test exe so we can
+    // handle timing more precisely.  This is clunky.  All we're
+    // trying to do is add predictability as to the timing of
+    // signal generation by created threads.
+    int sleep_seconds = 2 * (this_thread_index - 1);
+    std::this_thread::sleep_for(std::chrono::seconds(sleep_seconds));
+
+    // Test creating a SEGV.
+    {
+      std::lock_guard<std::mutex> lock(g_jump_buffer_mutex);
+      g_is_segfaulting = true;
+      int *bad_p = nullptr;
+      if (setjmp(g_jump_buffer) == 0) {
+        // Force a seg fault signal on this thread.
+        *bad_p = 0;
+      } else {
+        // Tell the system we're no longer seg faulting.
+        // Used by the SIGUSR1 signal handler that we inject
+        // in place of the SIGSEGV so it only tries to
+        // recover from the SIGSEGV if this seg fault code
+        // was in play.
+        g_is_segfaulting = false;
+      }
+    }
+
+    {
+      std::lock_guard<std::mutex> lock(g_print_mutex);
+      printf("thread ");
+      print_thread_id();
+      printf(": past SIGSEGV\n");
+    }
+  }
+
+  int sleep_seconds_remaining = 60;
+  std::this_thread::sleep_for(std::chrono::seconds(sleep_seconds_remaining));
+
+  return nullptr;
+}
+
+int main(int argc, char **argv) {
+  lldb_enable_attach();
+
+  std::vector<std::thread> threads;
+  std::unique_ptr<uint8_t[]> heap_array_up;
+  int return_value = 0;
+
+#if !defined(_WIN32)
+  // Set the signal handler.
+  sig_t sig_result = signal(SIGALRM, signal_handler);
+  if (sig_result == SIG_ERR) {
+    fprintf(stderr, "failed to set SIGALRM signal handler: errno=%d\n", errno);
+    exit(1);
+  }
+
+  sig_result = signal(SIGUSR1, signal_handler);
+  if (sig_result == SIG_ERR) {
+    fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno);
+    exit(1);
+  }
+
+  sig_result = signal(SIGSEGV, signal_handler);
+  if (sig_result == SIG_ERR) {
+    fprintf(stderr, "failed to set SIGUSR1 handler: errno=%d\n", errno);
+    exit(1);
+  }
+#endif
+
+  // Process command line args.
+  for (int i = 1; i < argc; ++i) {
+    if (std::strstr(argv[i], STDERR_PREFIX)) {
+      // Treat remainder as text to go to stderr.
+      fprintf(stderr, "%s\n", (argv[i] + strlen(STDERR_PREFIX)));
+    } else if (std::strstr(argv[i], RETVAL_PREFIX)) {
+      // Treat as the return value for the program.
+      return_value = std::atoi(argv[i] + strlen(RETVAL_PREFIX));
+    } else if (std::strstr(argv[i], SLEEP_PREFIX)) {
+      // Treat as the amount of time to have this process sleep (in seconds).
+      int sleep_seconds_remaining = std::atoi(argv[i] + strlen(SLEEP_PREFIX));
+
+      // Loop around, sleeping until all sleep time is used up.  Note that
+      // signals will cause sleep to end early with the number of seconds
+      // remaining.
+      std::this_thread::sleep_for(
+          std::chrono::seconds(sleep_seconds_remaining));
+
+    } else if (std::strstr(argv[i], SET_MESSAGE_PREFIX)) {
+      // Copy the contents after "set-message:" to the g_message buffer.
+      // Used for reading inferior memory and verifying contents match
+      // expectations.
+      strncpy(g_message, argv[i] + strlen(SET_MESSAGE_PREFIX),
+              sizeof(g_message));
+
+      // Ensure we're null terminated.
+      g_message[sizeof(g_message) - 1] = '\0';
+
+    } else if (std::strstr(argv[i], PRINT_MESSAGE_COMMAND)) {
+      std::lock_guard<std::mutex> lock(g_print_mutex);
+      printf("message: %s\n", g_message);
+    } else if (std::strstr(argv[i], GET_DATA_ADDRESS_PREFIX)) {
+      volatile void *data_p = nullptr;
+
+      if (std::strstr(argv[i] + strlen(GET_DATA_ADDRESS_PREFIX), "g_message"))
+        data_p = &g_message[0];
+      else if (std::strstr(argv[i] + strlen(GET_DATA_ADDRESS_PREFIX), "g_c1"))
+        data_p = &g_c1;
+      else if (std::strstr(argv[i] + strlen(GET_DATA_ADDRESS_PREFIX), "g_c2"))
+        data_p = &g_c2;
+
+      std::lock_guard<std::mutex> lock(g_print_mutex);
+      printf("data address: %p\n", data_p);
+    } else if (std::strstr(argv[i], GET_HEAP_ADDRESS_COMMAND)) {
+      // Create a byte array if not already present.
+      if (!heap_array_up)
+        heap_array_up.reset(new uint8_t[32]);
+
+      std::lock_guard<std::mutex> lock(g_print_mutex);
+      printf("heap address: %p\n", heap_array_up.get());
+
+    } else if (std::strstr(argv[i], GET_STACK_ADDRESS_COMMAND)) {
+      std::lock_guard<std::mutex> lock(g_print_mutex);
+      printf("stack address: %p\n", &return_value);
+    } else if (std::strstr(argv[i], GET_CODE_ADDRESS_PREFIX)) {
+      void (*func_p)() = nullptr;
+
+      if (std::strstr(argv[i] + strlen(GET_CODE_ADDRESS_PREFIX), "hello"))
+        func_p = hello;
+      else if (std::strstr(argv[i] + strlen(GET_CODE_ADDRESS_PREFIX),
+                           "swap_chars"))
+        func_p = swap_chars;
+
+      std::lock_guard<std::mutex> lock(g_print_mutex);
+      printf("code address: %p\n", func_p);
+    } else if (std::strstr(argv[i], CALL_FUNCTION_PREFIX)) {
+      void (*func_p)() = nullptr;
+
+      // Defaut to providing the address of main.
+      if (std::strcmp(argv[i] + strlen(CALL_FUNCTION_PREFIX), "hello") == 0)
+        func_p = hello;
+      else if (std::strcmp(argv[i] + strlen(CALL_FUNCTION_PREFIX),
+                           "swap_chars") == 0)
+        func_p = swap_chars;
+      else {
+        std::lock_guard<std::mutex> lock(g_print_mutex);
+        printf("unknown function: %s\n",
+               argv[i] + strlen(CALL_FUNCTION_PREFIX));
+      }
+      if (func_p)
+        func_p();
+    } else if (std::strstr(argv[i], THREAD_PREFIX)) {
+      // Check if we're creating a new thread.
+      if (std::strstr(argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_NEW)) {
+        threads.push_back(std::thread(thread_func, nullptr));
+      } else if (std::strstr(argv[i] + strlen(THREAD_PREFIX),
+                             THREAD_COMMAND_PRINT_IDS)) {
+        // Turn on thread id announcing.
+        g_print_thread_ids = true;
+
+        // And announce us.
+        {
+          std::lock_guard<std::mutex> lock(g_print_mutex);
+          printf("thread 0 id: ");
+          print_thread_id();
+          printf("\n");
+        }
+      } else if (std::strstr(argv[i] + strlen(THREAD_PREFIX),
+                             THREAD_COMMAND_SEGFAULT)) {
+        g_threads_do_segfault = true;
+      } else {
+        // At this point we don't do anything else with threads.
+        // Later use thread index and send command to thread.
+      }
+    } else if (std::strstr(argv[i], PRINT_PID_COMMAND)) {
+      print_pid();
+    } else {
+      // Treat the argument as text for stdout.
+      printf("%s\n", argv[i]);
+    }
+  }
+
+  // If we launched any threads, join them
+  for (std::vector<std::thread>::iterator it = threads.begin();
+       it != threads.end(); ++it)
+    it->join();
+
+  return return_value;
+}

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/platform-process-connect/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/platform-process-connect/TestPlatformProcessConnect.py

+from __future__ import print_function
+
+import time
+
+import gdbremote_testcase
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestPlatformProcessConnect(gdbremote_testcase.GdbRemoteTestCaseBase):
+    mydir = TestBase.compute_mydir(__file__)
+
+    @llgs_test
+    @no_debug_info_test
+    @skipIf(remote=False)
+    @expectedFailureAll(hostoslist=["windows"], triple='.*-android')
+    def test_platform_process_connect(self):
+        self.build()
+        self.init_llgs_test(False)
+
+        working_dir = lldb.remote_platform.GetWorkingDirectory()
+        src = lldb.SBFileSpec(self.getBuildArtifact("a.out"))
+        dest = lldb.SBFileSpec(os.path.join(working_dir, "a.out"))
+        err = lldb.remote_platform.Put(src, dest)
+        if err.Fail():
+            raise RuntimeError(
+                "Unable copy '%s' to '%s'.\n>>> %s" %
+                (f, wd, err.GetCString()))
+
+        m = re.search("^(.*)://([^:/]*)", configuration.lldb_platform_url)
+        protocol = m.group(1)
+        hostname = m.group(2)
+        unix_protocol = protocol.startswith("unix-")
+        if unix_protocol:
+            p = re.search("^(.*)-connect", protocol)
+            path = lldbutil.join_remote_paths(configuration.lldb_platform_working_dir,
+                    self.getBuildDirBasename(), "platform-%d.sock" % int(time.time()))
+            listen_url = "%s://%s" % (p.group(1), path)
+        else:
+            listen_url = "*:0"
+
+        port_file = "%s/port" % working_dir
+        commandline_args = [
+            "platform",
+            "--listen",
+            listen_url,
+            "--socket-file",
+            port_file,
+            "--",
+            "%s/a.out" %
+            working_dir,
+            "foo"]
+        self.spawnSubprocess(
+            self.debug_monitor_exe,
+            commandline_args,
+            install_remote=False)
+        self.addTearDownHook(self.cleanupSubprocesses)
+
+        socket_id = lldbutil.wait_for_file_on_target(self, port_file)
+
+        new_debugger = lldb.SBDebugger.Create()
+        new_debugger.SetAsync(False)
+
+        def del_debugger(new_debugger=new_debugger):
+            del new_debugger
+        self.addTearDownHook(del_debugger)
+
+        new_platform = lldb.SBPlatform(lldb.remote_platform.GetName())
+        new_debugger.SetSelectedPlatform(new_platform)
+        new_interpreter = new_debugger.GetCommandInterpreter()
+
+        if unix_protocol:
+            connect_url = "%s://%s%s" % (protocol, hostname, socket_id)
+        else:
+            connect_url = "%s://%s:%s" % (protocol, hostname, socket_id)
+
+        command = "platform connect %s" % (connect_url)
+        result = lldb.SBCommandReturnObject()
+        new_interpreter.HandleCommand(command, result)
+        self.assertTrue(
+            result.Succeeded(),
+            "platform process connect failed: %s" %
+            result.GetOutput())
+
+        target = new_debugger.GetSelectedTarget()
+        process = target.GetProcess()
+        thread = process.GetThreadAtIndex(0)
+
+        breakpoint = target.BreakpointCreateByName("main")
+        process.Continue()
+
+        frame = thread.GetFrameAtIndex(0)
+        self.assertEqual(frame.GetFunction().GetName(), "main")
+        self.assertEqual(frame.FindVariable("argc").GetValueAsSigned(), 2)
+        process.Continue()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/platform-process-connect/main.cpp

+#include <cstdio>
+
+int main(int argc, char **argv) {
+  printf("argc: %d\n", argc);
+  return argv[0][0];
+}

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/register-reading/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/register-reading/TestGdbRemoteGPacket.py

+from __future__ import print_function
+
+
+import gdbremote_testcase
+import textwrap
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+def _extract_register_value(reg_info, reg_bank, byte_order, bytes_per_entry=8):
+    reg_offset = int(reg_info["offset"])*2
+    reg_byte_size = int(2 * int(reg_info["bitsize"]) / 8)
+    # Create slice with the contents of the register.
+    reg_slice = reg_bank[reg_offset:reg_offset+reg_byte_size]
+
+    reg_value = []
+    # Wrap slice according to bytes_per_entry.
+    for entry in textwrap.wrap(reg_slice, 2 * bytes_per_entry):
+        # Invert the bytes order if target uses little-endian.
+        if byte_order == lldb.eByteOrderLittle:
+            entry = "".join(reversed([entry[i:i+2] for i in range(0,
+                                          len(entry),2)]))
+        reg_value.append("0x" + entry)
+
+    return reg_value
+
+
+class TestGdbRemoteGPacket(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def run_test_g_packet(self):
+        self.build()
+        self.prep_debug_monitor_and_inferior()
+        self.test_sequence.add_log_lines(
+            ["read packet: $g#67",
+             {"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$",
+              "capture": {1: "register_bank"}}],
+            True)
+        self.connect_to_debug_monitor()
+        context = self.expect_gdbremote_sequence()
+        register_bank = context.get("register_bank")
+        self.assertTrue(register_bank[0] != 'E')
+
+        self.test_sequence.add_log_lines(
+            ["read packet: $G" + register_bank + "#00",
+             {"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$",
+              "capture": {1: "G_reply"}}],
+            True)
+        context = self.expect_gdbremote_sequence()
+        self.assertTrue(context.get("G_reply")[0] != 'E')
+
+    @skipIfOutOfTreeDebugserver
+    @debugserver_test
+    @skipIfDarwinEmbedded
+    def test_g_packet_debugserver(self):
+        self.init_debugserver_test()
+        self.run_test_g_packet()
+
+    @skipIf(archs=no_match(["x86_64"]))
+    def g_returns_correct_data(self, with_suffix):
+        procs = self.prep_debug_monitor_and_inferior()
+
+        self.add_register_info_collection_packets()
+        if with_suffix:
+            self.add_thread_suffix_request_packets()
+        self.add_threadinfo_collection_packets()
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Gather register info.
+        reg_infos = self.parse_register_info_packets(context)
+        self.assertIsNotNone(reg_infos)
+        self.add_lldb_register_index(reg_infos)
+        # Index register info entries by name.
+        reg_infos = {info['name']: info for info in reg_infos}
+
+        # Gather thread info.
+        if with_suffix:
+            threads = self.parse_threadinfo_packets(context)
+            self.assertIsNotNone(threads)
+            thread_id = threads[0]
+            self.assertIsNotNone(thread_id)
+        else:
+            thread_id = None
+
+        # Send vCont packet to resume the inferior.
+        self.test_sequence.add_log_lines(["read packet: $vCont;c#a8",
+                                          {"direction": "send",
+                                           "regex": r"^\$T([0-9a-fA-F]{2}).*#[0-9a-fA-F]{2}$",
+                                           "capture": {1: "hex_exit_code"}},
+                                          ],
+                                         True)
+
+        # Send g packet to retrieve the register bank
+        if thread_id:
+            g_request = "read packet: $g;thread:{:x}#00".format(thread_id)
+        else:
+            g_request = "read packet: $g#00"
+        self.test_sequence.add_log_lines(
+            [g_request,
+             {"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$",
+              "capture": {1: "register_bank"}}],
+            True)
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+        reg_bank = context.get("register_bank")
+        self.assertTrue(reg_bank[0] != 'E')
+
+        byte_order = self.get_target_byte_order()
+        get_reg_value = lambda reg_name : _extract_register_value(
+            reg_infos[reg_name], reg_bank, byte_order)
+
+        self.assertEqual(['0x0102030405060708'], get_reg_value('r8'))
+        self.assertEqual(['0x1112131415161718'], get_reg_value('r9'))
+        self.assertEqual(['0x2122232425262728'], get_reg_value('r10'))
+        self.assertEqual(['0x3132333435363738'], get_reg_value('r11'))
+        self.assertEqual(['0x4142434445464748'], get_reg_value('r12'))
+        self.assertEqual(['0x5152535455565758'], get_reg_value('r13'))
+        self.assertEqual(['0x6162636465666768'], get_reg_value('r14'))
+        self.assertEqual(['0x7172737475767778'], get_reg_value('r15'))
+
+        self.assertEqual(
+            ['0x020406080a0c0e01', '0x030507090b0d0f00'], get_reg_value('xmm8'))
+        self.assertEqual(
+            ['0x121416181a1c1e11', '0x131517191b1d1f10'], get_reg_value('xmm9'))
+        self.assertEqual(
+            ['0x222426282a2c2e21', '0x232527292b2d2f20'], get_reg_value('xmm10'))
+        self.assertEqual(
+            ['0x323436383a3c3e31', '0x333537393b3d3f30'], get_reg_value('xmm11'))
+        self.assertEqual(
+            ['0x424446484a4c4e41', '0x434547494b4d4f40'], get_reg_value('xmm12'))
+        self.assertEqual(
+            ['0x525456585a5c5e51', '0x535557595b5d5f50'], get_reg_value('xmm13'))
+        self.assertEqual(
+            ['0x626466686a6c6e61', '0x636567696b6d6f60'], get_reg_value('xmm14'))
+        self.assertEqual(
+            ['0x727476787a7c7e71', '0x737577797b7d7f70'], get_reg_value('xmm15'))
+
+    @llgs_test
+    def test_g_returns_correct_data_with_suffix_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.g_returns_correct_data(True)
+
+    @llgs_test
+    def test_g_returns_correct_data_no_suffix_llgs(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.g_returns_correct_data(False)

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/register-reading/main.cpp

+#include <cstdint>
+
+struct alignas(16) xmm_t {
+  uint64_t a, b;
+};
+
+int main() {
+  uint64_t r8 = 0x0102030405060708;
+  uint64_t r9 = 0x1112131415161718;
+  uint64_t r10 = 0x2122232425262728;
+  uint64_t r11 = 0x3132333435363738;
+  uint64_t r12 = 0x4142434445464748;
+  uint64_t r13 = 0x5152535455565758;
+  uint64_t r14 = 0x6162636465666768;
+  uint64_t r15 = 0x7172737475767778;
+
+  xmm_t xmm8 = {0x020406080A0C0E01, 0x030507090B0D0F00};
+  xmm_t xmm9 = {0x121416181A1C1E11, 0x131517191B1D1F10};
+  xmm_t xmm10 = {0x222426282A2C2E21, 0x232527292B2D2F20};
+  xmm_t xmm11 = {0x323436383A3C3E31, 0x333537393B3D3F30};
+  xmm_t xmm12 = {0x424446484A4C4E41, 0x434547494B4D4F40};
+  xmm_t xmm13 = {0x525456585A5C5E51, 0x535557595B5D5F50};
+  xmm_t xmm14 = {0x626466686A6C6E61, 0x636567696B6D6F60};
+  xmm_t xmm15 = {0x727476787A7C7E71, 0x737577797B7D7F70};
+
+  asm volatile("movq    %0, %%r8\n\t"
+               "movq    %1, %%r9\n\t"
+               "movq    %2, %%r10\n\t"
+               "movq    %3, %%r11\n\t"
+               "movq    %4, %%r12\n\t"
+               "movq    %5, %%r13\n\t"
+               "movq    %6, %%r14\n\t"
+               "movq    %7, %%r15\n\t"
+               "\n\t"
+               "movaps  %8, %%xmm8\n\t"
+               "movaps  %9, %%xmm9\n\t"
+               "movaps  %10, %%xmm10\n\t"
+               "movaps  %11, %%xmm11\n\t"
+               "movaps  %12, %%xmm12\n\t"
+               "movaps  %13, %%xmm13\n\t"
+               "movaps  %14, %%xmm14\n\t"
+               "movaps  %15, %%xmm15\n\t"
+               "\n\t"
+               "int3"
+               :
+               : "g"(r8), "g"(r9), "g"(r10), "g"(r11), "g"(r12), "g"(r13),
+                 "g"(r14), "g"(r15), "m"(xmm8), "m"(xmm9), "m"(xmm10),
+                 "m"(xmm11), "m"(xmm12), "m"(xmm13), "m"(xmm14), "m"(xmm15)
+               : "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15",
+                 "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13",
+                 "%xmm14", "%xmm15");
+
+  return 0;
+}

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/signal-filtering/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/signal-filtering/TestGdbRemote_QPassSignals.py

+# This test makes sure that lldb-server supports and properly handles
+# QPassSignals GDB protocol package.
+from __future__ import print_function
+
+import gdbremote_testcase
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestGdbRemote_QPassSignals(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def expect_signal(self, expected_signo):
+        self.test_sequence.add_log_lines(["read packet: $vCont;c#a8",
+                                          {"direction": "send",
+                                           "regex": r"^\$T([0-9a-fA-F]{2}).*#[0-9a-fA-F]{2}$",
+                                           "capture": {1: "hex_exit_code"}},
+                                          ],
+                                         True)
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        hex_exit_code = context.get("hex_exit_code")
+        self.assertIsNotNone(hex_exit_code)
+        self.assertEqual(int(hex_exit_code, 16), expected_signo)
+
+    def expect_exit_code(self, exit_code):
+        self.test_sequence.add_log_lines(
+            ["read packet: $vCont;c#a8",
+             "send packet: $W{0:02x}#00".format(exit_code)],
+            True)
+        self.expect_gdbremote_sequence()
+
+
+    def ignore_signals(self, signals):
+        def signal_name_to_hex(signame):
+            return format(lldbutil.get_signal_number(signame), 'x')
+        signals_str = ";".join(map(signal_name_to_hex, signals))
+
+        self.test_sequence.add_log_lines(["read packet: $QPassSignals:"
+                                          + signals_str + " #00",
+                                          "send packet: $OK#00"],
+                                         True)
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+    @llgs_test
+    @skipUnlessPlatform(["linux", "android"])
+    def test_q_pass_signals(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        procs = self.prep_debug_monitor_and_inferior()
+        expected_signals = ["SIGSEGV",
+            "SIGALRM", "SIGFPE", "SIGBUS", "SIGINT", "SIGHUP"]
+        signals_to_ignore = ["SIGUSR1", "SIGUSR2"]
+        self.ignore_signals(signals_to_ignore)
+        for signal_name in expected_signals:
+            signo = lldbutil.get_signal_number(signal_name)
+            self.expect_signal(signo)
+        self.expect_exit_code(len(signals_to_ignore))
+
+    @llgs_test
+    @skipUnlessPlatform(["linux", "android"])
+    def test_change_signals_at_runtime(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        procs = self.prep_debug_monitor_and_inferior()
+        expected_signals = ["SIGSEGV", "SIGUSR1", "SIGUSR2",
+            "SIGALRM", "SIGHUP"]
+        signals_to_ignore = ["SIGFPE", "SIGBUS", "SIGINT"]
+
+        for signal_name in expected_signals:
+            signo = lldbutil.get_signal_number(signal_name)
+            self.expect_signal(signo)
+            if signal_name == "SIGALRM":
+                self.ignore_signals(signals_to_ignore)
+        self.expect_exit_code(len(signals_to_ignore))
+
+    @llgs_test
+    def test_default_signals_behavior(self):
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        procs = self.prep_debug_monitor_and_inferior()
+        expected_signals = ["SIGSEGV", "SIGUSR1", "SIGUSR2",
+            "SIGALRM", "SIGFPE", "SIGBUS", "SIGINT", "SIGHUP"]
+        for signal_name in expected_signals:
+            signo = lldbutil.get_signal_number(signal_name)
+            self.expect_signal(signo)
+        self.expect_exit_code(0)
+
+
+    @llgs_test
+    @skipUnlessPlatform(["linux", "android"])
+    def test_support_q_pass_signals(self):
+        self.init_llgs_test()
+        self.build()
+
+        # Start up the stub and start/prep the inferior.
+        self.set_inferior_startup_launch()
+        procs = self.prep_debug_monitor_and_inferior()
+        self.add_qSupported_packets()
+
+        # Run the packet stream.
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        # Retrieve the qSupported features and check QPassSignals+
+        supported_dict = self.parse_qSupported_response(context)
+        self.assertEqual(supported_dict["QPassSignals"], "+")

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/signal-filtering/main.cpp

+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <signal.h>
+#include <stdio.h>
+#include <vector>
+
+static int signal_counter = 0;
+
+static void count_signal(int signo) {
+  ++signal_counter;
+  printf("Signal %d\n", signo);
+}
+
+static void raise_signals() {
+  std::vector<int> signals(
+      {SIGSEGV, SIGUSR1, SIGUSR2, SIGALRM, SIGFPE, SIGBUS, SIGINT, SIGHUP});
+
+  for (int signal_num : signals) {
+    signal(signal_num, count_signal);
+  }
+
+  for (int signal_num : signals) {
+    raise(signal_num);
+  }
+}
+
+int main() {
+  raise_signals();
+  return signal_counter;
+}

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/socket_packet_pump.py

+
+from __future__ import print_function
+
+
+import re
+import select
+import threading
+import traceback
+import codecs
+
+from six.moves import queue
+from lldbsuite.support import seven
+
+
+def _handle_output_packet_string(packet_contents):
+    if (not packet_contents) or (len(packet_contents) < 1):
+        return None
+    elif packet_contents[0] != "O":
+        return None
+    elif packet_contents == "OK":
+        return None
+    else:
+        return seven.unhexlify(packet_contents[1:])
+
+
+def _dump_queue(the_queue):
+    while not the_queue.empty():
+        print(codecs.encode(the_queue.get(True), "string_escape"))
+        print("\n")
+
+
+class PumpQueues(object):
+
+    def __init__(self):
+        self._output_queue = queue.Queue()
+        self._packet_queue = queue.Queue()
+
+    def output_queue(self):
+        return self._output_queue
+
+    def packet_queue(self):
+        return self._packet_queue
+
+    def verify_queues_empty(self):
+        # Warn if there is any content left in any of the queues.
+        # That would represent unmatched packets.
+        if not self.output_queue().empty():
+            print("warning: output queue entries still exist:")
+            _dump_queue(self.output_queue())
+            print("from here:")
+            traceback.print_stack()
+
+        if not self.packet_queue().empty():
+            print("warning: packet queue entries still exist:")
+            _dump_queue(self.packet_queue())
+            print("from here:")
+            traceback.print_stack()
+
+
+class SocketPacketPump(object):
+    """A threaded packet reader that partitions packets into two streams.
+
+    All incoming $O packet content is accumulated with the current accumulation
+    state put into the OutputQueue.
+
+    All other incoming packets are placed in the packet queue.
+
+    A select thread can be started and stopped, and runs to place packet
+    content into the two queues.
+    """
+
+    _GDB_REMOTE_PACKET_REGEX = re.compile(r'^\$([^\#]*)#[0-9a-fA-F]{2}')
+
+    def __init__(self, pump_socket, pump_queues, logger=None):
+        if not pump_socket:
+            raise Exception("pump_socket cannot be None")
+
+        self._thread = None
+        self._stop_thread = False
+        self._socket = pump_socket
+        self._logger = logger
+        self._receive_buffer = ""
+        self._accumulated_output = ""
+        self._pump_queues = pump_queues
+
+    def __enter__(self):
+        """Support the python 'with' statement.
+
+        Start the pump thread."""
+        self.start_pump_thread()
+        return self
+
+    def __exit__(self, exit_type, value, the_traceback):
+        """Support the python 'with' statement.
+
+        Shut down the pump thread."""
+        self.stop_pump_thread()
+
+    def start_pump_thread(self):
+        if self._thread:
+            raise Exception("pump thread is already running")
+        self._stop_thread = False
+        self._thread = threading.Thread(target=self._run_method)
+        self._thread.start()
+
+    def stop_pump_thread(self):
+        self._stop_thread = True
+        if self._thread:
+            self._thread.join()
+
+    def _process_new_bytes(self, new_bytes):
+        if not new_bytes:
+            return
+        if len(new_bytes) < 1:
+            return
+
+        # Add new bytes to our accumulated unprocessed packet bytes.
+        self._receive_buffer += new_bytes
+
+        # Parse fully-formed packets into individual packets.
+        has_more = len(self._receive_buffer) > 0
+        while has_more:
+            if len(self._receive_buffer) <= 0:
+                has_more = False
+            # handle '+' ack
+            elif self._receive_buffer[0] == "+":
+                self._pump_queues.packet_queue().put("+")
+                self._receive_buffer = self._receive_buffer[1:]
+                if self._logger:
+                    self._logger.debug(
+                        "parsed packet from stub: +\n" +
+                        "new receive_buffer: {}".format(
+                            self._receive_buffer))
+            else:
+                packet_match = self._GDB_REMOTE_PACKET_REGEX.match(
+                    self._receive_buffer)
+                if packet_match:
+                    # Our receive buffer matches a packet at the
+                    # start of the receive buffer.
+                    new_output_content = _handle_output_packet_string(
+                        packet_match.group(1))
+                    if new_output_content:
+                        # This was an $O packet with new content.
+                        self._accumulated_output += new_output_content
+                        self._pump_queues.output_queue().put(self._accumulated_output)
+                    else:
+                        # Any packet other than $O.
+                        self._pump_queues.packet_queue().put(packet_match.group(0))
+
+                    # Remove the parsed packet from the receive
+                    # buffer.
+                    self._receive_buffer = self._receive_buffer[
+                        len(packet_match.group(0)):]
+                    if self._logger:
+                        self._logger.debug(
+                            "parsed packet from stub: " +
+                            packet_match.group(0))
+                        self._logger.debug(
+                            "new receive_buffer: " +
+                            self._receive_buffer)
+                else:
+                    # We don't have enough in the receive bufferto make a full
+                    # packet. Stop trying until we read more.
+                    has_more = False
+
+    def _run_method(self):
+        self._receive_buffer = ""
+        self._accumulated_output = ""
+
+        if self._logger:
+            self._logger.info("socket pump starting")
+
+        # Keep looping around until we're asked to stop the thread.
+        while not self._stop_thread:
+            can_read, _, _ = select.select([self._socket], [], [], 0)
+            if can_read and self._socket in can_read:
+                try:
+                    new_bytes = seven.bitcast_to_string(self._socket.recv(4096))
+                    if self._logger and new_bytes and len(new_bytes) > 0:
+                        self._logger.debug(
+                            "pump received bytes: {}".format(new_bytes))
+                except:
+                    # Likely a closed socket.  Done with the pump thread.
+                    if self._logger:
+                        self._logger.debug(
+                            "socket read failed, stopping pump read thread\n" +
+                            traceback.format_exc(3))
+                    break
+                self._process_new_bytes(new_bytes)
+
+        if self._logger:
+            self._logger.info("socket pump exiting")
+
+    def get_accumulated_output(self):
+        return self._accumulated_output
+
+    def get_receive_buffer(self):
+        return self._receive_buffer

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/test/test_lldbgdbserverutils.py

+from __future__ import print_function
+
+
+import unittest2
+import os.path
+import re
+import sys
+
+from lldbgdbserverutils import *
+
+
+class TestLldbGdbServerUtils(unittest2.TestCase):
+
+    def test_entry_exact_payload_match(self):
+        entry = GdbRemoteEntry(is_send_to_remote=False, exact_payload="$OK#9a")
+        entry.assert_match(self, "$OK#9a")
+
+    def test_entry_exact_payload_match_ignores_checksum(self):
+        entry = GdbRemoteEntry(is_send_to_remote=False, exact_payload="$OK#9a")
+        entry.assert_match(self, "$OK#00")
+
+    def test_entry_creates_context(self):
+        entry = GdbRemoteEntry(is_send_to_remote=False, exact_payload="$OK#9a")
+        context = entry.assert_match(self, "$OK#9a")
+        self.assertIsNotNone(context)
+
+    def test_entry_regex_matches(self):
+        entry = GdbRemoteEntry(
+            is_send_to_remote=False,
+            regex=re.compile(r"^\$QC([0-9a-fA-F]+)#"),
+            capture={
+                1: "thread_id"})
+        context = entry.assert_match(self, "$QC980#00")
+
+    def test_entry_regex_saves_match(self):
+        entry = GdbRemoteEntry(
+            is_send_to_remote=False,
+            regex=re.compile(r"^\$QC([0-9a-fA-F]+)#"),
+            capture={
+                1: "thread_id"})
+        context = entry.assert_match(self, "$QC980#00")
+        self.assertEqual(context["thread_id"], "980")
+
+    def test_entry_regex_expect_captures_success(self):
+        context = {"thread_id": "980"}
+        entry = GdbRemoteEntry(
+            is_send_to_remote=False,
+            regex=re.compile(r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+)"),
+            expect_captures={
+                2: "thread_id"})
+        entry.assert_match(self, "$T11thread:980;", context=context)
+
+    def test_entry_regex_expect_captures_raises_on_fail(self):
+        context = {"thread_id": "980"}
+        entry = GdbRemoteEntry(
+            is_send_to_remote=False,
+            regex=re.compile(r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+)"),
+            expect_captures={
+                2: "thread_id"})
+        try:
+            entry.assert_match(self, "$T11thread:970;", context=context)
+            self.fail()
+        except AssertionError:
+            # okay
+            return None

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/thread-name/Makefile

+LEVEL = ../../../make
+
+ENABLE_THREADS := YES
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/thread-name/TestGdbRemoteThreadName.py

+from __future__ import print_function
+
+import gdbremote_testcase
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestGdbRemoteThreadName(gdbremote_testcase.GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def run_and_check_name(self, expected_name):
+        self.test_sequence.add_log_lines(["read packet: $vCont;c#a8",
+                                          {"direction": "send",
+                                           "regex":
+                                           r"^\$T([0-9a-fA-F]{2})([^#]+)#[0-9a-fA-F]{2}$",
+                                           "capture": {
+                                               1: "signal",
+                                               2: "key_vals_text"}},
+                                          ],
+                                         True)
+
+        context = self.expect_gdbremote_sequence()
+        self.assertIsNotNone(context)
+
+        sigint = lldbutil.get_signal_number("SIGINT")
+        self.assertEqual(sigint, int(context.get("signal"), 16))
+        kv_dict = self.parse_key_val_dict(context.get("key_vals_text"))
+        self.assertEqual(expected_name, kv_dict.get("name"))
+
+    @llgs_test
+    def test(self):
+        """ Make sure lldb-server can retrieve inferior thread name"""
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        procs = self.prep_debug_monitor_and_inferior()
+
+        self.run_and_check_name("hello world")
+        self.run_and_check_name("goodbye world")

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/thread-name/main.cpp

+#include <pthread.h>
+#include <signal.h>
+
+void set_thread_name(const char *name) {
+#if defined(__APPLE__)
+  ::pthread_setname_np(name);
+#elif defined(__FreeBSD__)
+  ::pthread_set_name_np(::pthread_self(), name);
+#elif defined(__linux__)
+  ::pthread_setname_np(::pthread_self(), name);
+#elif defined(__NetBSD__)
+  ::pthread_setname_np(::pthread_self(), "%s", name);
+#endif
+}
+
+int main() {
+  set_thread_name("hello world");
+  raise(SIGINT);
+  set_thread_name("goodbye world");
+  raise(SIGINT);
+  return 0;
+}

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/.categories

+lldb-vscode

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/attach/Makefile

+LEVEL = ../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/attach/TestVSCode_attach.py

+"""
+Test lldb-vscode setBreakpoints request
+"""
+
+from __future__ import print_function
+
+import unittest2
+import vscode
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import lldbvscode_testcase
+import os
+import shutil
+import subprocess
+import tempfile
+import threading
+import time
+
+
+def spawn_and_wait(program, delay):
+    if delay:
+        time.sleep(delay)
+    process = subprocess.Popen([program],
+                               stdin=subprocess.PIPE,
+                               stdout=subprocess.PIPE,
+                               stderr=subprocess.PIPE)
+    process.wait()
+
+
+class TestVSCode_attach(lldbvscode_testcase.VSCodeTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def set_and_hit_breakpoint(self, continueToExit=True):
+        source = 'main.c'
+        breakpoint1_line = line_number(source, '// breakpoint 1')
+        lines = [breakpoint1_line]
+        # Set breakoint in the thread function so we can step the threads
+        breakpoint_ids = self.set_source_breakpoints(source, lines)
+        self.assertEqual(len(breakpoint_ids), len(lines),
+                         "expect correct number of breakpoints")
+        self.continue_to_breakpoints(breakpoint_ids)
+        if continueToExit:
+            self.continue_to_exit()
+
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @skipIfNetBSD # Hangs on NetBSD as well
+    @no_debug_info_test
+    def test_by_pid(self):
+        '''
+            Tests attaching to a process by process ID.
+        '''
+        self.build_and_create_debug_adaptor()
+        program = self.getBuildArtifact("a.out")
+        self.process = subprocess.Popen([program],
+                                        stdin=subprocess.PIPE,
+                                        stdout=subprocess.PIPE,
+                                        stderr=subprocess.PIPE)
+        self.attach(pid=self.process.pid)
+        self.set_and_hit_breakpoint(continueToExit=True)
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @skipIfNetBSD # Hangs on NetBSD as well
+    @no_debug_info_test
+    def test_by_name(self):
+        '''
+            Tests attaching to a process by process name.
+        '''
+        self.build_and_create_debug_adaptor()
+        orig_program = self.getBuildArtifact("a.out")
+        # Since we are going to attach by process name, we need a unique
+        # process name that has minimal chance to match a process that is
+        # already running. To do this we use tempfile.mktemp() to give us a
+        # full path to a location where we can copy our executable. We then
+        # run this copy to ensure we don't get the error "more that one
+        # process matches 'a.out'".
+        program = tempfile.mktemp()
+        shutil.copyfile(orig_program, program)
+        shutil.copymode(orig_program, program)
+
+        def cleanup():
+            if os.path.exists(program):
+                os.unlink(program)
+        # Execute the cleanup function during test case tear down.
+        self.addTearDownHook(cleanup)
+
+        self.process = subprocess.Popen([program],
+                                        stdin=subprocess.PIPE,
+                                        stdout=subprocess.PIPE,
+                                        stderr=subprocess.PIPE)
+        # Wait for a bit to ensure the process is launched, but not for so long
+        # that the process has already finished by the time we attach.
+        time.sleep(3)
+        self.attach(program=program)
+        self.set_and_hit_breakpoint(continueToExit=True)
+
+    @skipUnlessDarwin
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @skipIfNetBSD # Hangs on NetBSD as well
+    @no_debug_info_test
+    def test_by_name_waitFor(self):
+        '''
+            Tests attaching to a process by process name and waiting for the
+            next instance of a process to be launched, ingoring all current
+            ones.
+        '''
+        self.build_and_create_debug_adaptor()
+        program = self.getBuildArtifact("a.out")
+        self.spawn_thread = threading.Thread(target=spawn_and_wait,
+                                             args=(program, 1.0,))
+        self.spawn_thread.start()
+        self.attach(program=program, waitFor=True)
+        self.set_and_hit_breakpoint(continueToExit=True)
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @skipIfNetBSD # Hangs on NetBSD as well
+    @no_debug_info_test
+    def test_commands(self):
+        '''
+            Tests the "initCommands", "preRunCommands", "stopCommands",
+            "exitCommands", and "attachCommands" that can be passed during
+            attach.
+
+            "initCommands" are a list of LLDB commands that get executed
+            before the targt is created.
+            "preRunCommands" are a list of LLDB commands that get executed
+            after the target has been created and before the launch.
+            "stopCommands" are a list of LLDB commands that get executed each
+            time the program stops.
+            "exitCommands" are a list of LLDB commands that get executed when
+            the process exits
+            "attachCommands" are a list of LLDB commands that get executed and
+            must have a valid process in the selected target in LLDB after
+            they are done executing. This allows custom commands to create any
+            kind of debug session.
+        '''
+        self.build_and_create_debug_adaptor()
+        program = self.getBuildArtifact("a.out")
+        # Here we just create a target and launch the process as a way to test
+        # if we are able to use attach commands to create any kind of a target
+        # and use it for debugging
+        attachCommands = [
+            'target create -d "%s"' % (program),
+            'process launch -- arg1'
+        ]
+        initCommands = ['target list', 'platform list']
+        preRunCommands = ['image list a.out', 'image dump sections a.out']
+        stopCommands = ['frame variable', 'bt']
+        exitCommands = ['expr 2+3', 'expr 3+4']
+        self.attach(program=program,
+                    attachCommands=attachCommands,
+                    initCommands=initCommands,
+                    preRunCommands=preRunCommands,
+                    stopCommands=stopCommands,
+                    exitCommands=exitCommands)
+
+        # Get output from the console. This should contain both the
+        # "initCommands" and the "preRunCommands".
+        output = self.get_console()
+        # Verify all "initCommands" were found in console output
+        self.verify_commands('initCommands', output, initCommands)
+        # Verify all "preRunCommands" were found in console output
+        self.verify_commands('preRunCommands', output, preRunCommands)
+
+        functions = ['main']
+        breakpoint_ids = self.set_function_breakpoints(functions)
+        self.assertTrue(len(breakpoint_ids) == len(functions),
+                        "expect one breakpoint")
+        self.continue_to_breakpoints(breakpoint_ids)
+        output = self.get_console(timeout=1.0)
+        self.verify_commands('stopCommands', output, stopCommands)
+
+        # Continue after launch and hit the "pause()" call and stop the target.
+        # Get output from the console. This should contain both the
+        # "stopCommands" that were run after we stop.
+        self.vscode.request_continue()
+        time.sleep(0.5)
+        self.vscode.request_pause()
+        self.vscode.wait_for_stopped()
+        output = self.get_console(timeout=1.0)
+        self.verify_commands('stopCommands', output, stopCommands)
+
+        # Continue until the program exits
+        self.continue_to_exit()
+        # Get output from the console. This should contain both the
+        # "exitCommands" that were run after the second breakpoint was hit
+        output = self.get_console(timeout=1.0)
+        self.verify_commands('exitCommands', output, exitCommands)

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/attach/main.c

+#include <stdio.h>
+#include <unistd.h>
+
+int main(int argc, char const *argv[])
+{
+    lldb_enable_attach();
+
+    printf("pid = %i\n", getpid());
+    sleep(10);
+    return 0; // breakpoint 1
+}

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/breakpoint/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/breakpoint/TestVSCode_setBreakpoints.py

+"""
+Test lldb-vscode setBreakpoints request
+"""
+
+from __future__ import print_function
+
+import pprint
+import unittest2
+import vscode
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import lldbvscode_testcase
+import os
+
+
+class TestVSCode_setBreakpoints(lldbvscode_testcase.VSCodeTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @no_debug_info_test
+    def test_set_and_clear(self):
+        '''Tests setting and clearing source file and line breakpoints.
+           This packet is a bit tricky on the debug adaptor side since there
+           is no "clearBreakpoints" packet. Source file and line breakpoints
+           are set by sending a "setBreakpoints" packet with a source file
+           specified and zero or more source lines. If breakpoints have been
+           set in the source file before, any exising breakpoints must remain
+           set, and any new breakpoints must be created, and any breakpoints
+           that were in previous requests and are not in the current request
+           must be removed. This function tests this setting and clearing
+           and makes sure things happen correctly. It doesn't test hitting
+           breakpoints and the functionality of each breakpoint, like
+           'conditions' and 'hitCondition' settings.'''
+        source_basename = 'main.cpp'
+        source_path = os.path.join(os.getcwd(), source_basename)
+        first_line = line_number('main.cpp', 'break 12')
+        second_line = line_number('main.cpp', 'break 13')
+        third_line = line_number('main.cpp', 'break 14')
+        lines = [first_line, second_line, third_line]
+
+        # Visual Studio Code Debug Adaptors have no way to specify the file
+        # without launching or attaching to a process, so we must start a
+        # process in order to be able to set breakpoints.
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program)
+
+        # Set 3 breakoints and verify that they got set correctly
+        response = self.vscode.request_setBreakpoints(source_path, lines)
+        line_to_id = {}
+        if response:
+            breakpoints = response['body']['breakpoints']
+            self.assertTrue(len(breakpoints) == len(lines),
+                            "expect %u source breakpoints" % (len(lines)))
+            for breakpoint in breakpoints:
+                line = breakpoint['line']
+                # Store the "id" of the breakpoint that was set for later
+                line_to_id[line] = breakpoint['id']
+                self.assertTrue(line in lines, "line expected in lines array")
+                self.assertTrue(breakpoint['verified'],
+                                "expect breakpoint verified")
+
+        # There is no breakpoint delete packet, clients just send another
+        # setBreakpoints packet with the same source file with fewer lines.
+        # Below we remove the second line entry and call the setBreakpoints
+        # function again. We want to verify that any breakpoints that were set
+        # before still have the same "id". This means we didn't clear the
+        # breakpoint and set it again at the same location. We also need to
+        # verify that the second line location was actually removed.
+        lines.remove(second_line)
+        # Set 2 breakoints and verify that the previous breakoints that were
+        # set above are still set.
+        response = self.vscode.request_setBreakpoints(source_path, lines)
+        if response:
+            breakpoints = response['body']['breakpoints']
+            self.assertTrue(len(breakpoints) == len(lines),
+                            "expect %u source breakpoints" % (len(lines)))
+            for breakpoint in breakpoints:
+                line = breakpoint['line']
+                # Verify the same breakpoints are still set within LLDB by
+                # making sure the breakpoint ID didn't change
+                self.assertTrue(line_to_id[line] == breakpoint['id'],
+                                "verify previous breakpoints stayed the same")
+                self.assertTrue(line in lines, "line expected in lines array")
+                self.assertTrue(breakpoint['verified'],
+                                "expect breakpoint still verified")
+
+        # Now get the full list of breakpoints set in the target and verify
+        # we have only 2 breakpoints set. The response above could have told
+        # us about 2 breakpoints, but we want to make sure we don't have the
+        # third one still set in the target
+        response = self.vscode.request_testGetTargetBreakpoints()
+        if response:
+            breakpoints = response['body']['breakpoints']
+            self.assertTrue(len(breakpoints) == len(lines),
+                            "expect %u source breakpoints" % (len(lines)))
+            for breakpoint in breakpoints:
+                line = breakpoint['line']
+                # Verify the same breakpoints are still set within LLDB by
+                # making sure the breakpoint ID didn't change
+                self.assertTrue(line_to_id[line] == breakpoint['id'],
+                                "verify previous breakpoints stayed the same")
+                self.assertTrue(line in lines, "line expected in lines array")
+                self.assertTrue(breakpoint['verified'],
+                                "expect breakpoint still verified")
+
+        # Now clear all breakpoints for the source file by passing down an
+        # empty lines array
+        lines = []
+        response = self.vscode.request_setBreakpoints(source_path, lines)
+        if response:
+            breakpoints = response['body']['breakpoints']
+            self.assertTrue(len(breakpoints) == len(lines),
+                            "expect %u source breakpoints" % (len(lines)))
+
+        # Verify with the target that all breakpoints have been cleared
+        response = self.vscode.request_testGetTargetBreakpoints()
+        if response:
+            breakpoints = response['body']['breakpoints']
+            self.assertTrue(len(breakpoints) == len(lines),
+                            "expect %u source breakpoints" % (len(lines)))
+
+        # Now set a breakpoint again in the same source file and verify it
+        # was added.
+        lines = [second_line]
+        response = self.vscode.request_setBreakpoints(source_path, lines)
+        if response:
+            breakpoints = response['body']['breakpoints']
+            self.assertTrue(len(breakpoints) == len(lines),
+                            "expect %u source breakpoints" % (len(lines)))
+            for breakpoint in breakpoints:
+                line = breakpoint['line']
+                self.assertTrue(line in lines, "line expected in lines array")
+                self.assertTrue(breakpoint['verified'],
+                                "expect breakpoint still verified")
+
+        # Now get the full list of breakpoints set in the target and verify
+        # we have only 2 breakpoints set. The response above could have told
+        # us about 2 breakpoints, but we want to make sure we don't have the
+        # third one still set in the target
+        response = self.vscode.request_testGetTargetBreakpoints()
+        if response:
+            breakpoints = response['body']['breakpoints']
+            self.assertTrue(len(breakpoints) == len(lines),
+                            "expect %u source breakpoints" % (len(lines)))
+            for breakpoint in breakpoints:
+                line = breakpoint['line']
+                self.assertTrue(line in lines, "line expected in lines array")
+                self.assertTrue(breakpoint['verified'],
+                                "expect breakpoint still verified")
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @no_debug_info_test
+    def test_functionality(self):
+        '''Tests hitting breakpoints and the functionality of a single
+           breakpoint, like 'conditions' and 'hitCondition' settings.'''
+        source_basename = 'main.cpp'
+        source_path = os.path.join(os.getcwd(), source_basename)
+        loop_line = line_number('main.cpp', '// break loop')
+
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program)
+        # Set a breakpoint at the loop line with no condition and no
+        # hitCondition
+        breakpoint_ids = self.set_source_breakpoints(source_path, [loop_line])
+        self.assertTrue(len(breakpoint_ids) == 1, "expect one breakpoint")
+        self.vscode.request_continue()
+
+        # Verify we hit the breakpoint we just set
+        self.verify_breakpoint_hit(breakpoint_ids)
+
+        # Make sure i is zero at first breakpoint
+        i = int(self.vscode.get_local_variable_value('i'))
+        self.assertTrue(i == 0, 'i != 0 after hitting breakpoint')
+
+        # Update the condition on our breakpoint
+        new_breakpoint_ids = self.set_source_breakpoints(source_path,
+                                                         [loop_line],
+                                                         condition="i==4")
+        self.assertTrue(breakpoint_ids == new_breakpoint_ids,
+                        "existing breakpoint should have its condition "
+                        "updated")
+
+        self.continue_to_breakpoints(breakpoint_ids)
+        i = int(self.vscode.get_local_variable_value('i'))
+        self.assertTrue(i == 4,
+                        'i != 4 showing conditional works')
+
+        new_breakpoint_ids = self.set_source_breakpoints(source_path,
+                                                         [loop_line],
+                                                         hitCondition="2")
+
+        self.assertTrue(breakpoint_ids == new_breakpoint_ids,
+                        "existing breakpoint should have its condition "
+                        "updated")
+
+        # Continue with a hitContidtion of 2 and expect it to skip 1 value
+        self.continue_to_breakpoints(breakpoint_ids)
+        i = int(self.vscode.get_local_variable_value('i'))
+        self.assertTrue(i == 6,
+                        'i != 6 showing hitCondition works')
+
+        # continue after hitting our hitCondition and make sure it only goes
+        # up by 1
+        self.continue_to_breakpoints(breakpoint_ids)
+        i = int(self.vscode.get_local_variable_value('i'))
+        self.assertTrue(i == 7,
+                        'i != 7 showing post hitCondition hits every time')

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/breakpoint/TestVSCode_setExceptionBreakpoints.py

+"""
+Test lldb-vscode setBreakpoints request
+"""
+
+from __future__ import print_function
+
+import pprint
+import unittest2
+import vscode
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import lldbvscode_testcase
+import os
+
+
+class TestVSCode_setExceptionBreakpoints(
+        lldbvscode_testcase.VSCodeTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @expectedFailureNetBSD
+    @no_debug_info_test
+    def test_functionality(self):
+        '''Tests setting and clearing exception breakpoints.
+           This packet is a bit tricky on the debug adaptor side since there
+           is no "clear exception breakpoints" packet. Exception breakpoints
+           are set by sending a "setExceptionBreakpoints" packet with zero or
+           more exception filters. If exception breakpoints have been set
+           before, any exising breakpoints must remain set, and any new
+           breakpoints must be created, and any breakpoints that were in
+           previous requests and are not in the current request must be
+           removed. This exception tests this setting and clearing and makes
+           sure things happen correctly. It doesn't test hitting breakpoints
+           and the functionality of each breakpoint, like 'conditions' and
+           x'hitCondition' settings.
+        '''
+        # Visual Studio Code Debug Adaptors have no way to specify the file
+        # without launching or attaching to a process, so we must start a
+        # process in order to be able to set breakpoints.
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program)
+
+        filters = ['cpp_throw', 'cpp_catch']
+        response = self.vscode.request_setExceptionBreakpoints(filters)
+        if response:
+            self.assertTrue(response['success'])
+
+        self.continue_to_exception_breakpoint('C++ Throw')
+        self.continue_to_exception_breakpoint('C++ Catch')

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/breakpoint/TestVSCode_setFunctionBreakpoints.py

+"""
+Test lldb-vscode setBreakpoints request
+"""
+
+from __future__ import print_function
+
+import pprint
+import unittest2
+import vscode
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import lldbvscode_testcase
+import os
+
+
+class TestVSCode_setFunctionBreakpoints(
+        lldbvscode_testcase.VSCodeTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @no_debug_info_test
+    def test_set_and_clear(self):
+        '''Tests setting and clearing function breakpoints.
+           This packet is a bit tricky on the debug adaptor side since there
+           is no "clearFunction Breakpoints" packet. Function breakpoints
+           are set by sending a "setFunctionBreakpoints" packet with zero or
+           more function names. If function breakpoints have been set before,
+           any exising breakpoints must remain set, and any new breakpoints
+           must be created, and any breakpoints that were in previous requests
+           and are not in the current request must be removed. This function
+           tests this setting and clearing and makes sure things happen
+           correctly. It doesn't test hitting breakpoints and the functionality
+           of each breakpoint, like 'conditions' and 'hitCondition' settings.
+        '''
+        # Visual Studio Code Debug Adaptors have no way to specify the file
+        # without launching or attaching to a process, so we must start a
+        # process in order to be able to set breakpoints.
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program)
+        bp_id_12 = None
+        functions = ['twelve']
+        # Set a function breakpoint at 'twelve'
+        response = self.vscode.request_setFunctionBreakpoints(functions)
+        if response:
+            breakpoints = response['body']['breakpoints']
+            self.assertTrue(len(breakpoints) == len(functions),
+                            "expect %u source breakpoints" % (len(functions)))
+            for breakpoint in breakpoints:
+                bp_id_12 = breakpoint['id']
+                self.assertTrue(breakpoint['verified'],
+                                "expect breakpoint verified")
+
+        # Add an extra name and make sure we have two breakpoints after this
+        functions.append('thirteen')
+        response = self.vscode.request_setFunctionBreakpoints(functions)
+        if response:
+            breakpoints = response['body']['breakpoints']
+            self.assertTrue(len(breakpoints) == len(functions),
+                            "expect %u source breakpoints" % (len(functions)))
+            for breakpoint in breakpoints:
+                self.assertTrue(breakpoint['verified'],
+                                "expect breakpoint verified")
+
+        # There is no breakpoint delete packet, clients just send another
+        # setFunctionBreakpoints packet with the different function names.
+        functions.remove('thirteen')
+        response = self.vscode.request_setFunctionBreakpoints(functions)
+        if response:
+            breakpoints = response['body']['breakpoints']
+            self.assertTrue(len(breakpoints) == len(functions),
+                            "expect %u source breakpoints" % (len(functions)))
+            for breakpoint in breakpoints:
+                bp_id = breakpoint['id']
+                self.assertTrue(bp_id == bp_id_12,
+                                'verify "twelve" breakpoint ID is same')
+                self.assertTrue(breakpoint['verified'],
+                                "expect breakpoint still verified")
+
+        # Now get the full list of breakpoints set in the target and verify
+        # we have only 1 breakpoints set. The response above could have told
+        # us about 1 breakpoints, but we want to make sure we don't have the
+        # second one still set in the target
+        response = self.vscode.request_testGetTargetBreakpoints()
+        if response:
+            breakpoints = response['body']['breakpoints']
+            self.assertTrue(len(breakpoints) == len(functions),
+                            "expect %u source breakpoints" % (len(functions)))
+            for breakpoint in breakpoints:
+                bp_id = breakpoint['id']
+                self.assertTrue(bp_id == bp_id_12,
+                                'verify "twelve" breakpoint ID is same')
+                self.assertTrue(breakpoint['verified'],
+                                "expect breakpoint still verified")
+
+        # Now clear all breakpoints for the source file by passing down an
+        # empty lines array
+        functions = []
+        response = self.vscode.request_setFunctionBreakpoints(functions)
+        if response:
+            breakpoints = response['body']['breakpoints']
+            self.assertTrue(len(breakpoints) == len(functions),
+                            "expect %u source breakpoints" % (len(functions)))
+
+        # Verify with the target that all breakpoints have been cleared
+        response = self.vscode.request_testGetTargetBreakpoints()
+        if response:
+            breakpoints = response['body']['breakpoints']
+            self.assertTrue(len(breakpoints) == len(functions),
+                            "expect %u source breakpoints" % (len(functions)))
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @no_debug_info_test
+    def test_functionality(self):
+        '''Tests hitting breakpoints and the functionality of a single
+           breakpoint, like 'conditions' and 'hitCondition' settings.'''
+
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program)
+        # Set a breakpoint on "twelve" with no condition and no hitCondition
+        functions = ['twelve']
+        breakpoint_ids = self.set_function_breakpoints(functions)
+
+        self.assertTrue(len(breakpoint_ids) == len(functions),
+                        "expect one breakpoint")
+
+        # Verify we hit the breakpoint we just set
+        self.continue_to_breakpoints(breakpoint_ids)
+
+        # Make sure i is zero at first breakpoint
+        i = int(self.vscode.get_local_variable_value('i'))
+        self.assertTrue(i == 0, 'i != 0 after hitting breakpoint')
+
+        # Update the condition on our breakpoint
+        new_breakpoint_ids = self.set_function_breakpoints(functions,
+                                                           condition="i==4")
+        self.assertTrue(breakpoint_ids == new_breakpoint_ids,
+                        "existing breakpoint should have its condition "
+                        "updated")
+
+        self.continue_to_breakpoints(breakpoint_ids)
+        i = int(self.vscode.get_local_variable_value('i'))
+        self.assertTrue(i == 4,
+                        'i != 4 showing conditional works')
+        new_breakpoint_ids = self.set_function_breakpoints(functions,
+                                                           hitCondition="2")
+
+        self.assertTrue(breakpoint_ids == new_breakpoint_ids,
+                        "existing breakpoint should have its condition "
+                        "updated")
+
+        # Continue with a hitContidtion of 2 and expect it to skip 1 value
+        self.continue_to_breakpoints(breakpoint_ids)
+        i = int(self.vscode.get_local_variable_value('i'))
+        self.assertTrue(i == 6,
+                        'i != 6 showing hitCondition works')
+
+        # continue after hitting our hitCondition and make sure it only goes
+        # up by 1
+        self.continue_to_breakpoints(breakpoint_ids)
+        i = int(self.vscode.get_local_variable_value('i'))
+        self.assertTrue(i == 7,
+                        'i != 7 showing post hitCondition hits every time')

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/breakpoint/main.cpp

+#include <stdio.h>
+#include <stdexcept>
+
+int twelve(int i) {
+  return 12 + i; // break 12
+}
+
+int thirteen(int i) {
+  return 13 + i; // break 13
+}
+
+namespace a {
+  int fourteen(int i) {
+    return 14 + i; // break 14
+  }
+}
+int main(int argc, char const *argv[]) {
+  for (int i=0; i<10; ++i) {
+    int x = twelve(i) + thirteen(i) + a::fourteen(i); // break loop
+  }
+  try {
+    throw std::invalid_argument( "throwing exception for testing" );
+  } catch (...) {
+    puts("caught exception...");
+  }
+  return 0;
+}

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/launch/Makefile

+LEVEL = ../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/launch/TestVSCode_launch.py

+"""
+Test lldb-vscode setBreakpoints request
+"""
+
+from __future__ import print_function
+
+import pprint
+import unittest2
+import vscode
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import lldbvscode_testcase
+import os
+import time
+
+
+class TestVSCode_launch(lldbvscode_testcase.VSCodeTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @no_debug_info_test
+    def test_default(self):
+        '''
+            Tests the default launch of a simple program. No arguments,
+            environment, or anything else is specified.
+        '''
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program)
+        self.continue_to_exit()
+        # Now get the STDOUT and verify our program argument is correct
+        output = self.get_stdout()
+        self.assertTrue(output and len(output) > 0,
+                        "expect program output")
+        lines = output.splitlines()
+        self.assertTrue(program in lines[0],
+                        "make sure program path is in first argument")
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @no_debug_info_test
+    def test_stopOnEntry(self):
+        '''
+            Tests the default launch of a simple program that stops at the
+            entry point instead of continuing.
+        '''
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program, stopOnEntry=True)
+        self.set_function_breakpoints(['main'])
+        stopped_events = self.continue_to_next_stop()
+        for stopped_event in stopped_events:
+            if 'body' in stopped_event:
+                body = stopped_event['body']
+                if 'reason' in body:
+                    reason = body['reason']
+                    self.assertTrue(
+                        reason != 'breakpoint',
+                        'verify stop isn\'t "main" breakpoint')
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @expectedFailureNetBSD
+    @no_debug_info_test
+    def test_cwd(self):
+        '''
+            Tests the default launch of a simple program with a current working
+            directory.
+        '''
+        program = self.getBuildArtifact("a.out")
+        program_parent_dir = os.path.split(os.path.split(program)[0])[0]
+        self.build_and_launch(program,
+                              cwd=program_parent_dir)
+        self.continue_to_exit()
+        # Now get the STDOUT and verify our program argument is correct
+        output = self.get_stdout()
+        self.assertTrue(output and len(output) > 0,
+                        "expect program output")
+        lines = output.splitlines()
+        found = False
+        for line in lines:
+            if line.startswith('cwd = \"'):
+                quote_path = '"%s"' % (program_parent_dir)
+                found = True
+                self.assertTrue(quote_path in line,
+                                "working directory '%s' not in '%s'" % (
+                                    program_parent_dir, line))
+        self.assertTrue(found, "verified program working directory")
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @expectedFailureNetBSD
+    @no_debug_info_test
+    def test_debuggerRoot(self):
+        '''
+            Tests the "debuggerRoot" will change the working directory of
+            the lldb-vscode debug adaptor.
+        '''
+        program = self.getBuildArtifact("a.out")
+        program_parent_dir = os.path.split(os.path.split(program)[0])[0]
+        commands = ['platform shell echo cwd = $PWD']
+        self.build_and_launch(program,
+                              debuggerRoot=program_parent_dir,
+                              initCommands=commands)
+        output = self.get_console()
+        self.assertTrue(output and len(output) > 0,
+                        "expect console output")
+        lines = output.splitlines()
+        prefix = 'cwd = '
+        found = False
+        for line in lines:
+            if line.startswith(prefix):
+                found = True
+                self.assertTrue(program_parent_dir == line[len(prefix):],
+                                "lldb-vscode working dir '%s' == '%s'" % (
+                                    program_parent_dir, line[6:]))
+        self.assertTrue(found, "verified lldb-vscode working directory")
+        self.continue_to_exit()
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @no_debug_info_test
+    def test_sourcePath(self):
+        '''
+            Tests the "sourcePath" will set the target.source-map.
+        '''
+        program = self.getBuildArtifact("a.out")
+        program_dir = os.path.split(program)[0]
+        self.build_and_launch(program,
+                              sourcePath=program_dir)
+        output = self.get_console()
+        self.assertTrue(output and len(output) > 0,
+                        "expect console output")
+        lines = output.splitlines()
+        prefix = '(lldb) settings set target.source-map "." '
+        found = False
+        for line in lines:
+            if line.startswith(prefix):
+                found = True
+                quoted_path = '"%s"' % (program_dir)
+                self.assertTrue(quoted_path == line[len(prefix):],
+                                "lldb-vscode working dir %s == %s" % (
+                                    quoted_path, line[6:]))
+        self.assertTrue(found, 'found "sourcePath" in console output')
+        self.continue_to_exit()
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @no_debug_info_test
+    def test_disableSTDIO(self):
+        '''
+            Tests the default launch of a simple program with STDIO disabled.
+        '''
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program,
+                              disableSTDIO=True)
+        self.continue_to_exit()
+        # Now get the STDOUT and verify our program argument is correct
+        output = self.get_stdout()
+        self.assertTrue(output is None or len(output) == 0,
+                        "expect no program output")
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @skipIfLinux # shell argument expansion doesn't seem to work on Linux
+    @expectedFailureNetBSD
+    @no_debug_info_test
+    def test_shellExpandArguments_enabled(self):
+        '''
+            Tests the default launch of a simple program with shell expansion
+            enabled.
+        '''
+        program = self.getBuildArtifact("a.out")
+        program_dir = os.path.split(program)[0]
+        glob = os.path.join(program_dir, '*.out')
+        self.build_and_launch(program, args=[glob], shellExpandArguments=True)
+        self.continue_to_exit()
+        # Now get the STDOUT and verify our program argument is correct
+        output = self.get_stdout()
+        self.assertTrue(output and len(output) > 0,
+                        "expect no program output")
+        lines = output.splitlines()
+        for line in lines:
+            quote_path = '"%s"' % (program)
+            if line.startswith("arg[1] ="):
+                self.assertTrue(quote_path in line,
+                                'verify "%s" expanded to "%s"' % (
+                                    glob, program))
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @no_debug_info_test
+    def test_shellExpandArguments_disabled(self):
+        '''
+            Tests the default launch of a simple program with shell expansion
+            disabled.
+        '''
+        program = self.getBuildArtifact("a.out")
+        program_dir = os.path.split(program)[0]
+        glob = os.path.join(program_dir, '*.out')
+        self.build_and_launch(program,
+                              args=[glob],
+                              shellExpandArguments=False)
+        self.continue_to_exit()
+        # Now get the STDOUT and verify our program argument is correct
+        output = self.get_stdout()
+        self.assertTrue(output and len(output) > 0,
+                        "expect no program output")
+        lines = output.splitlines()
+        for line in lines:
+            quote_path = '"%s"' % (glob)
+            if line.startswith("arg[1] ="):
+                self.assertTrue(quote_path in line,
+                                'verify "%s" stayed to "%s"' % (
+                                    glob, glob))
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @no_debug_info_test
+    def test_args(self):
+        '''
+            Tests launch of a simple program with arguments
+        '''
+        program = self.getBuildArtifact("a.out")
+        args = ["one", "with space", "'with single quotes'",
+                '"with double quotes"']
+        self.build_and_launch(program,
+                              args=args)
+        self.continue_to_exit()
+
+        # Now get the STDOUT and verify our arguments got passed correctly
+        output = self.get_stdout()
+        self.assertTrue(output and len(output) > 0,
+                        "expect program output")
+        lines = output.splitlines()
+        # Skip the first argument that contains the program name
+        lines.pop(0)
+        # Make sure arguments we specified are correct
+        for (i, arg) in enumerate(args):
+            quoted_arg = '"%s"' % (arg)
+            self.assertTrue(quoted_arg in lines[i],
+                            'arg[%i] "%s" not in "%s"' % (i+1, quoted_arg, lines[i]))
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @no_debug_info_test
+    def test_environment(self):
+        '''
+            Tests launch of a simple program with environment variables
+        '''
+        program = self.getBuildArtifact("a.out")
+        env = ["NO_VALUE", "WITH_VALUE=BAR", "EMPTY_VALUE=",
+               "SPACE=Hello World"]
+        self.build_and_launch(program,
+                              env=env)
+        self.continue_to_exit()
+
+        # Now get the STDOUT and verify our arguments got passed correctly
+        output = self.get_stdout()
+        self.assertTrue(output and len(output) > 0,
+                        "expect program output")
+        lines = output.splitlines()
+        # Skip the all arguments so we have only environment vars left
+        while len(lines) and lines[0].startswith("arg["):
+            lines.pop(0)
+        # Make sure each environment variable in "env" is actually set in the
+        # program environment that was printed to STDOUT
+        for var in env:
+            found = False
+            for program_var in lines:
+                if var in program_var:
+                    found = True
+                    break
+            self.assertTrue(found,
+                            '"%s" must exist in program environment (%s)' % (
+                                var, lines))
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @no_debug_info_test
+    def test_commands(self):
+        '''
+            Tests the "initCommands", "preRunCommands", "stopCommands" and
+            "exitCommands" that can be passed during launch.
+
+            "initCommands" are a list of LLDB commands that get executed
+            before the targt is created.
+            "preRunCommands" are a list of LLDB commands that get executed
+            after the target has been created and before the launch.
+            "stopCommands" are a list of LLDB commands that get executed each
+            time the program stops.
+            "exitCommands" are a list of LLDB commands that get executed when
+            the process exits
+        '''
+        program = self.getBuildArtifact("a.out")
+        initCommands = ['target list', 'platform list']
+        preRunCommands = ['image list a.out', 'image dump sections a.out']
+        stopCommands = ['frame variable', 'bt']
+        exitCommands = ['expr 2+3', 'expr 3+4']
+        self.build_and_launch(program,
+                              initCommands=initCommands,
+                              preRunCommands=preRunCommands,
+                              stopCommands=stopCommands,
+                              exitCommands=exitCommands)
+
+        # Get output from the console. This should contain both the
+        # "initCommands" and the "preRunCommands".
+        output = self.get_console()
+        # Verify all "initCommands" were found in console output
+        self.verify_commands('initCommands', output, initCommands)
+        # Verify all "preRunCommands" were found in console output
+        self.verify_commands('preRunCommands', output, preRunCommands)
+
+        source = 'main.c'
+        first_line = line_number(source, '// breakpoint 1')
+        second_line = line_number(source, '// breakpoint 2')
+        lines = [first_line, second_line]
+
+        # Set 2 breakoints so we can verify that "stopCommands" get run as the
+        # breakpoints get hit
+        breakpoint_ids = self.set_source_breakpoints(source, lines)
+        self.assertTrue(len(breakpoint_ids) == len(lines),
+                        "expect correct number of breakpoints")
+
+        # Continue after launch and hit the first breakpoint.
+        # Get output from the console. This should contain both the
+        # "stopCommands" that were run after the first breakpoint was hit
+        self.continue_to_breakpoints(breakpoint_ids)
+        output = self.get_console(timeout=1.0)
+        self.verify_commands('stopCommands', output, stopCommands)
+
+        # Continue again and hit the second breakpoint.
+        # Get output from the console. This should contain both the
+        # "stopCommands" that were run after the second breakpoint was hit
+        self.continue_to_breakpoints(breakpoint_ids)
+        output = self.get_console(timeout=1.0)
+        self.verify_commands('stopCommands', output, stopCommands)
+
+        # Continue until the program exits
+        self.continue_to_exit()
+        # Get output from the console. This should contain both the
+        # "exitCommands" that were run after the second breakpoint was hit
+        output = self.get_console(timeout=1.0)
+        self.verify_commands('exitCommands', output, exitCommands)

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/launch/main.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int main(int argc, char const *argv[], char const *envp[]) {
+  for (int i=0; i<argc; ++i)
+    printf("arg[%i] = \"%s\"\n", i, argv[i]);
+  for (int i=0; envp[i]; ++i)
+    printf("env[%i] = \"%s\"\n", i, envp[i]);
+  char *cwd = getcwd(NULL, 0);
+  printf("cwd = \"%s\"\n", cwd); // breakpoint 1
+  free(cwd);
+  cwd = NULL;
+  return 0;  // breakpoint 2
+}

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/lldbvscode_testcase.py

+from __future__ import print_function
+
+from lldbsuite.test.lldbtest import *
+import os
+import vscode
+
+
+class VSCodeTestCaseBase(TestBase):
+
+    def create_debug_adaptor(self):
+        '''Create the Visual Studio Code debug adaptor'''
+        self.assertTrue(os.path.exists(self.lldbVSCodeExec),
+                        'lldb-vscode must exist')
+        self.vscode = vscode.DebugAdaptor(executable=self.lldbVSCodeExec)
+
+    def build_and_create_debug_adaptor(self):
+        self.build()
+        self.create_debug_adaptor()
+
+    def set_source_breakpoints(self, source_path, lines, condition=None,
+                               hitCondition=None):
+        '''Sets source breakpoints and returns an array of strings containing
+           the breakpoint location IDs ("1.1", "1.2") for each breakpoint
+           that was set.
+        '''
+        response = self.vscode.request_setBreakpoints(
+            source_path, lines, condition=condition, hitCondition=hitCondition)
+        if response is None:
+            return []
+        breakpoints = response['body']['breakpoints']
+        breakpoint_ids = []
+        for breakpoint in breakpoints:
+            response_id = breakpoint['id']
+            bp_id = response_id >> 32
+            bp_loc_id = response_id & 0xffffffff
+            breakpoint_ids.append('%i.%i' % (bp_id, bp_loc_id))
+        return breakpoint_ids
+
+    def set_function_breakpoints(self, functions, condition=None,
+                                 hitCondition=None):
+        '''Sets breakpoints by function name given an array of function names
+           and returns an array of strings containing the breakpoint location
+           IDs ("1.1", "1.2") for each breakpoint that was set.
+        '''
+        response = self.vscode.request_setFunctionBreakpoints(
+            functions, condition=condition, hitCondition=hitCondition)
+        if response is None:
+            return []
+        breakpoints = response['body']['breakpoints']
+        breakpoint_ids = []
+        for breakpoint in breakpoints:
+            response_id = breakpoint['id']
+            bp_id = response_id >> 32
+            bp_loc_id = response_id & 0xffffffff
+            breakpoint_ids.append('%i.%i' % (bp_id, bp_loc_id))
+        return breakpoint_ids
+
+    def verify_breakpoint_hit(self, breakpoint_ids):
+        '''Wait for the process we are debugging to stop, and verify we hit
+           any breakpoint location in the "breakpoint_ids" array.
+           "breakpoint_ids" should be a list of breakpoint location ID strings
+           (["1.1", "2.1"]). The return value from
+           self.set_source_breakpoints() can be passed to this function'''
+        stopped_events = self.vscode.wait_for_stopped()
+        for stopped_event in stopped_events:
+            if 'body' in stopped_event:
+                body = stopped_event['body']
+                if 'reason' not in body:
+                    continue
+                if body['reason'] != 'breakpoint':
+                    continue
+                if 'description' not in body:
+                    continue
+                # Description is "breakpoint 1.1", so look for any location id
+                # ("1.1") in the description field as verification that one of
+                # the breakpoint locations was hit
+                description = body['description']
+                for breakpoint_id in breakpoint_ids:
+                    if breakpoint_id in description:
+                        return True
+        return False
+
+    def verify_exception_breakpoint_hit(self, filter_label):
+        '''Wait for the process we are debugging to stop, and verify the stop
+           reason is 'exception' and that the description matches
+           'filter_label'
+        '''
+        stopped_events = self.vscode.wait_for_stopped()
+        for stopped_event in stopped_events:
+            if 'body' in stopped_event:
+                body = stopped_event['body']
+                if 'reason' not in body:
+                    continue
+                if body['reason'] != 'exception':
+                    continue
+                if 'description' not in body:
+                    continue
+                description = body['description']
+                if filter_label == description:
+                    return True
+        return False
+
+    def verify_commands(self, flavor, output, commands):
+        self.assertTrue(output and len(output) > 0, "expect console output")
+        lines = output.splitlines()
+        prefix = '(lldb) '
+        for cmd in commands:
+            found = False
+            for line in lines:
+                if line.startswith(prefix) and cmd in line:
+                    found = True
+                    break
+            self.assertTrue(found,
+                            "verify '%s' found in console output for '%s'" % (
+                                cmd, flavor))
+
+    def get_dict_value(self, d, key_path):
+        '''Verify each key in the key_path array is in contained in each
+           dictionary within "d". Assert if any key isn't in the
+           corresponding dictionary. This is handy for grabbing values from VS
+           Code response dictionary like getting
+           response['body']['stackFrames']
+        '''
+        value = d
+        for key in key_path:
+            if key in value:
+                value = value[key]
+            else:
+                self.assertTrue(key in value,
+                                'key "%s" from key_path "%s" not in "%s"' % (
+                                    key, key_path, d))
+        return value
+
+    def get_stackFrames(self, threadId=None, startFrame=None, levels=None,
+                        dump=False):
+        response = self.vscode.request_stackTrace(threadId=threadId,
+                                                  startFrame=startFrame,
+                                                  levels=levels,
+                                                  dump=dump)
+        if response:
+            return self.get_dict_value(response, ['body', 'stackFrames'])
+        return None
+
+    def get_source_and_line(self, threadId=None, frameIndex=0):
+        stackFrames = self.get_stackFrames(threadId=threadId,
+                                           startFrame=frameIndex,
+                                           levels=1)
+        if stackFrames is not None:
+            stackFrame = stackFrames[0]
+            ['source', 'path']
+            if 'source' in stackFrame:
+                source = stackFrame['source']
+                if 'path' in source:
+                    if 'line' in stackFrame:
+                        return (source['path'], stackFrame['line'])
+        return ('', 0)
+
+    def get_stdout(self, timeout=0.0):
+        return self.vscode.get_output('stdout', timeout=timeout)
+
+    def get_console(self, timeout=0.0):
+        return self.vscode.get_output('console', timeout=timeout)
+
+    def get_local_as_int(self, name, threadId=None):
+        value = self.vscode.get_local_variable_value(name, threadId=threadId)
+        if value.startswith('0x'):
+            return int(value, 16)
+        elif value.startswith('0'):
+            return int(value, 8)
+        else:
+            return int(value)
+
+    def set_local(self, name, value, id=None):
+        '''Set a top level local variable only.'''
+        return self.vscode.request_setVariable(1, name, str(value), id=id)
+
+    def set_global(self, name, value, id=None):
+        '''Set a top level global variable only.'''
+        return self.vscode.request_setVariable(2, name, str(value), id=id)
+
+    def stepIn(self, threadId=None, waitForStop=True):
+        self.vscode.request_stepIn(threadId=threadId)
+        if waitForStop:
+            return self.vscode.wait_for_stopped()
+        return None
+
+    def stepOver(self, threadId=None, waitForStop=True):
+        self.vscode.request_next(threadId=threadId)
+        if waitForStop:
+            return self.vscode.wait_for_stopped()
+        return None
+
+    def stepOut(self, threadId=None, waitForStop=True):
+        self.vscode.request_stepOut(threadId=threadId)
+        if waitForStop:
+            return self.vscode.wait_for_stopped()
+        return None
+
+    def continue_to_next_stop(self):
+        self.vscode.request_continue()
+        return self.vscode.wait_for_stopped()
+
+    def continue_to_breakpoints(self, breakpoint_ids):
+        self.vscode.request_continue()
+        self.verify_breakpoint_hit(breakpoint_ids)
+
+    def continue_to_exception_breakpoint(self, filter_label):
+        self.vscode.request_continue()
+        self.assertTrue(self.verify_exception_breakpoint_hit(filter_label),
+                        'verify we got "%s"' % (filter_label))
+
+    def continue_to_exit(self, exitCode=0):
+        self.vscode.request_continue()
+        stopped_events = self.vscode.wait_for_stopped()
+        self.assertTrue(len(stopped_events) == 1,
+                        "expecting single 'exited' event")
+        self.assertTrue(stopped_events[0]['event'] == 'exited',
+                        'make sure program ran to completion')
+        self.assertTrue(stopped_events[0]['body']['exitCode'] == exitCode,
+                        'exitCode == %i' % (exitCode))
+
+    def attach(self, program=None, pid=None, waitFor=None, trace=None,
+               initCommands=None, preRunCommands=None, stopCommands=None,
+               exitCommands=None, attachCommands=None):
+        '''Build the default Makefile target, create the VSCode debug adaptor,
+           and attach to the process.
+        '''
+        # Make sure we disconnect and terminate the VSCode debug adaptor even
+        # if we throw an exception during the test case.
+        def cleanup():
+            self.vscode.request_disconnect(terminateDebuggee=True)
+            self.vscode.terminate()
+
+        # Execute the cleanup function during test case tear down.
+        self.addTearDownHook(cleanup)
+        # Initialize and launch the program
+        self.vscode.request_initialize()
+        response = self.vscode.request_attach(
+            program=program, pid=pid, waitFor=waitFor, trace=trace,
+            initCommands=initCommands, preRunCommands=preRunCommands,
+            stopCommands=stopCommands, exitCommands=exitCommands,
+            attachCommands=attachCommands)
+        if not (response and response['success']):
+            self.assertTrue(response['success'],
+                            'attach failed (%s)' % (response['message']))
+
+    def build_and_launch(self, program, args=None, cwd=None, env=None,
+                         stopOnEntry=False, disableASLR=True,
+                         disableSTDIO=False, shellExpandArguments=False,
+                         trace=False, initCommands=None, preRunCommands=None,
+                         stopCommands=None, exitCommands=None,
+                         sourcePath=None, debuggerRoot=None):
+        '''Build the default Makefile target, create the VSCode debug adaptor,
+           and launch the process.
+        '''
+        self.build_and_create_debug_adaptor()
+        self.assertTrue(os.path.exists(program), 'executable must exist')
+
+        # Make sure we disconnect and terminate the VSCode debug adaptor even
+        # if we throw an exception during the test case.
+        def cleanup():
+            self.vscode.request_disconnect(terminateDebuggee=True)
+            self.vscode.terminate()
+
+        # Execute the cleanup function during test case tear down.
+        self.addTearDownHook(cleanup)
+
+        # Initialize and launch the program
+        self.vscode.request_initialize()
+        response = self.vscode.request_launch(
+            program,
+            args=args,
+            cwd=cwd,
+            env=env,
+            stopOnEntry=stopOnEntry,
+            disableASLR=disableASLR,
+            disableSTDIO=disableSTDIO,
+            shellExpandArguments=shellExpandArguments,
+            trace=trace,
+            initCommands=initCommands,
+            preRunCommands=preRunCommands,
+            stopCommands=stopCommands,
+            exitCommands=exitCommands,
+            sourcePath=sourcePath,
+            debuggerRoot=debuggerRoot)
+        if not (response and response['success']):
+            self.assertTrue(response['success'],
+                            'launch failed (%s)' % (response['message']))

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/stackTrace/Makefile

+LEVEL = ../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/stackTrace/TestVSCode_stackTrace.py

+"""
+Test lldb-vscode setBreakpoints request
+"""
+
+from __future__ import print_function
+
+import unittest2
+import vscode
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import lldbvscode_testcase
+import os
+
+
+class TestVSCode_stackTrace(lldbvscode_testcase.VSCodeTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    name_key_path = ['name']
+    source_key_path = ['source', 'path']
+    line_key_path = ['line']
+
+    def verify_stackFrames(self, start_idx, stackFrames):
+        frame_idx = start_idx
+        for stackFrame in stackFrames:
+            # Don't care about frame above main
+            if frame_idx > 20:
+                return
+            self.verify_stackFrame(frame_idx, stackFrame)
+            frame_idx += 1
+
+    def verify_stackFrame(self, frame_idx, stackFrame):
+        frame_name = self.get_dict_value(stackFrame, self.name_key_path)
+        frame_source = self.get_dict_value(stackFrame, self.source_key_path)
+        frame_line = self.get_dict_value(stackFrame, self.line_key_path)
+        if frame_idx == 0:
+            expected_line = self.recurse_end
+            expected_name = 'recurse'
+        elif frame_idx < 20:
+            expected_line = self.recurse_call
+            expected_name = 'recurse'
+        else:
+            expected_line = self.recurse_invocation
+            expected_name = 'main'
+        self.assertTrue(frame_name == expected_name,
+                        'frame #%i name "%s" == "%s"' % (
+                            frame_idx, frame_name, expected_name))
+        self.assertTrue(frame_source == self.source_path,
+                        'frame #%i source "%s" == "%s"' % (
+                            frame_idx, frame_source, self.source_path))
+        self.assertTrue(frame_line == expected_line,
+                        'frame #%i line %i == %i' % (frame_idx, frame_line,
+                                                     expected_line))
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @no_debug_info_test
+    def test_stackTrace(self):
+        '''
+            Tests the 'stackTrace' packet and all its variants.
+        '''
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program)
+        source = 'main.c'
+        self.source_path = os.path.join(os.getcwd(), source)
+        self.recurse_end = line_number(source, 'recurse end')
+        self.recurse_call = line_number(source, 'recurse call')
+        self.recurse_invocation = line_number(source, 'recurse invocation')
+
+        lines = [self.recurse_end]
+
+        # Set breakoint at a point of deepest recuusion
+        breakpoint_ids = self.set_source_breakpoints(source, lines)
+        self.assertTrue(len(breakpoint_ids) == len(lines),
+                        "expect correct number of breakpoints")
+
+        self.continue_to_breakpoints(breakpoint_ids)
+        startFrame = 0
+        # Verify we get all stack frames with no arguments
+        stackFrames = self.get_stackFrames()
+        frameCount = len(stackFrames)
+        self.assertTrue(frameCount >= 20,
+                        'verify we get at least 20 frames for all frames')
+        self.verify_stackFrames(startFrame, stackFrames)
+
+        # Verify all stack frames by specifying startFrame = 0 and levels not
+        # specified
+        stackFrames = self.get_stackFrames(startFrame=startFrame)
+        self.assertTrue(frameCount == len(stackFrames),
+                        ('verify same number of frames with startFrame=%i') % (
+                            startFrame))
+        self.verify_stackFrames(startFrame, stackFrames)
+
+        # Verify all stack frames by specifying startFrame = 0 and levels = 0
+        levels = 0
+        stackFrames = self.get_stackFrames(startFrame=startFrame,
+                                           levels=levels)
+        self.assertTrue(frameCount == len(stackFrames),
+                        ('verify same number of frames with startFrame=%i and'
+                         ' levels=%i') % (startFrame, levels))
+        self.verify_stackFrames(startFrame, stackFrames)
+
+        # Get only the first stack frame by sepcifying startFrame = 0 and
+        # levels = 1
+        levels = 1
+        stackFrames = self.get_stackFrames(startFrame=startFrame,
+                                           levels=levels)
+        self.assertTrue(levels == len(stackFrames),
+                        ('verify one frame with startFrame=%i and'
+                         ' levels=%i') % (startFrame, levels))
+        self.verify_stackFrames(startFrame, stackFrames)
+
+        # Get only the first 3 stack frames by sepcifying startFrame = 0 and
+        # levels = 3
+        levels = 3
+        stackFrames = self.get_stackFrames(startFrame=startFrame,
+                                           levels=levels)
+        self.assertTrue(levels == len(stackFrames),
+                        ('verify %i frames with startFrame=%i and'
+                         ' levels=%i') % (levels, startFrame, levels))
+        self.verify_stackFrames(startFrame, stackFrames)
+
+        # Get only the first 15 stack frames by sepcifying startFrame = 5 and
+        # levels = 16
+        startFrame = 5
+        levels = 16
+        stackFrames = self.get_stackFrames(startFrame=startFrame,
+                                           levels=levels)
+        self.assertTrue(levels == len(stackFrames),
+                        ('verify %i frames with startFrame=%i and'
+                         ' levels=%i') % (levels, startFrame, levels))
+        self.verify_stackFrames(startFrame, stackFrames)
+
+        # Verify we cap things correctly when we ask for too many frames
+        startFrame = 5
+        levels = 1000
+        stackFrames = self.get_stackFrames(startFrame=startFrame,
+                                           levels=levels)
+        self.assertTrue(len(stackFrames) == frameCount - startFrame,
+                        ('verify less than 1000 frames with startFrame=%i and'
+                         ' levels=%i') % (startFrame, levels))
+        self.verify_stackFrames(startFrame, stackFrames)
+
+        # Verify level=0 works with non-zerp start frame
+        startFrame = 5
+        levels = 0
+        stackFrames = self.get_stackFrames(startFrame=startFrame,
+                                           levels=levels)
+        self.assertTrue(len(stackFrames) == frameCount - startFrame,
+                        ('verify less than 1000 frames with startFrame=%i and'
+                         ' levels=%i') % (startFrame, levels))
+        self.verify_stackFrames(startFrame, stackFrames)
+
+        # Verify we get not frames when startFrame is too high
+        startFrame = 1000
+        levels = 1
+        stackFrames = self.get_stackFrames(startFrame=startFrame,
+                                           levels=levels)
+        self.assertTrue(0 == len(stackFrames),
+                        'verify zero frames with startFrame out of bounds')

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/stackTrace/main.c

+#include <stdio.h>
+#include <unistd.h>
+
+int recurse(int x) {
+  if (x <= 1)
+    return 1; // recurse end
+  return recurse(x-1) + x; // recurse call
+}
+
+int main(int argc, char const *argv[]) {
+  recurse(20); // recurse invocation
+  return 0;
+}

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/step/Makefile

+LEVEL = ../../../make
+
+ENABLE_THREADS := YES
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/step/TestVSCode_step.py

+"""
+Test lldb-vscode setBreakpoints request
+"""
+
+from __future__ import print_function
+
+import unittest2
+import vscode
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import lldbvscode_testcase
+import os
+
+
+class TestVSCode_step(lldbvscode_testcase.VSCodeTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @no_debug_info_test
+    def test_step(self):
+        '''
+            Tests the stepping in/out/over in threads.
+        '''
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program)
+        source = 'main.cpp'
+        # source_path = os.path.join(os.getcwd(), source)
+        breakpoint1_line = line_number(source, '// breakpoint 1')
+        lines = [breakpoint1_line]
+        # Set breakoint in the thread function so we can step the threads
+        breakpoint_ids = self.set_source_breakpoints(source, lines)
+        self.assertEqual(len(breakpoint_ids), len(lines),
+                        "expect correct number of breakpoints")
+        self.continue_to_breakpoints(breakpoint_ids)
+        threads = self.vscode.get_threads()
+        for thread in threads:
+            if 'reason' in thread:
+                reason = thread['reason']
+                if reason == 'breakpoint':
+                    # We have a thread that is stopped at our breakpoint.
+                    # Get the value of "x" and get the source file and line.
+                    # These will help us determine if we are stepping
+                    # correctly. If we step a thread correctly we will verify
+                    # the correct falue for x as it progresses through the
+                    # program.
+                    tid = thread['id']
+                    x1 = self.get_local_as_int('x', threadId=tid)
+                    (src1, line1) = self.get_source_and_line(threadId=tid)
+
+                    # Now step into the "recurse()" function call again and
+                    # verify, using the new value of "x" and the source file
+                    # and line if we stepped correctly
+                    self.stepIn(threadId=tid, waitForStop=True)
+                    x2 = self.get_local_as_int('x', threadId=tid)
+                    (src2, line2) = self.get_source_and_line(threadId=tid)
+                    self.assertEqual(x1, x2 + 1, 'verify step in variable')
+                    self.assertLess(line2, line1, 'verify step in line')
+                    self.assertEqual(src1, src2, 'verify step in source')
+
+                    # Now step out and verify
+                    self.stepOut(threadId=tid, waitForStop=True)
+                    x3 = self.get_local_as_int('x', threadId=tid)
+                    (src3, line3) = self.get_source_and_line(threadId=tid)
+                    self.assertEqual(x1, x3, 'verify step out variable')
+                    self.assertGreaterEqual(line3, line1, 'verify step out line')
+                    self.assertEqual(src1, src3, 'verify step in source')
+
+                    # Step over and verify
+                    self.stepOver(threadId=tid, waitForStop=True)
+                    x4 = self.get_local_as_int('x', threadId=tid)
+                    (src4, line4) = self.get_source_and_line(threadId=tid)
+                    self.assertEqual(x4, x3, 'verify step over variable')
+                    self.assertGreater(line4, line3, 'verify step over line')
+                    self.assertEqual(src1, src4, 'verify step over source')
+                    # only step one thread that is at the breakpoint and stop
+                    break

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/step/main.cpp

+int function(int x) {
+  if ((x % 2) == 0)
+    return function(x-1) + x; // breakpoint 1
+  else
+    return x;
+}
+
+int main(int argc, char const *argv[]) {
+  return function(2);
+}

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/variables/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/variables/TestVSCode_variables.py

+"""
+Test lldb-vscode setBreakpoints request
+"""
+
+from __future__ import print_function
+
+import unittest2
+import vscode
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import lldbvscode_testcase
+import os
+
+
+def make_buffer_verify_dict(start_idx, count, offset=0):
+    verify_dict = {}
+    for i in range(start_idx, start_idx + count):
+        verify_dict['[%i]' % (i)] = {'type': 'int', 'value': str(i+offset)}
+    return verify_dict
+
+
+class TestVSCode_variables(lldbvscode_testcase.VSCodeTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def verify_values(self, verify_dict, actual, varref_dict=None):
+        if 'equals' in verify_dict:
+            verify = verify_dict['equals']
+            for key in verify:
+                verify_value = verify[key]
+                actual_value = actual[key]
+                self.assertTrue(verify_value == actual_value,
+                                '"%s" keys don\'t match (%s != %s)' % (
+                                    key, actual_value, verify_value))
+        if 'startswith' in verify_dict:
+            verify = verify_dict['startswith']
+            for key in verify:
+                verify_value = verify[key]
+                actual_value = actual[key]
+                startswith = actual_value.startswith(verify_value)
+                self.assertTrue(startswith,
+                                ('"%s" value "%s" doesn\'t start with'
+                                 ' "%s")') % (
+                                    key, actual_value,
+                                    verify_value))
+        hasVariablesReference = 'variablesReference' in actual
+        varRef = None
+        if hasVariablesReference:
+            # Remember variable references in case we want to test further
+            # by using the evaluate name.
+            varRef = actual['variablesReference']
+            if varRef != 0 and varref_dict is not None:
+                varref_dict[actual['evaluateName']] = varRef
+        if ('hasVariablesReference' in verify_dict and
+                verify_dict['hasVariablesReference']):
+            self.assertTrue(hasVariablesReference,
+                            "verify variable reference")
+        if 'children' in verify_dict:
+            self.assertTrue(hasVariablesReference and varRef is not None and
+                            varRef != 0,
+                            ("children verify values specified for "
+                             "variable without children"))
+
+            response = self.vscode.request_variables(varRef)
+            self.verify_variables(verify_dict['children'],
+                                  response['body']['variables'],
+                                  varref_dict)
+
+    def verify_variables(self, verify_dict, variables, varref_dict=None):
+        for variable in variables:
+            name = variable['name']
+            self.assertTrue(name in verify_dict,
+                            'variable "%s" in verify dictionary' % (name))
+            self.verify_values(verify_dict[name], variable, varref_dict)
+
+    @skipIfWindows
+    @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @no_debug_info_test
+    def test_scopes_variables_setVariable_evaluate(self):
+        '''
+            Tests the "scopes", "variables", "setVariable", and "evaluate"
+            packets.
+        '''
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program)
+        source = 'main.cpp'
+        breakpoint1_line = line_number(source, '// breakpoint 1')
+        lines = [breakpoint1_line]
+        # Set breakoint in the thread function so we can step the threads
+        breakpoint_ids = self.set_source_breakpoints(source, lines)
+        self.assertTrue(len(breakpoint_ids) == len(lines),
+                        "expect correct number of breakpoints")
+        self.continue_to_breakpoints(breakpoint_ids)
+        locals = self.vscode.get_local_variables()
+        globals = self.vscode.get_global_variables()
+        buffer_children = make_buffer_verify_dict(0, 32)
+        verify_locals = {
+            'argc': {
+                'equals': {'type': 'int', 'value': '1'}
+            },
+            'argv': {
+                'equals': {'type': 'const char **'},
+                'startswith': {'value': '0x'},
+                'hasVariablesReference': True
+            },
+            'pt': {
+                'equals': {'type': 'PointType'},
+                'hasVariablesReference': True,
+                'children': {
+                    'x': {'equals': {'type': 'int', 'value': '11'}},
+                    'y': {'equals': {'type': 'int', 'value': '22'}},
+                    'buffer': {'children': buffer_children}
+                }
+            }
+        }
+        verify_globals = {
+            's_local': {
+                'equals': {'type': 'float', 'value': '2.25'}
+            },
+            '::g_global': {
+                'equals': {'type': 'int', 'value': '123'}
+            },
+            's_global': {
+                'equals': {'type': 'int', 'value': '234'}
+            },
+        }
+        varref_dict = {}
+        self.verify_variables(verify_locals, locals, varref_dict)
+        self.verify_variables(verify_globals, globals, varref_dict)
+        # pprint.PrettyPrinter(indent=4).pprint(varref_dict)
+        # We need to test the functionality of the "variables" request as it
+        # has optional parameters like "start" and "count" to limit the number
+        # of variables that are fetched
+        varRef = varref_dict['pt.buffer']
+        response = self.vscode.request_variables(varRef)
+        self.verify_variables(buffer_children, response['body']['variables'])
+        # Verify setting start=0 in the arguments still gets all children
+        response = self.vscode.request_variables(varRef, start=0)
+        self.verify_variables(buffer_children, response['body']['variables'])
+        # Verify setting count=0 in the arguments still gets all children.
+        # If count is zero, it means to get all children.
+        response = self.vscode.request_variables(varRef, count=0)
+        self.verify_variables(buffer_children, response['body']['variables'])
+        # Verify setting count to a value that is too large in the arguments
+        # still gets all children, and no more
+        response = self.vscode.request_variables(varRef, count=1000)
+        self.verify_variables(buffer_children, response['body']['variables'])
+        # Verify setting the start index and count gets only the children we
+        # want
+        response = self.vscode.request_variables(varRef, start=5, count=5)
+        self.verify_variables(make_buffer_verify_dict(5, 5),
+                              response['body']['variables'])
+        # Verify setting the start index to a value that is out of range
+        # results in an empty list
+        response = self.vscode.request_variables(varRef, start=32, count=1)
+        self.assertTrue(len(response['body']['variables']) == 0,
+                        'verify we get no variable back for invalid start')
+
+        # Test evaluate
+        expressions = {
+            'pt.x': {
+                'equals': {'result': '11', 'type': 'int'},
+                'hasVariablesReference': False
+            },
+            'pt.buffer[2]': {
+                'equals': {'result': '2', 'type': 'int'},
+                'hasVariablesReference': False
+            },
+            'pt': {
+                'equals': {'type': 'PointType'},
+                'startswith': {'result': 'PointType @ 0x'},
+                'hasVariablesReference': True
+            },
+            'pt.buffer': {
+                'equals': {'type': 'int [32]'},
+                'startswith': {'result': 'int [32] @ 0x'},
+                'hasVariablesReference': True
+            },
+            'argv': {
+                'equals': {'type': 'const char **'},
+                'startswith': {'result': '0x'},
+                'hasVariablesReference': True
+            },
+            'argv[0]': {
+                'equals': {'type': 'const char *'},
+                'startswith': {'result': '0x'},
+                'hasVariablesReference': True
+            },
+            '2+3': {
+                'equals': {'result': '5', 'type': 'int'},
+                'hasVariablesReference': False
+            },
+        }
+        for expression in expressions:
+            response = self.vscode.request_evaluate(expression)
+            self.verify_values(expressions[expression], response['body'])
+
+        # Test setting variables
+        self.set_local('argc', 123)
+        argc = self.get_local_as_int('argc')
+        self.assertTrue(argc == 123,
+                        'verify argc was set to 123 (123 != %i)' % (argc))
+
+        self.set_local('argv', 0x1234)
+        argv = self.get_local_as_int('argv')
+        self.assertTrue(argv == 0x1234,
+                        'verify argv was set to 0x1234 (0x1234 != %#x)' % (
+                            argv))
+
+        # Set a variable value whose name is synthetic, like a variable index
+        # and verify the value by reading it
+        self.vscode.request_setVariable(varRef, "[0]", 100)
+        response = self.vscode.request_variables(varRef, start=0, count=1)
+        self.verify_variables(make_buffer_verify_dict(0, 1, 100),
+                              response['body']['variables'])
+
+        # Set a variable value whose name is a real child value, like "pt.x"
+        # and verify the value by reading it
+        varRef = varref_dict['pt']
+        self.vscode.request_setVariable(varRef, "x", 111)
+        response = self.vscode.request_variables(varRef, start=0, count=1)
+        value = response['body']['variables'][0]['value']
+        self.assertTrue(value == '111',
+                        'verify pt.x got set to 111 (111 != %s)' % (value))

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/variables/main.cpp

+
+#define BUFFER_SIZE 32
+struct PointType {
+  int x;
+  int y;
+  int buffer[BUFFER_SIZE];
+};
+
+int g_global = 123;
+static int s_global = 234;
+
+int main(int argc, char const *argv[]) {
+  static float s_local = 2.25;
+  PointType pt = { 11,22, {0}};
+  for (int i=0; i<BUFFER_SIZE; ++i)
+    pt.buffer[i] = i;
+  return s_global - g_global - pt.y; // breakpoint 1
+}

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-vscode/vscode.py

+#!/usr/bin/env python
+
+import binascii
+import json
+import optparse
+import os
+import pprint
+import socket
+import string
+import subprocess
+import sys
+import threading
+
+
+def dump_memory(base_addr, data, num_per_line, outfile):
+
+    data_len = len(data)
+    hex_string = binascii.hexlify(data)
+    addr = base_addr
+    ascii_str = ''
+    i = 0
+    while i < data_len:
+        outfile.write('0x%8.8x: ' % (addr + i))
+        bytes_left = data_len - i
+        if bytes_left >= num_per_line:
+            curr_data_len = num_per_line
+        else:
+            curr_data_len = bytes_left
+        hex_start_idx = i * 2
+        hex_end_idx = hex_start_idx + curr_data_len * 2
+        curr_hex_str = hex_string[hex_start_idx:hex_end_idx]
+        # 'curr_hex_str' now contains the hex byte string for the
+        # current line with no spaces between bytes
+        t = iter(curr_hex_str)
+        # Print hex bytes separated by space
+        outfile.write(' '.join(a + b for a, b in zip(t, t)))
+        # Print two spaces
+        outfile.write('  ')
+        # Calculate ASCII string for bytes into 'ascii_str'
+        ascii_str = ''
+        for j in range(i, i + curr_data_len):
+            ch = data[j]
+            if ch in string.printable and ch not in string.whitespace:
+                ascii_str += '%c' % (ch)
+            else:
+                ascii_str += '.'
+        # Print ASCII representation and newline
+        outfile.write(ascii_str)
+        i = i + curr_data_len
+        outfile.write('\n')
+
+
+def read_packet(f, verbose=False, trace_file=None):
+    '''Decode a JSON packet that starts with the content length and is
+       followed by the JSON bytes from a file 'f'. Returns None on EOF.
+    '''
+    line = f.readline().decode("utf-8")
+    if len(line) == 0:
+        return None  # EOF.
+
+    # Watch for line that starts with the prefix
+    prefix = 'Content-Length: '
+    if line.startswith(prefix):
+        # Decode length of JSON bytes
+        if verbose:
+            print('content: "%s"' % (line))
+        length = int(line[len(prefix):])
+        if verbose:
+            print('length: "%u"' % (length))
+        # Skip empty line
+        line = f.readline()
+        if verbose:
+            print('empty: "%s"' % (line))
+        # Read JSON bytes
+        json_str = f.read(length)
+        if verbose:
+            print('json: "%s"' % (json_str))
+        if trace_file:
+            trace_file.write('from adaptor:\n%s\n' % (json_str))
+        # Decode the JSON bytes into a python dictionary
+        return json.loads(json_str)
+
+    return None
+
+
+def packet_type_is(packet, packet_type):
+    return 'type' in packet and packet['type'] == packet_type
+
+
+def read_packet_thread(vs_comm):
+    done = False
+    while not done:
+        packet = read_packet(vs_comm.recv, trace_file=vs_comm.trace_file)
+        # `packet` will be `None` on EOF. We want to pass it down to
+        # handle_recv_packet anyway so the main thread can handle unexpected
+        # termination of lldb-vscode and stop waiting for new packets.
+        done = not vs_comm.handle_recv_packet(packet)
+
+
+class DebugCommunication(object):
+
+    def __init__(self, recv, send):
+        self.trace_file = None
+        self.send = send
+        self.recv = recv
+        self.recv_packets = []
+        self.recv_condition = threading.Condition()
+        self.recv_thread = threading.Thread(target=read_packet_thread,
+                                            args=(self,))
+        self.process_event_body = None
+        self.exit_status = None
+        self.initialize_body = None
+        self.thread_stop_reasons = {}
+        self.sequence = 1
+        self.threads = None
+        self.recv_thread.start()
+        self.output_condition = threading.Condition()
+        self.output = {}
+        self.configuration_done_sent = False
+        self.frame_scopes = {}
+
+    @classmethod
+    def encode_content(cls, s):
+        return ("Content-Length: %u\r\n\r\n%s" % (len(s), s)).encode("utf-8")
+
+    @classmethod
+    def validate_response(cls, command, response):
+        if command['command'] != response['command']:
+            raise ValueError('command mismatch in response')
+        if command['seq'] != response['request_seq']:
+            raise ValueError('seq mismatch in response')
+
+    def get_output(self, category, timeout=0.0, clear=True):
+        self.output_condition.acquire()
+        output = None
+        if category in self.output:
+            output = self.output[category]
+            if clear:
+                del self.output[category]
+        elif timeout != 0.0:
+            self.output_condition.wait(timeout)
+            if category in self.output:
+                output = self.output[category]
+                if clear:
+                    del self.output[category]
+        self.output_condition.release()
+        return output
+
+    def enqueue_recv_packet(self, packet):
+        self.recv_condition.acquire()
+        self.recv_packets.append(packet)
+        self.recv_condition.notify()
+        self.recv_condition.release()
+
+    def handle_recv_packet(self, packet):
+        '''Called by the read thread that is waiting for all incoming packets
+           to store the incoming packet in "self.recv_packets" in a thread safe
+           way. This function will then signal the "self.recv_condition" to
+           indicate a new packet is available. Returns True if the caller
+           should keep calling this function for more packets.
+        '''
+        # If EOF, notify the read thread by enqueing a None.
+        if not packet:
+            self.enqueue_recv_packet(None)
+            return False
+
+        # Check the packet to see if is an event packet
+        keepGoing = True
+        packet_type = packet['type']
+        if packet_type == 'event':
+            event = packet['event']
+            body = None
+            if 'body' in packet:
+                body = packet['body']
+            # Handle the event packet and cache information from these packets
+            # as they come in
+            if event == 'output':
+                # Store any output we receive so clients can retrieve it later.
+                category = body['category']
+                output = body['output']
+                self.output_condition.acquire()
+                if category in self.output:
+                    self.output[category] += output
+                else:
+                    self.output[category] = output
+                self.output_condition.notify()
+                self.output_condition.release()
+                # no need to add 'output' packets to our packets list
+                return keepGoing
+            elif event == 'process':
+                # When a new process is attached or launched, remember the
+                # details that are available in the body of the event
+                self.process_event_body = body
+            elif event == 'stopped':
+                # Each thread that stops with a reason will send a
+                # 'stopped' event. We need to remember the thread stop
+                # reasons since the 'threads' command doesn't return
+                # that information.
+                self._process_stopped()
+                tid = body['threadId']
+                self.thread_stop_reasons[tid] = body
+        elif packet_type == 'response':
+            if packet['command'] == 'disconnect':
+                keepGoing = False
+        self.enqueue_recv_packet(packet)
+        return keepGoing
+
+    def send_packet(self, command_dict, set_sequence=True):
+        '''Take the "command_dict" python dictionary and encode it as a JSON
+           string and send the contents as a packet to the VSCode debug
+           adaptor'''
+        # Set the sequence ID for this command automatically
+        if set_sequence:
+            command_dict['seq'] = self.sequence
+            self.sequence += 1
+        # Encode our command dictionary as a JSON string
+        json_str = json.dumps(command_dict, separators=(',', ':'))
+        if self.trace_file:
+            self.trace_file.write('to adaptor:\n%s\n' % (json_str))
+        length = len(json_str)
+        if length > 0:
+            # Send the encoded JSON packet and flush the 'send' file
+            self.send.write(self.encode_content(json_str))
+            self.send.flush()
+
+    def recv_packet(self, filter_type=None, filter_event=None, timeout=None):
+        '''Get a JSON packet from the VSCode debug adaptor. This function
+           assumes a thread that reads packets is running and will deliver
+           any received packets by calling handle_recv_packet(...). This
+           function will wait for the packet to arrive and return it when
+           it does.'''
+        while True:
+            try:
+                self.recv_condition.acquire()
+                packet = None
+                while True:
+                    for (i, curr_packet) in enumerate(self.recv_packets):
+                        if not curr_packet:
+                            raise EOFError
+                        packet_type = curr_packet['type']
+                        if filter_type is None or packet_type in filter_type:
+                            if (filter_event is None or
+                                (packet_type == 'event' and
+                                 curr_packet['event'] in filter_event)):
+                                packet = self.recv_packets.pop(i)
+                                break
+                    if packet:
+                        break
+                    # Sleep until packet is received
+                    len_before = len(self.recv_packets)
+                    self.recv_condition.wait(timeout)
+                    len_after = len(self.recv_packets)
+                    if len_before == len_after:
+                        return None  # Timed out
+                return packet
+            except EOFError:
+                return None
+            finally:
+                self.recv_condition.release()
+
+        return None
+
+    def send_recv(self, command):
+        '''Send a command python dictionary as JSON and receive the JSON
+           response. Validates that the response is the correct sequence and
+           command in the reply. Any events that are received are added to the
+           events list in this object'''
+        self.send_packet(command)
+        done = False
+        while not done:
+            response = self.recv_packet(filter_type='response')
+            if response is None:
+                desc = 'no response for "%s"' % (command['command'])
+                raise ValueError(desc)
+            self.validate_response(command, response)
+            return response
+        return None
+
+    def wait_for_event(self, filter=None, timeout=None):
+        while True:
+            return self.recv_packet(filter_type='event', filter_event=filter,
+                                    timeout=timeout)
+        return None
+
+    def wait_for_stopped(self, timeout=None):
+        stopped_events = []
+        stopped_event = self.wait_for_event(filter=['stopped', 'exited'],
+                                            timeout=timeout)
+        exited = False
+        while stopped_event:
+            stopped_events.append(stopped_event)
+            # If we exited, then we are done
+            if stopped_event['event'] == 'exited':
+                self.exit_status = stopped_event['body']['exitCode']
+                exited = True
+                break
+            # Otherwise we stopped and there might be one or more 'stopped'
+            # events for each thread that stopped with a reason, so keep
+            # checking for more 'stopped' events and return all of them
+            stopped_event = self.wait_for_event(filter='stopped', timeout=0.25)
+        if exited:
+            self.threads = []
+        return stopped_events
+
+    def wait_for_exited(self):
+        event_dict = self.wait_for_event('exited')
+        if event_dict is None:
+            raise ValueError("didn't get stopped event")
+        return event_dict
+
+    def get_initialize_value(self, key):
+        '''Get a value for the given key if it there is a key/value pair in
+           the "initialize" request response body.
+        '''
+        if self.initialize_body and key in self.initialize_body:
+            return self.initialize_body[key]
+        return None
+
+    def get_threads(self):
+        if self.threads is None:
+            self.request_threads()
+        return self.threads
+
+    def get_thread_id(self, threadIndex=0):
+        '''Utility function to get the first thread ID in the thread list.
+           If the thread list is empty, then fetch the threads.
+        '''
+        if self.threads is None:
+            self.request_threads()
+        if self.threads and threadIndex < len(self.threads):
+            return self.threads[threadIndex]['id']
+        return None
+
+    def get_stackFrame(self, frameIndex=0, threadId=None):
+        '''Get a single "StackFrame" object from a "stackTrace" request and
+           return the "StackFrame as a python dictionary, or None on failure
+        '''
+        if threadId is None:
+            threadId = self.get_thread_id()
+        if threadId is None:
+            print('invalid threadId')
+            return None
+        response = self.request_stackTrace(threadId, startFrame=frameIndex,
+                                           levels=1)
+        if response:
+            return response['body']['stackFrames'][0]
+        print('invalid response')
+        return None
+
+    def get_scope_variables(self, scope_name, frameIndex=0, threadId=None):
+        stackFrame = self.get_stackFrame(frameIndex=frameIndex,
+                                         threadId=threadId)
+        if stackFrame is None:
+            return []
+        frameId = stackFrame['id']
+        if frameId in self.frame_scopes:
+            frame_scopes = self.frame_scopes[frameId]
+        else:
+            scopes_response = self.request_scopes(frameId)
+            frame_scopes = scopes_response['body']['scopes']
+            self.frame_scopes[frameId] = frame_scopes
+        for scope in frame_scopes:
+            if scope['name'] == scope_name:
+                varRef = scope['variablesReference']
+                variables_response = self.request_variables(varRef)
+                if variables_response:
+                    if 'body' in variables_response:
+                        body = variables_response['body']
+                        if 'variables' in body:
+                            vars = body['variables']
+                            return vars
+        return []
+
+    def get_global_variables(self, frameIndex=0, threadId=None):
+        return self.get_scope_variables('Globals', frameIndex=frameIndex,
+                                        threadId=threadId)
+
+    def get_local_variables(self, frameIndex=0, threadId=None):
+        return self.get_scope_variables('Locals', frameIndex=frameIndex,
+                                        threadId=threadId)
+
+    def get_local_variable(self, name, frameIndex=0, threadId=None):
+        locals = self.get_local_variables(frameIndex=frameIndex,
+                                          threadId=threadId)
+        for local in locals:
+            if 'name' in local and local['name'] == name:
+                return local
+        return None
+
+    def get_local_variable_value(self, name, frameIndex=0, threadId=None):
+        variable = self.get_local_variable(name, frameIndex=frameIndex,
+                                           threadId=threadId)
+        if variable and 'value' in variable:
+            return variable['value']
+        return None
+
+    def replay_packets(self, replay_file_path):
+        f = open(replay_file_path, 'r')
+        mode = 'invalid'
+        set_sequence = False
+        command_dict = None
+        while mode != 'eof':
+            if mode == 'invalid':
+                line = f.readline()
+                if line.startswith('to adapter:'):
+                    mode = 'send'
+                elif line.startswith('from adapter:'):
+                    mode = 'recv'
+            elif mode == 'send':
+                command_dict = read_packet(f)
+                # Skip the end of line that follows the JSON
+                f.readline()
+                if command_dict is None:
+                    raise ValueError('decode packet failed from replay file')
+                print('Sending:')
+                pprint.PrettyPrinter(indent=2).pprint(command_dict)
+                # raw_input('Press ENTER to send:')
+                self.send_packet(command_dict, set_sequence)
+                mode = 'invalid'
+            elif mode == 'recv':
+                print('Replay response:')
+                replay_response = read_packet(f)
+                # Skip the end of line that follows the JSON
+                f.readline()
+                pprint.PrettyPrinter(indent=2).pprint(replay_response)
+                actual_response = self.recv_packet()
+                if actual_response:
+                    type = actual_response['type']
+                    print('Actual response:')
+                    if type == 'response':
+                        self.validate_response(command_dict, actual_response)
+                    pprint.PrettyPrinter(indent=2).pprint(actual_response)
+                else:
+                    print("error: didn't get a valid response")
+                mode = 'invalid'
+
+    def request_attach(self, program=None, pid=None, waitFor=None, trace=None,
+                       initCommands=None, preRunCommands=None,
+                       stopCommands=None, exitCommands=None,
+                       attachCommands=None):
+        args_dict = {}
+        if pid is not None:
+            args_dict['pid'] = pid
+        if program is not None:
+            args_dict['program'] = program
+        if waitFor is not None:
+            args_dict['waitFor'] = waitFor
+        if trace:
+            args_dict['trace'] = trace
+        args_dict['initCommands'] = [
+            'settings set symbols.enable-external-lookup false']
+        if initCommands:
+            args_dict['initCommands'].extend(initCommands)
+        if preRunCommands:
+            args_dict['preRunCommands'] = preRunCommands
+        if stopCommands:
+            args_dict['stopCommands'] = stopCommands
+        if exitCommands:
+            args_dict['exitCommands'] = exitCommands
+        if attachCommands:
+            args_dict['attachCommands'] = attachCommands
+        command_dict = {
+            'command': 'attach',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        return self.send_recv(command_dict)
+
+    def request_configurationDone(self):
+        command_dict = {
+            'command': 'configurationDone',
+            'type': 'request',
+            'arguments': {}
+        }
+        response = self.send_recv(command_dict)
+        if response:
+            self.configuration_done_sent = True
+        return response
+
+    def _process_stopped(self):
+        self.threads = None
+        self.frame_scopes = {}
+
+    def request_continue(self, threadId=None):
+        if self.exit_status is not None:
+            raise ValueError('request_continue called after process exited')
+        # If we have launched or attached, then the first continue is done by
+        # sending the 'configurationDone' request
+        if not self.configuration_done_sent:
+            return self.request_configurationDone()
+        args_dict = {}
+        if threadId is None:
+            threadId = self.get_thread_id()
+        args_dict['threadId'] = threadId
+        command_dict = {
+            'command': 'continue',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        response = self.send_recv(command_dict)
+        recv_packets = []
+        self.recv_condition.acquire()
+        for event in self.recv_packets:
+            if event['event'] != 'stopped':
+                recv_packets.append(event)
+        self.recv_packets = recv_packets
+        self.recv_condition.release()
+        return response
+
+    def request_disconnect(self, terminateDebuggee=None):
+        args_dict = {}
+        if terminateDebuggee is not None:
+            if terminateDebuggee:
+                args_dict['terminateDebuggee'] = True
+            else:
+                args_dict['terminateDebuggee'] = False
+        command_dict = {
+            'command': 'disconnect',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        return self.send_recv(command_dict)
+
+    def request_evaluate(self, expression, frameIndex=0, threadId=None):
+        stackFrame = self.get_stackFrame(frameIndex=frameIndex,
+                                         threadId=threadId)
+        if stackFrame is None:
+            return []
+        args_dict = {
+            'expression': expression,
+            'frameId': stackFrame['id'],
+        }
+        command_dict = {
+            'command': 'evaluate',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        return self.send_recv(command_dict)
+
+    def request_initialize(self):
+        command_dict = {
+            'command': 'initialize',
+            'type': 'request',
+            'arguments': {
+                'adapterID': 'lldb-native',
+                'clientID': 'vscode',
+                'columnsStartAt1': True,
+                'linesStartAt1': True,
+                'locale': 'en-us',
+                'pathFormat': 'path',
+                'supportsRunInTerminalRequest': True,
+                'supportsVariablePaging': True,
+                'supportsVariableType': True
+            }
+        }
+        response = self.send_recv(command_dict)
+        if response:
+            if 'body' in response:
+                self.initialize_body = response['body']
+        return response
+
+    def request_launch(self, program, args=None, cwd=None, env=None,
+                       stopOnEntry=False, disableASLR=True,
+                       disableSTDIO=False, shellExpandArguments=False,
+                       trace=False, initCommands=None, preRunCommands=None,
+                       stopCommands=None, exitCommands=None, sourcePath=None,
+                       debuggerRoot=None):
+        args_dict = {
+            'program': program
+        }
+        if args:
+            args_dict['args'] = args
+        if cwd:
+            args_dict['cwd'] = cwd
+        if env:
+            args_dict['env'] = env
+        if stopOnEntry:
+            args_dict['stopOnEntry'] = stopOnEntry
+        if disableASLR:
+            args_dict['disableASLR'] = disableASLR
+        if disableSTDIO:
+            args_dict['disableSTDIO'] = disableSTDIO
+        if shellExpandArguments:
+            args_dict['shellExpandArguments'] = shellExpandArguments
+        if trace:
+            args_dict['trace'] = trace
+        args_dict['initCommands'] = [
+            'settings set symbols.enable-external-lookup false']
+        if initCommands:
+            args_dict['initCommands'].extend(initCommands)
+        if preRunCommands:
+            args_dict['preRunCommands'] = preRunCommands
+        if stopCommands:
+            args_dict['stopCommands'] = stopCommands
+        if exitCommands:
+            args_dict['exitCommands'] = exitCommands
+        if sourcePath:
+            args_dict['sourcePath'] = sourcePath
+        if debuggerRoot:
+            args_dict['debuggerRoot'] = debuggerRoot
+        command_dict = {
+            'command': 'launch',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        response = self.send_recv(command_dict)
+
+        # Wait for a 'process' and 'initialized' event in any order
+        self.wait_for_event(filter=['process', 'initialized'])
+        self.wait_for_event(filter=['process', 'initialized'])
+        return response
+
+    def request_next(self, threadId):
+        if self.exit_status is not None:
+            raise ValueError('request_continue called after process exited')
+        args_dict = {'threadId': threadId}
+        command_dict = {
+            'command': 'next',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        return self.send_recv(command_dict)
+
+    def request_stepIn(self, threadId):
+        if self.exit_status is not None:
+            raise ValueError('request_continue called after process exited')
+        args_dict = {'threadId': threadId}
+        command_dict = {
+            'command': 'stepIn',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        return self.send_recv(command_dict)
+
+    def request_stepOut(self, threadId):
+        if self.exit_status is not None:
+            raise ValueError('request_continue called after process exited')
+        args_dict = {'threadId': threadId}
+        command_dict = {
+            'command': 'stepOut',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        return self.send_recv(command_dict)
+
+    def request_pause(self, threadId=None):
+        if self.exit_status is not None:
+            raise ValueError('request_continue called after process exited')
+        if threadId is None:
+            threadId = self.get_thread_id()
+        args_dict = {'threadId': threadId}
+        command_dict = {
+            'command': 'pause',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        return self.send_recv(command_dict)
+
+    def request_scopes(self, frameId):
+        args_dict = {'frameId': frameId}
+        command_dict = {
+            'command': 'scopes',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        return self.send_recv(command_dict)
+
+    def request_setBreakpoints(self, file_path, line_array, condition=None,
+                               hitCondition=None):
+        (dir, base) = os.path.split(file_path)
+        breakpoints = []
+        for line in line_array:
+            bp = {'line': line}
+            if condition is not None:
+                bp['condition'] = condition
+            if hitCondition is not None:
+                bp['hitCondition'] = hitCondition
+            breakpoints.append(bp)
+        source_dict = {
+            'name': base,
+            'path': file_path
+        }
+        args_dict = {
+            'source': source_dict,
+            'breakpoints': breakpoints,
+            'lines': '%s' % (line_array),
+            'sourceModified': False,
+        }
+        command_dict = {
+            'command': 'setBreakpoints',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        return self.send_recv(command_dict)
+
+    def request_setExceptionBreakpoints(self, filters):
+        args_dict = {'filters': filters}
+        command_dict = {
+            'command': 'setExceptionBreakpoints',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        return self.send_recv(command_dict)
+
+    def request_setFunctionBreakpoints(self, names, condition=None,
+                                       hitCondition=None):
+        breakpoints = []
+        for name in names:
+            bp = {'name': name}
+            if condition is not None:
+                bp['condition'] = condition
+            if hitCondition is not None:
+                bp['hitCondition'] = hitCondition
+            breakpoints.append(bp)
+        args_dict = {'breakpoints': breakpoints}
+        command_dict = {
+            'command': 'setFunctionBreakpoints',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        return self.send_recv(command_dict)
+
+    def request_stackTrace(self, threadId=None, startFrame=None, levels=None,
+                           dump=False):
+        if threadId is None:
+            threadId = self.get_thread_id()
+        args_dict = {'threadId': threadId}
+        if startFrame is not None:
+            args_dict['startFrame'] = startFrame
+        if levels is not None:
+            args_dict['levels'] = levels
+        command_dict = {
+            'command': 'stackTrace',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        response = self.send_recv(command_dict)
+        if dump:
+            for (idx, frame) in enumerate(response['body']['stackFrames']):
+                name = frame['name']
+                if 'line' in frame and 'source' in frame:
+                    source = frame['source']
+                    if 'sourceReference' not in source:
+                        if 'name' in source:
+                            source_name = source['name']
+                            line = frame['line']
+                            print("[%3u] %s @ %s:%u" % (idx, name, source_name,
+                                                        line))
+                            continue
+                print("[%3u] %s" % (idx, name))
+        return response
+
+    def request_threads(self):
+        '''Request a list of all threads and combine any information from any
+           "stopped" events since those contain more information about why a
+           thread actually stopped. Returns an array of thread dictionaries
+           with information about all threads'''
+        command_dict = {
+            'command': 'threads',
+            'type': 'request',
+            'arguments': {}
+        }
+        response = self.send_recv(command_dict)
+        body = response['body']
+        # Fill in "self.threads" correctly so that clients that call
+        # self.get_threads() or self.get_thread_id(...) can get information
+        # on threads when the process is stopped.
+        if 'threads' in body:
+            self.threads = body['threads']
+            for thread in self.threads:
+                # Copy the thread dictionary so we can add key/value pairs to
+                # it without affecfting the original info from the "threads"
+                # command.
+                tid = thread['id']
+                if tid in self.thread_stop_reasons:
+                    thread_stop_info = self.thread_stop_reasons[tid]
+                    copy_keys = ['reason', 'description', 'text']
+                    for key in copy_keys:
+                        if key in thread_stop_info:
+                            thread[key] = thread_stop_info[key]
+        else:
+            self.threads = None
+        return response
+
+    def request_variables(self, variablesReference, start=None, count=None):
+        args_dict = {'variablesReference': variablesReference}
+        if start is not None:
+            args_dict['start'] = start
+        if count is not None:
+            args_dict['count'] = count
+        command_dict = {
+            'command': 'variables',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        return self.send_recv(command_dict)
+
+    def request_setVariable(self, containingVarRef, name, value, id=None):
+        args_dict = {
+            'variablesReference': containingVarRef,
+            'name': name,
+            'value': str(value)
+        }
+        if id is not None:
+            args_dict['id'] = id
+        command_dict = {
+            'command': 'setVariable',
+            'type': 'request',
+            'arguments': args_dict
+        }
+        return self.send_recv(command_dict)
+
+    def request_testGetTargetBreakpoints(self):
+        '''A request packet used in the LLDB test suite to get all currently
+           set breakpoint infos for all breakpoints currently set in the
+           target.
+        '''
+        command_dict = {
+            'command': '_testGetTargetBreakpoints',
+            'type': 'request',
+            'arguments': {}
+        }
+        return self.send_recv(command_dict)
+
+    def terminate(self):
+        self.send.close()
+        # self.recv.close()
+
+
+class DebugAdaptor(DebugCommunication):
+    def __init__(self, executable=None, port=None):
+        self.process = None
+        if executable is not None:
+            self.process = subprocess.Popen([executable],
+                                            stdin=subprocess.PIPE,
+                                            stdout=subprocess.PIPE,
+                                            stderr=subprocess.PIPE)
+            DebugCommunication.__init__(self, self.process.stdout,
+                                        self.process.stdin)
+        elif port is not None:
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            s.connect(('127.0.0.1', port))
+            DebugCommunication.__init__(self, s.makefile('r'), s.makefile('w'))
+
+    def get_pid(self):
+        if self.process:
+            return self.process.pid
+        return -1
+
+    def terminate(self):
+        super(DebugAdaptor, self).terminate()
+        if self.process is not None:
+            self.process.terminate()
+            self.process.wait()
+            self.process = None
+
+
+def attach_options_specified(options):
+    if options.pid is not None:
+        return True
+    if options.waitFor:
+        return True
+    if options.attach:
+        return True
+    if options.attachCmds:
+        return True
+    return False
+
+
+def run_vscode(dbg, args, options):
+    dbg.request_initialize()
+    if attach_options_specified(options):
+        response = dbg.request_attach(program=options.program,
+                                      pid=options.pid,
+                                      waitFor=options.waitFor,
+                                      attachCommands=options.attachCmds,
+                                      initCommands=options.initCmds,
+                                      preRunCommands=options.preRunCmds,
+                                      stopCommands=options.stopCmds,
+                                      exitCommands=options.exitCmds)
+    else:
+        response = dbg.request_launch(options.program,
+                                      args=args,
+                                      env=options.envs,
+                                      cwd=options.workingDir,
+                                      debuggerRoot=options.debuggerRoot,
+                                      sourcePath=options.sourcePath,
+                                      initCommands=options.initCmds,
+                                      preRunCommands=options.preRunCmds,
+                                      stopCommands=options.stopCmds,
+                                      exitCommands=options.exitCmds)
+
+    if response['success']:
+        if options.sourceBreakpoints:
+            source_to_lines = {}
+            for file_line in options.sourceBreakpoints:
+                (path, line) = file_line.split(':')
+                if len(path) == 0 or len(line) == 0:
+                    print('error: invalid source with line "%s"' %
+                          (file_line))
+
+                else:
+                    if path in source_to_lines:
+                        source_to_lines[path].append(int(line))
+                    else:
+                        source_to_lines[path] = [int(line)]
+            for source in source_to_lines:
+                dbg.request_setBreakpoints(source, source_to_lines[source])
+        if options.funcBreakpoints:
+            dbg.request_setFunctionBreakpoints(options.funcBreakpoints)
+        dbg.request_configurationDone()
+        dbg.wait_for_stopped()
+    else:
+        if 'message' in response:
+            print(response['message'])
+    dbg.request_disconnect(terminateDebuggee=True)
+
+
+def main():
+    parser = optparse.OptionParser(
+        description=('A testing framework for the Visual Studio Code Debug '
+                     'Adaptor protocol'))
+
+    parser.add_option(
+        '--vscode',
+        type='string',
+        dest='vscode_path',
+        help=('The path to the command line program that implements the '
+              'Visual Studio Code Debug Adaptor protocol.'),
+        default=None)
+
+    parser.add_option(
+        '--program',
+        type='string',
+        dest='program',
+        help='The path to the program to debug.',
+        default=None)
+
+    parser.add_option(
+        '--workingDir',
+        type='string',
+        dest='workingDir',
+        default=None,
+        help='Set the working directory for the process we launch.')
+
+    parser.add_option(
+        '--sourcePath',
+        type='string',
+        dest='sourcePath',
+        default=None,
+        help=('Set the relative source root for any debug info that has '
+              'relative paths in it.'))
+
+    parser.add_option(
+        '--debuggerRoot',
+        type='string',
+        dest='debuggerRoot',
+        default=None,
+        help=('Set the working directory for lldb-vscode for any object files '
+              'with relative paths in the Mach-o debug map.'))
+
+    parser.add_option(
+        '-r', '--replay',
+        type='string',
+        dest='replay',
+        help=('Specify a file containing a packet log to replay with the '
+              'current Visual Studio Code Debug Adaptor executable.'),
+        default=None)
+
+    parser.add_option(
+        '-g', '--debug',
+        action='store_true',
+        dest='debug',
+        default=False,
+        help='Pause waiting for a debugger to attach to the debug adaptor')
+
+    parser.add_option(
+        '--port',
+        type='int',
+        dest='port',
+        help="Attach a socket to a port instead of using STDIN for VSCode",
+        default=None)
+
+    parser.add_option(
+        '--pid',
+        type='int',
+        dest='pid',
+        help="The process ID to attach to",
+        default=None)
+
+    parser.add_option(
+        '--attach',
+        action='store_true',
+        dest='attach',
+        default=False,
+        help=('Specify this option to attach to a process by name. The '
+              'process name is the basanme of the executable specified with '
+              'the --program option.'))
+
+    parser.add_option(
+        '-f', '--function-bp',
+        type='string',
+        action='append',
+        dest='funcBreakpoints',
+        help=('Specify the name of a function to break at. '
+              'Can be specified more than once.'),
+        default=[])
+
+    parser.add_option(
+        '-s', '--source-bp',
+        type='string',
+        action='append',
+        dest='sourceBreakpoints',
+        default=[],
+        help=('Specify source breakpoints to set in the format of '
+              '<source>:<line>. '
+              'Can be specified more than once.'))
+
+    parser.add_option(
+        '--attachCommand',
+        type='string',
+        action='append',
+        dest='attachCmds',
+        default=[],
+        help=('Specify a LLDB command that will attach to a process. '
+              'Can be specified more than once.'))
+
+    parser.add_option(
+        '--initCommand',
+        type='string',
+        action='append',
+        dest='initCmds',
+        default=[],
+        help=('Specify a LLDB command that will be executed before the target '
+              'is created. Can be specified more than once.'))
+
+    parser.add_option(
+        '--preRunCommand',
+        type='string',
+        action='append',
+        dest='preRunCmds',
+        default=[],
+        help=('Specify a LLDB command that will be executed after the target '
+              'has been created. Can be specified more than once.'))
+
+    parser.add_option(
+        '--stopCommand',
+        type='string',
+        action='append',
+        dest='stopCmds',
+        default=[],
+        help=('Specify a LLDB command that will be executed each time the'
+              'process stops. Can be specified more than once.'))
+
+    parser.add_option(
+        '--exitCommand',
+        type='string',
+        action='append',
+        dest='exitCmds',
+        default=[],
+        help=('Specify a LLDB command that will be executed when the process '
+              'exits. Can be specified more than once.'))
+
+    parser.add_option(
+        '--env',
+        type='string',
+        action='append',
+        dest='envs',
+        default=[],
+        help=('Specify environment variables to pass to the launched '
+              'process.'))
+
+    parser.add_option(
+        '--waitFor',
+        action='store_true',
+        dest='waitFor',
+        default=False,
+        help=('Wait for the next process to be launched whose name matches '
+              'the basename of the program specified with the --program '
+              'option'))
+
+    (options, args) = parser.parse_args(sys.argv[1:])
+
+    if options.vscode_path is None and options.port is None:
+        print('error: must either specify a path to a Visual Studio Code '
+              'Debug Adaptor vscode executable path using the --vscode '
+              'option, or a port to attach to for an existing lldb-vscode '
+              'using the --port option')
+        return
+    dbg = DebugAdaptor(executable=options.vscode_path, port=options.port)
+    if options.debug:
+        raw_input('Waiting for debugger to attach pid "%i"' % (
+                  dbg.get_pid()))
+    if options.replay:
+        dbg.replay_packets(options.replay)
+    else:
+        run_vscode(dbg, args, options)
+    dbg.terminate()
+
+
+if __name__ == '__main__':
+    main()