| """ |
| Test that the lldb-mi driver understands MI command syntax. |
| """ |
| |
| from __future__ import print_function |
| |
| |
| import lldbmi_testcase |
| from lldbsuite.test.decorators import * |
| from lldbsuite.test.lldbtest import * |
| from lldbsuite.test import lldbutil |
| from functools import reduce |
| |
| |
| class MiSyntaxTestCase(lldbmi_testcase.MiTestCaseBase): |
| |
| mydir = TestBase.compute_mydir(__file__) |
| |
| @skipIfWindows # llvm.org/pr24452: Get lldb-mi tests working on Windows |
| @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races |
| @skipIfRemote # We do not currently support remote debugging via the MI. |
| @skipIfDarwin |
| def test_lldbmi_tokens(self): |
| """Test that 'lldb-mi --interpreter' prints command tokens.""" |
| |
| self.spawnLldbMi(args=None) |
| |
| # Load executable |
| self.runCmd("000-file-exec-and-symbols %s" % self.myexe) |
| self.expect("000\^done") |
| |
| # Run to main |
| self.runCmd("100000001-break-insert -f main") |
| self.expect("100000001\^done,bkpt={number=\"1\"") |
| self.runCmd("2-exec-run") |
| self.expect("2\^running") |
| self.expect("\*stopped,reason=\"breakpoint-hit\"") |
| |
| # Exit |
| self.runCmd("0000000000000000000003-exec-continue") |
| self.expect("0000000000000000000003\^running") |
| self.expect("\*stopped,reason=\"exited-normally\"") |
| |
| @skipIfWindows # llvm.org/pr24452: Get lldb-mi tests working on Windows |
| @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races |
| @skipIfRemote # We do not currently support remote debugging via the MI. |
| @skipIfDarwin |
| def test_lldbmi_specialchars(self): |
| """Test that 'lldb-mi --interpreter' handles complicated strings.""" |
| |
| # Create an alias for myexe |
| complicated_myexe = self.getBuildArtifact("C--mpl-x file's`s @#$%^&*()_+-={}[]| name") |
| os.symlink(self.myexe, complicated_myexe) |
| self.addTearDownHook(lambda: os.unlink(complicated_myexe)) |
| |
| self.spawnLldbMi(args="\"%s\"" % complicated_myexe) |
| |
| # Test that the executable was loaded |
| self.expect( |
| "-file-exec-and-symbols \"%s\"" % |
| complicated_myexe, exactly=True) |
| self.expect("\^done") |
| |
| # Check that it was loaded correctly |
| self.runCmd("-break-insert -f main") |
| self.expect("\^done,bkpt={number=\"1\"") |
| self.runCmd("-exec-run") |
| self.expect("\^running") |
| self.expect("\*stopped,reason=\"breakpoint-hit\"") |
| |
| @skipIfWindows # llvm.org/pr24452: Get lldb-mi tests working on Windows |
| @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races |
| @skipIfDarwin |
| @skipIfRemote # We do not currently support remote debugging via the MI. |
| def test_lldbmi_output_grammar(self): |
| """Test that 'lldb-mi --interpreter' uses standard output syntax.""" |
| |
| self.spawnLldbMi(args=None) |
| self.child.setecho(False) |
| |
| # Run all commands simultaneously |
| self.runCmd("-unknown-command") |
| self.runCmd("-interpreter-exec command help") |
| self.runCmd("-file-exec-and-symbols %s" % self.myexe) |
| self.runCmd("-break-insert -f main") |
| self.runCmd("-gdb-set target-async off") |
| self.runCmd("-exec-run") |
| self.runCmd("-gdb-set target-async on") |
| self.runCmd("-exec-continue") |
| self.runCmd("-gdb-exit") |
| |
| # Test that the program's output matches to the following pattern: |
| # ( async-record | stream-record )* [ result-record ] "(gdb)" nl |
| async_record = "^[0-9]*(\*|\+|=).+?\n" # 1 |
| stream_record = "^(~|@|&).+?\n" # 2 |
| result_record = "^[0-9]*\^.+?\n" # 3 |
| prompt = "^\(gdb\)\r\n" # 4 |
| command = "^\r\n" # 5 (it looks like empty line for pexpect) |
| error = "^.+?\n" # 6 |
| import pexpect # 7 (EOF) |
| all_patterns = [ |
| async_record, |
| stream_record, |
| result_record, |
| prompt, |
| command, |
| error, |
| pexpect.EOF] |
| |
| # Routines to get a bit-mask for the specified list of patterns |
| def get_bit(pattern): return all_patterns.index(pattern) |
| def get_mask(pattern): return 1 << get_bit(pattern) |
| def or_op(x, y): return x | y |
| def get_state(*args): return reduce(or_op, map(get_mask, args)) |
| |
| next_state = get_state(command) |
| while True: |
| it = self.expect(all_patterns) |
| matched_pattern = all_patterns[it] |
| |
| # Check that state is acceptable |
| if not (next_state & get_mask(matched_pattern)): |
| self.fail( |
| "error: inconsistent pattern '%s' for state %#x (matched string: %s)" % |
| (repr(matched_pattern), next_state, self.child.after)) |
| elif matched_pattern == async_record or matched_pattern == stream_record: |
| next_state = get_state( |
| async_record, |
| stream_record, |
| result_record, |
| prompt) |
| elif matched_pattern == result_record: |
| # FIXME lldb-mi prints async-records out of turn |
| # ``` |
| # ^done |
| # (gdb) |
| # ^running |
| # =thread-group-started,id="i1",pid="13875" |
| # (gdb) |
| # ``` |
| # Therefore to pass that test I changed the grammar's rule: |
| # next_state = get_state(prompt) |
| # to: |
| next_state = get_state(async_record, prompt) |
| elif matched_pattern == prompt: |
| # FIXME lldb-mi prints the prompt out of turn |
| # ``` |
| # ^done |
| # (gdb) |
| # ^running |
| # (gdb) |
| # (gdb) |
| # ``` |
| # Therefore to pass that test I changed the grammar's rule: |
| # next_state = get_state(async_record, stream_record, result_record, command, pexpect.EOF) |
| # to: |
| next_state = get_state( |
| async_record, |
| stream_record, |
| result_record, |
| prompt, |
| command, |
| pexpect.EOF) |
| elif matched_pattern == command: |
| next_state = get_state( |
| async_record, |
| stream_record, |
| result_record) |
| elif matched_pattern == pexpect.EOF: |
| break |
| else: |
| self.fail("error: pexpect returned an unknown state") |
