[lldb] Restructure test folders to match LLDB command hierarchy

Summary:
As discussed on lldb-dev, this patch moves some LLDB tests into a hierarchy that more closely
resembles the commands we use in the LLDB interpreter. This patch should only move tests
that use the command interpreter and shouldn't touch any tests that primarily test the SB API.

Reviewers: #lldb, jfb, JDevlieghere

Reviewed By: #lldb, JDevlieghere

Subscribers: dexonsmith, arphaman, JDevlieghere, lldb-commits

Tags: #lldb

Differential Revision: https://reviews.llvm.org/D67033

llvm-svn: 370605

1 files changed, 440 insertions, 0 deletions

diff --git a/lldb/packages/Python/lldbsuite/test/commands/target/basic/TestTargetCommand.py b/lldb/packages/Python/lldbsuite/test/commands/target/basic/TestTargetCommand.py
new file mode 100644
index 00000000000..c16c6b46dc8
--- /dev/null
+++ b/lldb/packages/Python/lldbsuite/test/commands/target/basic/TestTargetCommand.py
@@ -0,0 +1,440 @@
+"""
+Test some target commands: create, list, select, variable.
+"""
+
+from __future__ import print_function
+import os
+import stat
+import tempfile
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class targetCommandTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line numbers for our breakpoints.
+        self.line_b = line_number('b.c', '// Set break point at this line.')
+        self.line_c = line_number('c.c', '// Set break point at this line.')
+
+    def buildB(self):
+        db = {'C_SOURCES': 'b.c', 'EXE': self.getBuildArtifact('b.out')}
+        self.build(dictionary=db)
+        self.addTearDownCleanup(dictionary=db)
+
+    def buildAll(self):
+        da = {'C_SOURCES': 'a.c', 'EXE': self.getBuildArtifact('a.out')}
+        self.build(dictionary=da)
+        self.addTearDownCleanup(dictionary=da)
+
+        self.buildB()
+
+        dc = {'C_SOURCES': 'c.c', 'EXE': self.getBuildArtifact('c.out')}
+        self.build(dictionary=dc)
+        self.addTearDownCleanup(dictionary=dc)
+
+    def test_target_command(self):
+        """Test some target commands: create, list, select."""
+        self.buildAll()
+        self.do_target_command()
+
+    def test_target_variable_command(self):
+        """Test 'target variable' command before and after starting the inferior."""
+        d = {'C_SOURCES': 'globals.c', 'EXE': self.getBuildArtifact('globals')}
+        self.build(dictionary=d)
+        self.addTearDownCleanup(dictionary=d)
+
+        self.do_target_variable_command('globals')
+
+    def test_target_variable_command_no_fail(self):
+        """Test 'target variable' command before and after starting the inferior."""
+        d = {'C_SOURCES': 'globals.c', 'EXE': self.getBuildArtifact('globals')}
+        self.build(dictionary=d)
+        self.addTearDownCleanup(dictionary=d)
+
+        self.do_target_variable_command_no_fail('globals')
+
+    def do_target_command(self):
+        """Exercise 'target create', 'target list', 'target select' commands."""
+        exe_a = self.getBuildArtifact("a.out")
+        exe_b = self.getBuildArtifact("b.out")
+        exe_c = self.getBuildArtifact("c.out")
+
+        self.runCmd("target list")
+        output = self.res.GetOutput()
+        if output.startswith("No targets"):
+            # We start from index 0.
+            base = 0
+        else:
+            # Find the largest index of the existing list.
+            import re
+            pattern = re.compile("target #(\d+):")
+            for line in reversed(output.split(os.linesep)):
+                match = pattern.search(line)
+                if match:
+                    # We will start from (index + 1) ....
+                    base = int(match.group(1), 10) + 1
+                    #print("base is:", base)
+                    break
+
+        self.runCmd("target create " + exe_a, CURRENT_EXECUTABLE_SET)
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        self.runCmd("target create " + exe_b, CURRENT_EXECUTABLE_SET)
+        lldbutil.run_break_set_by_file_and_line(
+            self, 'b.c', self.line_b, num_expected_locations=1, loc_exact=True)
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        self.runCmd("target create " + exe_c, CURRENT_EXECUTABLE_SET)
+        lldbutil.run_break_set_by_file_and_line(
+            self, 'c.c', self.line_c, num_expected_locations=1, loc_exact=True)
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        self.runCmd("target list")
+
+        self.runCmd("target select %d" % base)
+        self.runCmd("thread backtrace")
+
+        self.runCmd("target select %d" % (base + 2))
+        self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
+                    substrs=['c.c:%d' % self.line_c,
+                             'stop reason = breakpoint'])
+
+        self.runCmd("target select %d" % (base + 1))
+        self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
+                    substrs=['b.c:%d' % self.line_b,
+                             'stop reason = breakpoint'])
+
+        self.runCmd("target list")
+
+    def do_target_variable_command(self, exe_name):
+        """Exercise 'target variable' command before and after starting the inferior."""
+        self.runCmd("file " + self.getBuildArtifact(exe_name),
+                    CURRENT_EXECUTABLE_SET)
+
+        self.expect(
+            "target variable my_global_char",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=[
+                "my_global_char",
+                "'X'"])
+        self.expect(
+            "target variable my_global_str",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=[
+                'my_global_str',
+                '"abc"'])
+        self.expect(
+            "target variable my_static_int",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=[
+                'my_static_int',
+                '228'])
+        self.expect("target variable my_global_str_ptr", matching=False,
+                    substrs=['"abc"'])
+        self.expect("target variable *my_global_str_ptr", matching=True,
+                    substrs=['"abc"'])
+        self.expect(
+            "target variable *my_global_str",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=['a'])
+
+        self.runCmd("b main")
+        self.runCmd("run")
+
+        self.expect(
+            "target variable my_global_str",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=[
+                'my_global_str',
+                '"abc"'])
+        self.expect(
+            "target variable my_static_int",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=[
+                'my_static_int',
+                '228'])
+        self.expect("target variable my_global_str_ptr", matching=False,
+                    substrs=['"abc"'])
+        self.expect("target variable *my_global_str_ptr", matching=True,
+                    substrs=['"abc"'])
+        self.expect(
+            "target variable *my_global_str",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=['a'])
+        self.expect(
+            "target variable my_global_char",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=[
+                "my_global_char",
+                "'X'"])
+
+        self.runCmd("c")
+
+        # rdar://problem/9763907
+        # 'target variable' command fails if the target program has been run
+        self.expect(
+            "target variable my_global_str",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=[
+                'my_global_str',
+                '"abc"'])
+        self.expect(
+            "target variable my_static_int",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=[
+                'my_static_int',
+                '228'])
+        self.expect("target variable my_global_str_ptr", matching=False,
+                    substrs=['"abc"'])
+        self.expect("target variable *my_global_str_ptr", matching=True,
+                    substrs=['"abc"'])
+        self.expect(
+            "target variable *my_global_str",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=['a'])
+        self.expect(
+            "target variable my_global_char",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=[
+                "my_global_char",
+                "'X'"])
+
+    def do_target_variable_command_no_fail(self, exe_name):
+        """Exercise 'target variable' command before and after starting the inferior."""
+        self.runCmd("file " + self.getBuildArtifact(exe_name),
+                    CURRENT_EXECUTABLE_SET)
+
+        self.expect(
+            "target variable my_global_char",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=[
+                "my_global_char",
+                "'X'"])
+        self.expect(
+            "target variable my_global_str",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=[
+                'my_global_str',
+                '"abc"'])
+        self.expect(
+            "target variable my_static_int",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=[
+                'my_static_int',
+                '228'])
+        self.expect("target variable my_global_str_ptr", matching=False,
+                    substrs=['"abc"'])
+        self.expect("target variable *my_global_str_ptr", matching=True,
+                    substrs=['"abc"'])
+        self.expect(
+            "target variable *my_global_str",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=['a'])
+
+        self.runCmd("b main")
+        self.runCmd("run")
+
+        # New feature: you don't need to specify the variable(s) to 'target vaiable'.
+        # It will find all the global and static variables in the current
+        # compile unit.
+        self.expect("target variable",
+                    substrs=['my_global_char',
+                             'my_global_str',
+                             'my_global_str_ptr',
+                             'my_static_int'])
+
+        self.expect(
+            "target variable my_global_str",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=[
+                'my_global_str',
+                '"abc"'])
+        self.expect(
+            "target variable my_static_int",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=[
+                'my_static_int',
+                '228'])
+        self.expect("target variable my_global_str_ptr", matching=False,
+                    substrs=['"abc"'])
+        self.expect("target variable *my_global_str_ptr", matching=True,
+                    substrs=['"abc"'])
+        self.expect(
+            "target variable *my_global_str",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=['a'])
+        self.expect(
+            "target variable my_global_char",
+            VARIABLES_DISPLAYED_CORRECTLY,
+            substrs=[
+                "my_global_char",
+                "'X'"])
+
+    @no_debug_info_test
+    def test_target_stop_hook_disable_enable(self):
+        self.buildB()
+        self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET)
+
+        self.expect("target stop-hook disable 1", error=True, substrs=['unknown stop hook id: "1"'])
+        self.expect("target stop-hook disable blub", error=True, substrs=['invalid stop hook id: "blub"'])
+        self.expect("target stop-hook enable 1", error=True, substrs=['unknown stop hook id: "1"'])
+        self.expect("target stop-hook enable blub", error=True, substrs=['invalid stop hook id: "blub"'])
+
+    @no_debug_info_test
+    def test_target_stop_hook_delete(self):
+        self.buildB()
+        self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET)
+
+        self.expect("target stop-hook delete 1", error=True, substrs=['unknown stop hook id: "1"'])
+        self.expect("target stop-hook delete blub", error=True, substrs=['invalid stop hook id: "blub"'])
+
+    @no_debug_info_test
+    def test_target_list_args(self):
+        self.expect("target list blub", error=True,
+                    substrs=["the 'target list' command takes no arguments"])
+
+    @no_debug_info_test
+    def test_target_select_no_index(self):
+        self.expect("target select", error=True,
+                    substrs=["'target select' takes a single argument: a target index"])
+
+    @no_debug_info_test
+    def test_target_select_invalid_index(self):
+        self.runCmd("target delete --all")
+        self.expect("target select 0", error=True,
+                    substrs=["index 0 is out of range since there are no active targets"])
+        self.buildB()
+        self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET)
+        self.expect("target select 1", error=True,
+                    substrs=["index 1 is out of range, valid target indexes are 0 - 0"])
+
+
+    @no_debug_info_test
+    def test_target_create_multiple_args(self):
+        self.expect("target create a b", error=True,
+                    substrs=["'target create' takes exactly one executable path"])
+
+    @no_debug_info_test
+    def test_target_create_nonexistent_core_file(self):
+        self.expect("target create -c doesntexist", error=True,
+                    substrs=["core file 'doesntexist' doesn't exist"])
+
+    # Write only files don't seem to be supported on Windows.
+    @skipIfWindows
+    @no_debug_info_test
+    def test_target_create_unreadable_core_file(self):
+        tf = tempfile.NamedTemporaryFile()
+        os.chmod(tf.name, stat.S_IWRITE)
+        self.expect("target create -c '" + tf.name + "'", error=True,
+                    substrs=["core file '", "' is not readable"])
+
+    @no_debug_info_test
+    def test_target_create_nonexistent_sym_file(self):
+        self.expect("target create -s doesntexist doesntexisteither", error=True,
+                    substrs=["invalid symbol file path 'doesntexist'"])
+
+    @skipIfWindows
+    @no_debug_info_test
+    def test_target_create_invalid_core_file(self):
+        invalid_core_path = os.path.join(self.getSourceDir(), "invalid_core_file")
+        self.expect("target create -c '" + invalid_core_path + "'", error=True,
+                    substrs=["Unable to find process plug-in for core file '"])
+
+
+    # Write only files don't seem to be supported on Windows.
+    @skipIfWindows
+    @no_debug_info_test
+    def test_target_create_unreadable_sym_file(self):
+        tf = tempfile.NamedTemporaryFile()
+        os.chmod(tf.name, stat.S_IWRITE)
+        self.expect("target create -s '" + tf.name + "' no_exe", error=True,
+                    substrs=["symbol file '", "' is not readable"])
+
+    @no_debug_info_test
+    def test_target_delete_all(self):
+        self.buildAll()
+        self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
+        self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET)
+        self.expect("target delete --all")
+        self.expect("target list", substrs=["No targets."])
+
+    @no_debug_info_test
+    def test_target_delete_by_index(self):
+        self.buildAll()
+        self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
+        self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET)
+        self.runCmd("file " + self.getBuildArtifact("c.out"), CURRENT_EXECUTABLE_SET)
+        self.expect("target delete 3", error=True,
+                    substrs=["target index 3 is out of range, valid target indexes are 0 - 2"])
+
+        self.runCmd("target delete 1")
+        self.expect("target list", matching=False, substrs=["b.out"])
+        self.runCmd("target delete 1")
+        self.expect("target list", matching=False, substrs=["c.out"])
+
+        self.expect("target delete 1", error=True,
+                    substrs=["target index 1 is out of range, the only valid index is 0"])
+
+        self.runCmd("target delete 0")
+        self.expect("target list", matching=False, substrs=["a.out"])
+
+        self.expect("target delete 0", error=True, substrs=["no targets to delete"])
+        self.expect("target delete 1", error=True, substrs=["no targets to delete"])
+
+    @no_debug_info_test
+    def test_target_delete_by_index_multiple(self):
+        self.buildAll()
+        self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
+        self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET)
+        self.runCmd("file " + self.getBuildArtifact("c.out"), CURRENT_EXECUTABLE_SET)
+
+        self.expect("target delete 0 1 2 3", error=True,
+                    substrs=["target index 3 is out of range, valid target indexes are 0 - 2"])
+        self.expect("target list", substrs=["a.out", "b.out", "c.out"])
+
+        self.runCmd("target delete 0 1 2")
+        self.expect("target list", matching=False, substrs=["a.out", "c.out"])
+
+    @no_debug_info_test
+    def test_target_delete_selected(self):
+        self.buildAll()
+        self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
+        self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET)
+        self.runCmd("file " + self.getBuildArtifact("c.out"), CURRENT_EXECUTABLE_SET)
+        self.runCmd("target select 1")
+        self.runCmd("target delete")
+        self.expect("target list", matching=False, substrs=["b.out"])
+        self.runCmd("target delete")
+        self.runCmd("target delete")
+        self.expect("target list", substrs=["No targets."])
+        self.expect("target delete", error=True, substrs=["no target is currently selected"])
+
+    @no_debug_info_test
+    def test_target_modules_search_paths_clear(self):
+        self.buildB()
+        self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET)
+        self.runCmd("target modules search-paths add foo bar")
+        self.runCmd("target modules search-paths add foz baz")
+        self.runCmd("target modules search-paths clear")
+        self.expect("target list", matching=False, substrs=["bar", "baz"])
+
+    @no_debug_info_test
+    def test_target_modules_search_paths_query(self):
+        self.buildB()
+        self.runCmd("file " + self.getBuildArtifact("b.out"), CURRENT_EXECUTABLE_SET)
+        self.runCmd("target modules search-paths add foo bar")
+        self.expect("target modules search-paths query foo", substrs=["bar"])
+        # Query something that doesn't exist.
+        self.expect("target modules search-paths query faz", substrs=["faz"])
+
+        # Invalid arguments.
+        self.expect("target modules search-paths query faz baz", error=True,
+                    substrs=["query requires one argument"])