2010-12-10 02:22:12 +08:00
|
|
|
"""
|
|
|
|
Test lldb core component: SourceManager.
|
|
|
|
|
|
|
|
Test cases:
|
2010-12-10 06:06:05 +08:00
|
|
|
|
2010-12-11 09:20:39 +08:00
|
|
|
o test_display_source_python:
|
|
|
|
Test display of source using the SBSourceManager API.
|
2010-12-10 06:06:05 +08:00
|
|
|
o test_modify_source_file_while_debugging:
|
|
|
|
Test the caching mechanism of the source manager.
|
2010-12-10 02:22:12 +08:00
|
|
|
"""
|
|
|
|
|
2015-10-24 01:04:29 +08:00
|
|
|
from __future__ import print_function
|
add stop column highlighting support
This change introduces optional marking of the column within a source
line where a thread is stopped. This marking will show up when the
source code for a thread stop is displayed, when the debug info
knows the column information, and if the optional column marking is
enabled.
There are two separate methods for handling the marking of the stop
column:
* via ANSI terminal codes, which are added inline to the source line
display. The default ANSI mark-up is to underline the column.
* via a pure text-based caret that is added in the appropriate column
in a newly-inserted blank line underneath the source line in
question.
There are some new options that control how this all works.
* settings set stop-show-column
This takes one of 4 values:
* ansi-or-caret: use the ANSI terminal code mechanism if LLDB
is running with color enabled; if not, use the caret-based,
pure text method (see the "caret" mode below).
* ansi: only use the ANSI terminal code mechanism to highlight
the stop line. If LLDB is running with color disabled, no
stop column marking will occur.
* caret: only use the pure text caret method, which introduces
a newly-inserted line underneath the current line, where
the only character in the new line is a caret that highlights
the stop column in question.
* none: no stop column marking will be attempted.
* settings set stop-show-column-ansi-prefix
This is a text format that indicates the ANSI formatting
code to insert into the stream immediately preceding the
column where the stop column character will be marked up.
It defaults to ${ansi.underline}; however, it can contain
any valid LLDB format codes, e.g.
${ansi.fg.red}${ansi.bold}${ansi.underline}
* settings set stop-show-column-ansi-suffix
This is the text format that specifies the ANSI terminal
codes to end the markup that was started with the prefix
described above. It defaults to: ${ansi.normal}. This
should be sufficient for the common cases.
Significant leg-work was done by Adrian Prantl. (Thanks, Adrian!)
differential review: https://reviews.llvm.org/D20835
reviewers: clayborg, jingham
llvm-svn: 282105
2016-09-22 04:13:14 +08:00
|
|
|
import re
|
2015-11-04 03:20:39 +08:00
|
|
|
|
2010-12-10 02:38:52 +08:00
|
|
|
import lldb
|
2016-02-05 07:04:17 +08:00
|
|
|
from lldbsuite.test.decorators import *
|
2015-11-03 10:06:18 +08:00
|
|
|
from lldbsuite.test.lldbtest import *
|
2016-02-05 07:04:17 +08:00
|
|
|
from lldbsuite.test import lldbutil
|
2010-12-10 02:22:12 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
|
add stop column highlighting support
This change introduces optional marking of the column within a source
line where a thread is stopped. This marking will show up when the
source code for a thread stop is displayed, when the debug info
knows the column information, and if the optional column marking is
enabled.
There are two separate methods for handling the marking of the stop
column:
* via ANSI terminal codes, which are added inline to the source line
display. The default ANSI mark-up is to underline the column.
* via a pure text-based caret that is added in the appropriate column
in a newly-inserted blank line underneath the source line in
question.
There are some new options that control how this all works.
* settings set stop-show-column
This takes one of 4 values:
* ansi-or-caret: use the ANSI terminal code mechanism if LLDB
is running with color enabled; if not, use the caret-based,
pure text method (see the "caret" mode below).
* ansi: only use the ANSI terminal code mechanism to highlight
the stop line. If LLDB is running with color disabled, no
stop column marking will occur.
* caret: only use the pure text caret method, which introduces
a newly-inserted line underneath the current line, where
the only character in the new line is a caret that highlights
the stop column in question.
* none: no stop column marking will be attempted.
* settings set stop-show-column-ansi-prefix
This is a text format that indicates the ANSI formatting
code to insert into the stream immediately preceding the
column where the stop column character will be marked up.
It defaults to ${ansi.underline}; however, it can contain
any valid LLDB format codes, e.g.
${ansi.fg.red}${ansi.bold}${ansi.underline}
* settings set stop-show-column-ansi-suffix
This is the text format that specifies the ANSI terminal
codes to end the markup that was started with the prefix
described above. It defaults to: ${ansi.normal}. This
should be sufficient for the common cases.
Significant leg-work was done by Adrian Prantl. (Thanks, Adrian!)
differential review: https://reviews.llvm.org/D20835
reviewers: clayborg, jingham
llvm-svn: 282105
2016-09-22 04:13:14 +08:00
|
|
|
def ansi_underline_surround_regex(inner_regex_text):
|
|
|
|
# return re.compile(r"\[4m%s\[0m" % inner_regex_text)
|
|
|
|
return "4.+\033\\[4m%s\033\\[0m" % inner_regex_text
|
|
|
|
|
|
|
|
|
2010-12-10 02:22:12 +08:00
|
|
|
class SourceManagerTestCase(TestBase):
|
|
|
|
|
2013-12-11 07:19:29 +08:00
|
|
|
mydir = TestBase.compute_mydir(__file__)
|
2010-12-10 02:22:12 +08:00
|
|
|
|
add stop column highlighting support
This change introduces optional marking of the column within a source
line where a thread is stopped. This marking will show up when the
source code for a thread stop is displayed, when the debug info
knows the column information, and if the optional column marking is
enabled.
There are two separate methods for handling the marking of the stop
column:
* via ANSI terminal codes, which are added inline to the source line
display. The default ANSI mark-up is to underline the column.
* via a pure text-based caret that is added in the appropriate column
in a newly-inserted blank line underneath the source line in
question.
There are some new options that control how this all works.
* settings set stop-show-column
This takes one of 4 values:
* ansi-or-caret: use the ANSI terminal code mechanism if LLDB
is running with color enabled; if not, use the caret-based,
pure text method (see the "caret" mode below).
* ansi: only use the ANSI terminal code mechanism to highlight
the stop line. If LLDB is running with color disabled, no
stop column marking will occur.
* caret: only use the pure text caret method, which introduces
a newly-inserted line underneath the current line, where
the only character in the new line is a caret that highlights
the stop column in question.
* none: no stop column marking will be attempted.
* settings set stop-show-column-ansi-prefix
This is a text format that indicates the ANSI formatting
code to insert into the stream immediately preceding the
column where the stop column character will be marked up.
It defaults to ${ansi.underline}; however, it can contain
any valid LLDB format codes, e.g.
${ansi.fg.red}${ansi.bold}${ansi.underline}
* settings set stop-show-column-ansi-suffix
This is the text format that specifies the ANSI terminal
codes to end the markup that was started with the prefix
described above. It defaults to: ${ansi.normal}. This
should be sufficient for the common cases.
Significant leg-work was done by Adrian Prantl. (Thanks, Adrian!)
differential review: https://reviews.llvm.org/D20835
reviewers: clayborg, jingham
llvm-svn: 282105
2016-09-22 04:13:14 +08:00
|
|
|
SOURCE_FILE = 'main.c'
|
|
|
|
|
|
|
|
NO_DEBUG_INFO_TESTCASE = True
|
|
|
|
|
2010-12-10 02:22:12 +08:00
|
|
|
def setUp(self):
|
|
|
|
# Call super's setUp().
|
|
|
|
TestBase.setUp(self)
|
|
|
|
# Find the line number to break inside main().
|
add stop column highlighting support
This change introduces optional marking of the column within a source
line where a thread is stopped. This marking will show up when the
source code for a thread stop is displayed, when the debug info
knows the column information, and if the optional column marking is
enabled.
There are two separate methods for handling the marking of the stop
column:
* via ANSI terminal codes, which are added inline to the source line
display. The default ANSI mark-up is to underline the column.
* via a pure text-based caret that is added in the appropriate column
in a newly-inserted blank line underneath the source line in
question.
There are some new options that control how this all works.
* settings set stop-show-column
This takes one of 4 values:
* ansi-or-caret: use the ANSI terminal code mechanism if LLDB
is running with color enabled; if not, use the caret-based,
pure text method (see the "caret" mode below).
* ansi: only use the ANSI terminal code mechanism to highlight
the stop line. If LLDB is running with color disabled, no
stop column marking will occur.
* caret: only use the pure text caret method, which introduces
a newly-inserted line underneath the current line, where
the only character in the new line is a caret that highlights
the stop column in question.
* none: no stop column marking will be attempted.
* settings set stop-show-column-ansi-prefix
This is a text format that indicates the ANSI formatting
code to insert into the stream immediately preceding the
column where the stop column character will be marked up.
It defaults to ${ansi.underline}; however, it can contain
any valid LLDB format codes, e.g.
${ansi.fg.red}${ansi.bold}${ansi.underline}
* settings set stop-show-column-ansi-suffix
This is the text format that specifies the ANSI terminal
codes to end the markup that was started with the prefix
described above. It defaults to: ${ansi.normal}. This
should be sufficient for the common cases.
Significant leg-work was done by Adrian Prantl. (Thanks, Adrian!)
differential review: https://reviews.llvm.org/D20835
reviewers: clayborg, jingham
llvm-svn: 282105
2016-09-22 04:13:14 +08:00
|
|
|
self.line = line_number(self.SOURCE_FILE, '// Set break point at this line.')
|
|
|
|
|
|
|
|
def get_expected_stop_column_number(self):
|
|
|
|
"""Return the 1-based column number of the first non-whitespace
|
|
|
|
character in the breakpoint source line."""
|
|
|
|
stop_line = get_line(self.SOURCE_FILE, self.line)
|
|
|
|
# The number of spaces that must be skipped to get to the first non-
|
|
|
|
# whitespace character --- where we expect the debugger breakpoint
|
|
|
|
# column to be --- is equal to the number of characters that get
|
|
|
|
# stripped off the front when we lstrip it, plus one to specify
|
|
|
|
# the character column after the initial whitespace.
|
|
|
|
return len(stop_line) - len(stop_line.lstrip()) + 1
|
|
|
|
|
|
|
|
def do_display_source_python_api(self, use_color, column_marker_regex):
|
2015-09-30 18:12:40 +08:00
|
|
|
self.build()
|
2018-01-20 07:24:35 +08:00
|
|
|
exe = self.getBuildArtifact("a.out")
|
2010-12-11 09:20:39 +08:00
|
|
|
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
|
|
|
|
|
|
|
|
target = self.dbg.CreateTarget(exe)
|
2011-05-25 02:22:45 +08:00
|
|
|
self.assertTrue(target, VALID_TARGET)
|
2010-12-11 09:20:39 +08:00
|
|
|
|
|
|
|
# Launch the process, and do not stop at the entry point.
|
add stop column highlighting support
This change introduces optional marking of the column within a source
line where a thread is stopped. This marking will show up when the
source code for a thread stop is displayed, when the debug info
knows the column information, and if the optional column marking is
enabled.
There are two separate methods for handling the marking of the stop
column:
* via ANSI terminal codes, which are added inline to the source line
display. The default ANSI mark-up is to underline the column.
* via a pure text-based caret that is added in the appropriate column
in a newly-inserted blank line underneath the source line in
question.
There are some new options that control how this all works.
* settings set stop-show-column
This takes one of 4 values:
* ansi-or-caret: use the ANSI terminal code mechanism if LLDB
is running with color enabled; if not, use the caret-based,
pure text method (see the "caret" mode below).
* ansi: only use the ANSI terminal code mechanism to highlight
the stop line. If LLDB is running with color disabled, no
stop column marking will occur.
* caret: only use the pure text caret method, which introduces
a newly-inserted line underneath the current line, where
the only character in the new line is a caret that highlights
the stop column in question.
* none: no stop column marking will be attempted.
* settings set stop-show-column-ansi-prefix
This is a text format that indicates the ANSI formatting
code to insert into the stream immediately preceding the
column where the stop column character will be marked up.
It defaults to ${ansi.underline}; however, it can contain
any valid LLDB format codes, e.g.
${ansi.fg.red}${ansi.bold}${ansi.underline}
* settings set stop-show-column-ansi-suffix
This is the text format that specifies the ANSI terminal
codes to end the markup that was started with the prefix
described above. It defaults to: ${ansi.normal}. This
should be sufficient for the common cases.
Significant leg-work was done by Adrian Prantl. (Thanks, Adrian!)
differential review: https://reviews.llvm.org/D20835
reviewers: clayborg, jingham
llvm-svn: 282105
2016-09-22 04:13:14 +08:00
|
|
|
args = None
|
|
|
|
envp = None
|
2016-09-07 04:57:50 +08:00
|
|
|
process = target.LaunchSimple(
|
add stop column highlighting support
This change introduces optional marking of the column within a source
line where a thread is stopped. This marking will show up when the
source code for a thread stop is displayed, when the debug info
knows the column information, and if the optional column marking is
enabled.
There are two separate methods for handling the marking of the stop
column:
* via ANSI terminal codes, which are added inline to the source line
display. The default ANSI mark-up is to underline the column.
* via a pure text-based caret that is added in the appropriate column
in a newly-inserted blank line underneath the source line in
question.
There are some new options that control how this all works.
* settings set stop-show-column
This takes one of 4 values:
* ansi-or-caret: use the ANSI terminal code mechanism if LLDB
is running with color enabled; if not, use the caret-based,
pure text method (see the "caret" mode below).
* ansi: only use the ANSI terminal code mechanism to highlight
the stop line. If LLDB is running with color disabled, no
stop column marking will occur.
* caret: only use the pure text caret method, which introduces
a newly-inserted line underneath the current line, where
the only character in the new line is a caret that highlights
the stop column in question.
* none: no stop column marking will be attempted.
* settings set stop-show-column-ansi-prefix
This is a text format that indicates the ANSI formatting
code to insert into the stream immediately preceding the
column where the stop column character will be marked up.
It defaults to ${ansi.underline}; however, it can contain
any valid LLDB format codes, e.g.
${ansi.fg.red}${ansi.bold}${ansi.underline}
* settings set stop-show-column-ansi-suffix
This is the text format that specifies the ANSI terminal
codes to end the markup that was started with the prefix
described above. It defaults to: ${ansi.normal}. This
should be sufficient for the common cases.
Significant leg-work was done by Adrian Prantl. (Thanks, Adrian!)
differential review: https://reviews.llvm.org/D20835
reviewers: clayborg, jingham
llvm-svn: 282105
2016-09-22 04:13:14 +08:00
|
|
|
args, envp, self.get_process_working_directory())
|
|
|
|
self.assertIsNotNone(process)
|
2010-12-11 09:20:39 +08:00
|
|
|
|
|
|
|
#
|
|
|
|
# Exercise Python APIs to display source lines.
|
|
|
|
#
|
|
|
|
|
add stop column highlighting support
This change introduces optional marking of the column within a source
line where a thread is stopped. This marking will show up when the
source code for a thread stop is displayed, when the debug info
knows the column information, and if the optional column marking is
enabled.
There are two separate methods for handling the marking of the stop
column:
* via ANSI terminal codes, which are added inline to the source line
display. The default ANSI mark-up is to underline the column.
* via a pure text-based caret that is added in the appropriate column
in a newly-inserted blank line underneath the source line in
question.
There are some new options that control how this all works.
* settings set stop-show-column
This takes one of 4 values:
* ansi-or-caret: use the ANSI terminal code mechanism if LLDB
is running with color enabled; if not, use the caret-based,
pure text method (see the "caret" mode below).
* ansi: only use the ANSI terminal code mechanism to highlight
the stop line. If LLDB is running with color disabled, no
stop column marking will occur.
* caret: only use the pure text caret method, which introduces
a newly-inserted line underneath the current line, where
the only character in the new line is a caret that highlights
the stop column in question.
* none: no stop column marking will be attempted.
* settings set stop-show-column-ansi-prefix
This is a text format that indicates the ANSI formatting
code to insert into the stream immediately preceding the
column where the stop column character will be marked up.
It defaults to ${ansi.underline}; however, it can contain
any valid LLDB format codes, e.g.
${ansi.fg.red}${ansi.bold}${ansi.underline}
* settings set stop-show-column-ansi-suffix
This is the text format that specifies the ANSI terminal
codes to end the markup that was started with the prefix
described above. It defaults to: ${ansi.normal}. This
should be sufficient for the common cases.
Significant leg-work was done by Adrian Prantl. (Thanks, Adrian!)
differential review: https://reviews.llvm.org/D20835
reviewers: clayborg, jingham
llvm-svn: 282105
2016-09-22 04:13:14 +08:00
|
|
|
# Setup whether we should use ansi escape sequences, including color
|
|
|
|
# and styles such as underline.
|
|
|
|
self.dbg.SetUseColor(use_color)
|
|
|
|
|
2010-12-11 09:20:39 +08:00
|
|
|
# Create the filespec for 'main.c'.
|
|
|
|
filespec = lldb.SBFileSpec('main.c', False)
|
|
|
|
source_mgr = self.dbg.GetSourceManager()
|
|
|
|
# Use a string stream as the destination.
|
|
|
|
stream = lldb.SBStream()
|
add stop column highlighting support
This change introduces optional marking of the column within a source
line where a thread is stopped. This marking will show up when the
source code for a thread stop is displayed, when the debug info
knows the column information, and if the optional column marking is
enabled.
There are two separate methods for handling the marking of the stop
column:
* via ANSI terminal codes, which are added inline to the source line
display. The default ANSI mark-up is to underline the column.
* via a pure text-based caret that is added in the appropriate column
in a newly-inserted blank line underneath the source line in
question.
There are some new options that control how this all works.
* settings set stop-show-column
This takes one of 4 values:
* ansi-or-caret: use the ANSI terminal code mechanism if LLDB
is running with color enabled; if not, use the caret-based,
pure text method (see the "caret" mode below).
* ansi: only use the ANSI terminal code mechanism to highlight
the stop line. If LLDB is running with color disabled, no
stop column marking will occur.
* caret: only use the pure text caret method, which introduces
a newly-inserted line underneath the current line, where
the only character in the new line is a caret that highlights
the stop column in question.
* none: no stop column marking will be attempted.
* settings set stop-show-column-ansi-prefix
This is a text format that indicates the ANSI formatting
code to insert into the stream immediately preceding the
column where the stop column character will be marked up.
It defaults to ${ansi.underline}; however, it can contain
any valid LLDB format codes, e.g.
${ansi.fg.red}${ansi.bold}${ansi.underline}
* settings set stop-show-column-ansi-suffix
This is the text format that specifies the ANSI terminal
codes to end the markup that was started with the prefix
described above. It defaults to: ${ansi.normal}. This
should be sufficient for the common cases.
Significant leg-work was done by Adrian Prantl. (Thanks, Adrian!)
differential review: https://reviews.llvm.org/D20835
reviewers: clayborg, jingham
llvm-svn: 282105
2016-09-22 04:13:14 +08:00
|
|
|
column = self.get_expected_stop_column_number()
|
|
|
|
context_before = 2
|
|
|
|
context_after = 2
|
|
|
|
current_line_prefix = "=>"
|
|
|
|
source_mgr.DisplaySourceLinesWithLineNumbersAndColumn(
|
|
|
|
filespec, self.line, column, context_before, context_after,
|
|
|
|
current_line_prefix, stream)
|
2010-12-11 09:20:39 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
# 2
|
2011-03-31 06:28:50 +08:00
|
|
|
# 3 int main(int argc, char const *argv[]) {
|
|
|
|
# => 4 printf("Hello world.\n"); // Set break point at this line.
|
|
|
|
# 5 return 0;
|
|
|
|
# 6 }
|
2010-12-11 09:20:39 +08:00
|
|
|
self.expect(stream.GetData(), "Source code displayed correctly",
|
|
|
|
exe=False,
|
add stop column highlighting support
This change introduces optional marking of the column within a source
line where a thread is stopped. This marking will show up when the
source code for a thread stop is displayed, when the debug info
knows the column information, and if the optional column marking is
enabled.
There are two separate methods for handling the marking of the stop
column:
* via ANSI terminal codes, which are added inline to the source line
display. The default ANSI mark-up is to underline the column.
* via a pure text-based caret that is added in the appropriate column
in a newly-inserted blank line underneath the source line in
question.
There are some new options that control how this all works.
* settings set stop-show-column
This takes one of 4 values:
* ansi-or-caret: use the ANSI terminal code mechanism if LLDB
is running with color enabled; if not, use the caret-based,
pure text method (see the "caret" mode below).
* ansi: only use the ANSI terminal code mechanism to highlight
the stop line. If LLDB is running with color disabled, no
stop column marking will occur.
* caret: only use the pure text caret method, which introduces
a newly-inserted line underneath the current line, where
the only character in the new line is a caret that highlights
the stop column in question.
* none: no stop column marking will be attempted.
* settings set stop-show-column-ansi-prefix
This is a text format that indicates the ANSI formatting
code to insert into the stream immediately preceding the
column where the stop column character will be marked up.
It defaults to ${ansi.underline}; however, it can contain
any valid LLDB format codes, e.g.
${ansi.fg.red}${ansi.bold}${ansi.underline}
* settings set stop-show-column-ansi-suffix
This is the text format that specifies the ANSI terminal
codes to end the markup that was started with the prefix
described above. It defaults to: ${ansi.normal}. This
should be sufficient for the common cases.
Significant leg-work was done by Adrian Prantl. (Thanks, Adrian!)
differential review: https://reviews.llvm.org/D20835
reviewers: clayborg, jingham
llvm-svn: 282105
2016-09-22 04:13:14 +08:00
|
|
|
patterns=['=> %d.*Hello world' % self.line,
|
|
|
|
column_marker_regex])
|
2011-12-20 08:41:28 +08:00
|
|
|
|
|
|
|
# Boundary condition testings for SBStream(). LLDB should not crash!
|
2012-10-06 03:14:57 +08:00
|
|
|
stream.Print(None)
|
2011-12-20 08:41:28 +08:00
|
|
|
stream.RedirectToFile(None, True)
|
2010-12-11 09:20:39 +08:00
|
|
|
|
add stop column highlighting support
This change introduces optional marking of the column within a source
line where a thread is stopped. This marking will show up when the
source code for a thread stop is displayed, when the debug info
knows the column information, and if the optional column marking is
enabled.
There are two separate methods for handling the marking of the stop
column:
* via ANSI terminal codes, which are added inline to the source line
display. The default ANSI mark-up is to underline the column.
* via a pure text-based caret that is added in the appropriate column
in a newly-inserted blank line underneath the source line in
question.
There are some new options that control how this all works.
* settings set stop-show-column
This takes one of 4 values:
* ansi-or-caret: use the ANSI terminal code mechanism if LLDB
is running with color enabled; if not, use the caret-based,
pure text method (see the "caret" mode below).
* ansi: only use the ANSI terminal code mechanism to highlight
the stop line. If LLDB is running with color disabled, no
stop column marking will occur.
* caret: only use the pure text caret method, which introduces
a newly-inserted line underneath the current line, where
the only character in the new line is a caret that highlights
the stop column in question.
* none: no stop column marking will be attempted.
* settings set stop-show-column-ansi-prefix
This is a text format that indicates the ANSI formatting
code to insert into the stream immediately preceding the
column where the stop column character will be marked up.
It defaults to ${ansi.underline}; however, it can contain
any valid LLDB format codes, e.g.
${ansi.fg.red}${ansi.bold}${ansi.underline}
* settings set stop-show-column-ansi-suffix
This is the text format that specifies the ANSI terminal
codes to end the markup that was started with the prefix
described above. It defaults to: ${ansi.normal}. This
should be sufficient for the common cases.
Significant leg-work was done by Adrian Prantl. (Thanks, Adrian!)
differential review: https://reviews.llvm.org/D20835
reviewers: clayborg, jingham
llvm-svn: 282105
2016-09-22 04:13:14 +08:00
|
|
|
@add_test_categories(['pyapi'])
|
|
|
|
def test_display_source_python_dumb_terminal(self):
|
|
|
|
"""Test display of source using the SBSourceManager API, using a
|
|
|
|
dumb terminal and thus no color support (the default)."""
|
|
|
|
use_color = False
|
|
|
|
self.do_display_source_python_api(use_color, r"\s+\^")
|
|
|
|
|
|
|
|
@add_test_categories(['pyapi'])
|
|
|
|
def test_display_source_python_ansi_terminal(self):
|
|
|
|
"""Test display of source using the SBSourceManager API, using a
|
|
|
|
dumb terminal and thus no color support (the default)."""
|
|
|
|
use_color = True
|
|
|
|
underline_regex = ansi_underline_surround_regex(r".")
|
|
|
|
self.do_display_source_python_api(use_color, underline_regex)
|
|
|
|
|
2015-09-30 18:12:40 +08:00
|
|
|
def test_move_and_then_display_source(self):
|
2011-12-13 05:59:28 +08:00
|
|
|
"""Test that target.source-map settings work by moving main.c to hidden/main.c."""
|
2015-09-30 18:12:40 +08:00
|
|
|
self.build()
|
2018-01-20 07:24:35 +08:00
|
|
|
exe = self.getBuildArtifact("a.out")
|
2011-12-13 05:59:28 +08:00
|
|
|
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
|
|
|
|
|
|
|
|
# Move main.c to hidden/main.c.
|
|
|
|
main_c = "main.c"
|
|
|
|
main_c_hidden = os.path.join("hidden", main_c)
|
|
|
|
os.rename(main_c, main_c_hidden)
|
|
|
|
|
2016-01-26 03:13:35 +08:00
|
|
|
# Restore main.c after the test.
|
|
|
|
self.addTearDownHook(lambda: os.rename(main_c_hidden, main_c))
|
|
|
|
|
2011-12-13 05:59:28 +08:00
|
|
|
if self.TraceOn():
|
2014-07-23 00:19:29 +08:00
|
|
|
system([["ls"]])
|
|
|
|
system([["ls", "hidden"]])
|
2011-12-13 05:59:28 +08:00
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
# Set source remapping with invalid replace path and verify we get an
|
|
|
|
# error
|
|
|
|
self.expect(
|
|
|
|
"settings set target.source-map /a/b/c/d/e /q/r/s/t/u",
|
|
|
|
error=True,
|
|
|
|
substrs=['''error: the replacement path doesn't exist: "/q/r/s/t/u"'''])
|
|
|
|
|
2011-12-13 05:59:28 +08:00
|
|
|
# Set target.source-map settings.
|
2016-09-07 04:57:50 +08:00
|
|
|
self.runCmd("settings set target.source-map %s %s" %
|
2018-01-31 02:29:16 +08:00
|
|
|
(self.getSourceDir(),
|
|
|
|
os.path.join(self.getSourceDir(), "hidden")))
|
2011-12-13 05:59:28 +08:00
|
|
|
# And verify that the settings work.
|
|
|
|
self.expect("settings show target.source-map",
|
2018-01-31 02:29:16 +08:00
|
|
|
substrs=[self.getSourceDir(),
|
|
|
|
os.path.join(self.getSourceDir(), "hidden")])
|
2011-12-13 05:59:28 +08:00
|
|
|
|
|
|
|
# Display main() and verify that the source mapping has been kicked in.
|
2013-02-06 08:35:33 +08:00
|
|
|
self.expect("source list -n main", SOURCE_DISPLAYED_CORRECTLY,
|
2016-09-07 04:57:50 +08:00
|
|
|
substrs=['Hello world'])
|
2011-12-13 05:59:28 +08:00
|
|
|
|
2015-09-30 18:12:40 +08:00
|
|
|
def test_modify_source_file_while_debugging(self):
|
2010-12-10 02:22:12 +08:00
|
|
|
"""Modify a source file while debugging the executable."""
|
2015-09-30 18:12:40 +08:00
|
|
|
self.build()
|
2018-01-20 07:24:35 +08:00
|
|
|
exe = self.getBuildArtifact("a.out")
|
2010-12-10 02:22:12 +08:00
|
|
|
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
|
|
self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
|
2010-12-10 02:22:12 +08:00
|
|
|
|
2015-07-02 07:56:30 +08:00
|
|
|
self.runCmd("run", RUN_SUCCEEDED)
|
2010-12-10 02:22:12 +08:00
|
|
|
|
|
|
|
# The stop reason of the thread should be breakpoint.
|
|
|
|
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
|
2016-09-07 04:57:50 +08:00
|
|
|
substrs=['stopped',
|
|
|
|
'main.c:%d' % self.line,
|
|
|
|
'stop reason = breakpoint'])
|
2010-12-10 02:22:12 +08:00
|
|
|
|
|
|
|
# Display some source code.
|
2016-09-07 04:57:50 +08:00
|
|
|
self.expect(
|
|
|
|
"source list -f main.c -l %d" %
|
|
|
|
self.line,
|
|
|
|
SOURCE_DISPLAYED_CORRECTLY,
|
|
|
|
substrs=['Hello world'])
|
2010-12-10 02:22:12 +08:00
|
|
|
|
2011-04-21 04:35:59 +08:00
|
|
|
# The '-b' option shows the line table locations from the debug information
|
|
|
|
# that indicates valid places to set source level breakpoints.
|
|
|
|
|
|
|
|
# The file to display is implicit in this case.
|
2013-02-06 08:35:33 +08:00
|
|
|
self.runCmd("source list -l %d -c 3 -b" % self.line)
|
2011-04-21 04:35:59 +08:00
|
|
|
output = self.res.GetOutput().splitlines()[0]
|
|
|
|
|
|
|
|
# If the breakpoint set command succeeded, we should expect a positive number
|
|
|
|
# of breakpoints for the current line, i.e., self.line.
|
|
|
|
import re
|
|
|
|
m = re.search('^\[(\d+)\].*// Set break point at this line.', output)
|
|
|
|
if not m:
|
|
|
|
self.fail("Fail to display source level breakpoints")
|
|
|
|
self.assertTrue(int(m.group(1)) > 0)
|
|
|
|
|
2010-12-10 02:22:12 +08:00
|
|
|
# Read the main.c file content.
|
2016-01-26 03:13:35 +08:00
|
|
|
with io.open('main.c', 'r', newline='\n') as f:
|
2010-12-10 02:22:12 +08:00
|
|
|
original_content = f.read()
|
2011-04-20 06:11:23 +08:00
|
|
|
if self.TraceOn():
|
2015-10-24 01:04:29 +08:00
|
|
|
print("original content:", original_content)
|
2010-12-10 02:22:12 +08:00
|
|
|
|
|
|
|
# Modify the in-memory copy of the original source code.
|
|
|
|
new_content = original_content.replace('Hello world', 'Hello lldb', 1)
|
|
|
|
|
|
|
|
# This is the function to restore the original content.
|
|
|
|
def restore_file():
|
2015-10-24 01:04:29 +08:00
|
|
|
#print("os.path.getmtime() before restore:", os.path.getmtime('main.c'))
|
2011-03-04 09:35:22 +08:00
|
|
|
time.sleep(1)
|
2016-01-26 03:13:35 +08:00
|
|
|
with io.open('main.c', 'w', newline='\n') as f:
|
2010-12-10 02:22:12 +08:00
|
|
|
f.write(original_content)
|
2011-04-20 06:11:23 +08:00
|
|
|
if self.TraceOn():
|
|
|
|
with open('main.c', 'r') as f:
|
2015-10-24 01:04:29 +08:00
|
|
|
print("content restored to:", f.read())
|
2011-03-04 09:35:22 +08:00
|
|
|
# Touch the file just to be sure.
|
|
|
|
os.utime('main.c', None)
|
2011-04-20 06:11:23 +08:00
|
|
|
if self.TraceOn():
|
2016-09-07 04:57:50 +08:00
|
|
|
print(
|
|
|
|
"os.path.getmtime() after restore:",
|
|
|
|
os.path.getmtime('main.c'))
|
2011-03-04 09:35:22 +08:00
|
|
|
|
2010-12-10 02:22:12 +08:00
|
|
|
# Modify the source code file.
|
2016-01-26 03:13:35 +08:00
|
|
|
with io.open('main.c', 'w', newline='\n') as f:
|
2011-03-04 09:35:22 +08:00
|
|
|
time.sleep(1)
|
2010-12-10 02:22:12 +08:00
|
|
|
f.write(new_content)
|
2011-04-20 06:11:23 +08:00
|
|
|
if self.TraceOn():
|
2015-10-24 01:04:29 +08:00
|
|
|
print("new content:", new_content)
|
2016-09-07 04:57:50 +08:00
|
|
|
print(
|
|
|
|
"os.path.getmtime() after writing new content:",
|
|
|
|
os.path.getmtime('main.c'))
|
2010-12-10 02:22:12 +08:00
|
|
|
# Add teardown hook to restore the file to the original content.
|
|
|
|
self.addTearDownHook(restore_file)
|
|
|
|
|
|
|
|
# Display the source code again. We should see the updated line.
|
2016-09-07 04:57:50 +08:00
|
|
|
self.expect(
|
|
|
|
"source list -f main.c -l %d" %
|
|
|
|
self.line,
|
|
|
|
SOURCE_DISPLAYED_CORRECTLY,
|
|
|
|
substrs=['Hello lldb'])
|
2016-03-04 19:26:44 +08:00
|
|
|
|
2016-04-19 17:31:14 +08:00
|
|
|
def test_set_breakpoint_with_absolute_path(self):
|
2016-03-04 19:26:44 +08:00
|
|
|
self.build()
|
2016-09-07 04:57:50 +08:00
|
|
|
self.runCmd("settings set target.source-map %s %s" %
|
2018-01-31 02:29:16 +08:00
|
|
|
(self.getSourceDir(),
|
|
|
|
os.path.join(self.getSourceDir(), "hidden")))
|
2016-03-04 19:26:44 +08:00
|
|
|
|
2018-01-20 07:24:35 +08:00
|
|
|
exe = self.getBuildArtifact("a.out")
|
2018-01-31 02:29:16 +08:00
|
|
|
main = os.path.join(self.getSourceDir(), "hidden", "main.c")
|
2016-03-04 19:26:44 +08:00
|
|
|
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
|
|
|
|
|
2016-09-07 04:57:50 +08:00
|
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
|
|
self, main, self.line, num_expected_locations=1, loc_exact=False)
|
|
|
|
|
2016-03-04 19:26:44 +08:00
|
|
|
self.runCmd("run", RUN_SUCCEEDED)
|
|
|
|
|
|
|
|
# The stop reason of the thread should be breakpoint.
|
|
|
|
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
|
2016-09-07 04:57:50 +08:00
|
|
|
substrs=['stopped',
|
|
|
|
'main.c:%d' % self.line,
|
|
|
|
'stop reason = breakpoint'])
|