LLDB tests modification for hardware breakpoints

[georgiev]

Summary

LLDB now shows additional string 'hardware' when a hardware breakpoint is hit. Current test fail for those kind of breakpoints, as they match exact string, which doesn't include 'hardware'.
The proposed solution is a regex match with an optional include of 'hardware' string (zero or one).

[jingham]

All these tests are testing the same sort of thing. It would be better to make an lldbutil function that does this test and convert all these tests over to that. This sort of change is exactly why we don't want code that's poking at command results to find info about things like breakpoints scattered all over the testsuite.

[jingham]

Actually, they aren't testing the same "sort" of thing, it's exactly the same test: "was the breakpoint hit once". But those tests are also really inaccurate as they just ask whether any breakpoint has a hit count of 1. It would be really easy to edit a test, add another breakpoint that gets hit before you get to this self.expect. In that case, this test would stop testing what it was intended to test.

I know you didn't add these expects, but if you have the time it would be great to add lldbutils.GetBreakpointCount(breakpoint_no) and then actually pass the right breakpoint to the test...

[georgiev]

What about the case when we have a logical BP with more than one location? the locations may have different hit count.
In particular we have a test like:
patterns=[

"1\.1: .+ unresolved, hit count = 0 +Options: disabled",
"1\.2: .+ resolved,( hardware,)? hit count = 1",
"1\.3: .+ resolved,( hardware,)? hit count = 1"])

[jingham]

If you have the breakpoint ID, you can find the SB Breakpoint and just ask it directly what it's hit count or location hit count are, and you don't have to scrub text output.

Jim

[georgiev]

A diff updated with a new lldbutil function to test the breakpoint - check_breakpoint().

[labath]

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

736

None would be more pythonic

753–754

If you replace assertTrue(foo == bar) with assertEquals(foo, bar) then you get the failure message for free.

[jingham]

It looks like you missed one conversion. I agree with Pavel that None is not only more pythonic but also more lldbutils-y. Other than those nits, LGTM.

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

738

These could be two lists or a list of duples to allow matching against more than one location at a time, but we can do also that when we need it.

lldb/test/API/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py

-1–1

Why didn't you change this one to use your new function?

[tatyana-krasnukha]

lldb/test/API/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py

-1–1

check_breakpoint checks the correctness of a breakpoint and its locations, whereas this test seems to be checking that side_effect is correctly updated inside the breakpoint command script.

[georgiev]

Added breakpoint resolved check.
Addressed some of the comments.

[georgiev]

Diff update

[tatyana-krasnukha]

LGTM, but I would wait for one more approval.

[jingham]

There's one comment typo, but you can fix that on submission. Otherwise, LGTM.

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

744

location -> locations

[aprantl]

FYI, this broke all the TestObjCNewSyntax* tests. I *think* I've fixed them.

[clayborg]

This change causes many test suite errors due to inline comment. Please fix ASAP

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

759

This line throws and exception when I run it on my system. It seems we have a function in lldbtest.py:

# utility methods that tests can use to access the current objects
def target(self):
    if not self.dbg:
        raise Exception('Invalid debugger instance')
    return self.dbg.GetSelectedTarget()

And many tests actually set "self.target" to be a lldb.SBTarget with lines like:

self.target = self.dbg.CreateTarget(exe)

So this test fails for many objective C tests now with an exception

[clayborg]

The right fix IMHO is to rename the function in lldbtest.py from "def target(self):" to "def selected_target(self):" and then find all call sites and fix them.

[clayborg]

In D111899#3140422, @aprantl wrote:

FYI, this broke all the TestObjCNewSyntax* tests. I *think* I've fixed them.

I synced to top of tree, still having issues. What was the commit for your fix?

[clayborg]

Never mind, it seems to be fixed. Although the problem I mentioned is still true where some test cases might set "self.target = debugger.CreateTarget(...)" and if those test cases try to use the check_breakpoint function. See suggested code edit for a potential fix.

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

759

You can make this safer by doing the suggested code change

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

if module_name:
 
         test.assertTrue(
             module_name.find(out_module_name) != -
             1,
             "Symbol module name '%s' isn't in expected module name '%s'." %
             (out_module_name,
              module_name))
 
+def check_breakpoint(
+            test,
+            bpno,
+            expected_locations = None,
+            expected_resolved_count = None,
+            expected_hit_count = None,
+            location_id = None,
+            expected_location_resolved = True,
+            expected_location_hit_count = None):
+    """
+    Test breakpoint or breakpoint location.
+    Breakpoint resolved count is always checked. If not specified the assumption is that all locations 
+    should be resolved. 
+    To test a breakpoint location, breakpoint number (bpno) and location_id must be set. In this case
+    the resolved count for a breakpoint is not tested by default. The location is expected to be resolved,
+    unless expected_location_resolved is set to False.
+    test - test context
+    bpno - breakpoint number to test
+    expected_locations - expected number of locations for this breakpoint. If 'None' this parameter is not tested.
+    expected_resolved_count - expected resolved locations number for the breakpoint.  If 'None' - all locations should be resolved.
+    expected_hit_count - expected hit count for this breakpoint. If 'None' this parameter is not tested.
+    location_id - If not 'None' sets the location ID for the breakpoint to test.
+    expected_location_resolved - Extected resolved status for the location_id (True/False). Default - True.
+    expected_location_hit_count - Expected hit count for the breakpoint at location_id. Must be set if the location_id parameter is set.
+    """
+    
+    bkpt = test.target().FindBreakpointByID(bpno)
+    test.assertTrue(bkpt.IsValid(), "Breakpoint is not valid.")
+
+    if expected_locations is not None:
+        test.assertEquals(expected_locations, bkpt.GetNumLocations())
+
+    if expected_resolved_count is not None:
+        test.assertEquals(expected_resolved_count, bkpt.GetNumResolvedLocations())
+    else:
+        expected_resolved_count = bkpt.GetNumLocations()
+        if location_id is None:
+            test.assertEquals(expected_resolved_count, bkpt.GetNumResolvedLocations())
+
+    if expected_hit_count is not None:
+        test.assertEquals(expected_hit_count, bkpt.GetHitCount())
+
+    if location_id is not None:
+        loc_bkpt = bkpt.FindLocationByID(location_id)
+        test.assertTrue(loc_bkpt.IsValid(), "Breakpoint location is not valid.")
+        test.assertEquals(loc_bkpt.IsResolved(), expected_location_resolved)
+        if expected_location_hit_count is not None:
+            test.assertEquals(expected_location_hit_count, loc_bkpt.GetHitCount())
+
+
+
 # ==================================================
 # Utility functions related to Threads and Processes
 # ==================================================
 
 
 def get_stopped_threads(process, reason):
     """Returns the thread(s) with the specified stop reason in a list.
 

lldb/test/API/commands/apropos/with-process/TestAproposWithProcess.py

def test_apropos_with_process(self):
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped', 'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         self.runCmd('apropos env')

lldb/test/API/commands/command/nested_alias/TestNestedAlias.py

def test_nested_alias(self):
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped', 'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # This is the function to remove the custom aliases in order to have a
         # clean slate for the next test case.
         def cleanup():
             self.runCmd('command unalias read', check=False)
             self.runCmd('command unalias rd', check=False)
             self.runCmd('command unalias fo', check=False)
             self.runCmd('command unalias foself', check=False)

lldb/test/API/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py

 """
 Test lldb breakpoint command add/list/delete.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
def breakpoint_command_sequence(self):
         # We should be stopped again due to breakpoint 1.
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 2.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_TWICE,
-                    substrs=['resolved, hit count = 2'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 2)
 
     def breakpoint_command_script_parameters(self):
         """Test that the frame and breakpoint location are being properly passed to the script breakpoint command function."""
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Add a breakpoint.
         lldbutil.run_break_set_by_file_and_line(
             self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
 
         # Now add callbacks for the breakpoints just created.
         self.runCmd("breakpoint command add -s python -o 'import side_effect; side_effect.frame = str(frame); side_effect.bp_loc = str(bp_loc)' 1")
 
         # Reset canary variables and run.
         side_effect.frame = None
         side_effect.bp_loc = None
         self.runCmd("run", RUN_SUCCEEDED)
 
         self.expect(side_effect.frame, exe=False, startstr="frame #0:")
         self.expect(side_effect.bp_loc, exe=False,
-                patterns=["1.* where = .*main .* resolved, hit count = 1"])
+                patterns=["1.* where = .*main .* resolved,( hardware,)? hit count = 1"])
 
     def breakpoint_commands_on_creation(self):
         """Test that setting breakpoint commands when creating the breakpoint works"""
         target = self.createTestTarget()
 
         # Add a breakpoint.
         lldbutil.run_break_set_by_file_and_line(
             self, "main.c", self.line, num_expected_locations=1, loc_exact=True,

lldb/test/API/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py

def breakpoint_ignore_count(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The process should be stopped at this point.
         self.expect("process status", PROCESS_STOPPED,
                     patterns=['Process .* stopped'])
 
         # Also check the hit count, which should be 2, due to ignore count of
         # 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_THRICE,
-                    substrs=["resolved = 1",
-                             "hit count = 2"])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 2)
 
         # The frame #0 should correspond to main.c:37, the executable statement
         # in function name 'c'.  And frame #2 should point to main.c:45.
         self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT,
                     #substrs = ["stop reason = breakpoint"],
                     patterns=["frame #0.*main.c:%d" % self.line1,
                               "frame #2.*main.c:%d" % self.line2])
 
         # continue -i 1 is the same as setting the ignore count to 1 again, try that:
         # Now run the program.
         self.runCmd("process continue -i 1", RUN_SUCCEEDED)
 
         # The process should be stopped at this point.
         self.expect("process status", PROCESS_STOPPED,
                     patterns=['Process .* stopped'])
 
         # Also check the hit count, which should be 2, due to ignore count of
         # 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_THRICE,
-                    substrs=["resolved = 1",
-                             "hit count = 4"])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 4)
 
         # The frame #0 should correspond to main.c:37, the executable statement
         # in function name 'c'.  And frame #2 should point to main.c:45.
         self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT,
                     #substrs = ["stop reason = breakpoint"],
                     patterns=["frame #0.*main.c:%d" % self.line1,
                               "frame #1.*main.c:%d" % self.line5])
 

lldb/test/API/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py

def breakpoint_locations_test(self):
         self.runCmd("process continue")
 
         # Stopped again.
         self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=["stop reason = breakpoint 1."])
 
         # At this point, 1.1 has a hit count of 0 and the other a hit count of
         # 1".
-        self.expect(
-            "breakpoint list -f",
-            "The breakpoints should report correct hit counts",
-            patterns=[
-                "1\.1: .+ unresolved, hit count = 0 +Options: disabled",
-                "1\.2: .+ resolved, hit count = 1",
-                "1\.3: .+ resolved, hit count = 1"])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_locations = 3, expected_resolved_count = 2, expected_hit_count = 2)
+        lldbutil.check_breakpoint(self, bpno = 1, location_id = 1,  expected_location_resolved = False, expected_location_hit_count = 0)
+        lldbutil.check_breakpoint(self, bpno = 1, location_id = 2, expected_location_resolved = True, expected_location_hit_count = 1)
+        lldbutil.check_breakpoint(self, bpno = 1, location_id = 3, expected_location_resolved = True, expected_location_hit_count = 1)

lldb/test/API/functionalities/dead-strip/TestDeadStrip.py

def test(self):
 
         # The stop reason of the thread should be breakpoint (breakpoint #1).
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'a.out`f1',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f 1", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         self.runCmd("continue")
 
         # The stop reason of the thread should be breakpoint (breakpoint #3).
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'a.out`f3',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f 3", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 3, expected_hit_count = 1)

lldb/test/API/functionalities/load_unload/TestLoadUnload.py

def run_load_unload(self):
 
         # The stop reason of the thread should be breakpoint and at a_function.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'a_function',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # Issue the 'continue' command.  We should stop agaian at a_function.
         # The stop reason of the thread should be breakpoint and at a_function.
         self.runCmd("continue")
 
         # rdar://problem/8508987
         # The a_function breakpoint should be encountered twice.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'a_function',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 2.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 2'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 2)
 
     def test_step_over_load(self):
         self.setSvr4Support(False)
         self.run_step_over_load()
 
     def test_step_over_load_with_svr4(self):
         self.setSvr4Support(True)
         self.run_step_over_load()

lldb/test/API/functionalities/memory/cache/TestMemoryCache.py

def test_memory_cache(self):
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped', 'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # Read a chunk of memory containing &my_ints[0]. The number of bytes read
         # must be greater than m_L2_cache_line_byte_size to make sure the L1
         # cache is used.
         self.runCmd('memory read -f d -c 201 `&my_ints - 100`')
 
         # Check the value of my_ints[0] is the same as set in main.cpp.
         line = self.res.GetOutput().splitlines()[100]

lldb/test/API/functionalities/memory/find/TestMemoryFind.py

def test_memory_find(self):
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped', 'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # Test the memory find commands.
 
         self.expect(
             'memory find -s "in const" `stringdata` `stringdata+(int)strlen(stringdata)`',
             substrs=[
                 'data found at location: 0x',
                 '69 6e 20 63',

lldb/test/API/functionalities/memory/read/TestMemoryRead.py

def build_run_stop(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list",
                     STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped', 'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f",
-                    BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
     @no_debug_info_test
     def test_memory_read(self):
         """Test the 'memory read' command with plain and vector formats."""
         self.build_run_stop()
 
         # (lldb) memory read -f d -c 1 `&argc`
         # 0x7fff5fbff9a0: 1

lldb/test/API/lang/c/anonymous/TestAnonymous.py

def common_setup(self, line):
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)

lldb/test/API/lang/c/array_types/TestArrayTypes.py

def test_and_run_command(self):
         self.runCmd("process status")
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=['resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # Issue 'variable list' command on several array-type variables.
 
         self.expect(
             "frame variable --show-types strings",
             VARIABLES_DISPLAYED_CORRECTLY,
             startstr='(char *[4])',
             substrs=[

lldb/test/API/lang/c/conflicting-symbol/TestConflictingSymbol.py

def test_conflicting_symbols(self):
             None, environment, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # This should display correctly.
         self.expect(
             "expr (unsigned long long)conflicting_symbol",
             "Symbol from One should be found",
             substrs=[
                 "11111"])
 
         self.runCmd("continue", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         self.expect(
             "expr (unsigned long long)conflicting_symbol",
             "Symbol from Two should be found",
             substrs=[
                 "22222"])
 
         self.runCmd("continue", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         self.expect(
             "expr (unsigned long long)conflicting_symbol",
             "An error should be printed when symbols can't be ordered",
             error=True,
             substrs=[
                 "Multiple internal symbols"])
 

lldb/test/API/lang/c/const_variables/TestConstVariables.py

def test_and_run_command(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         self.runCmd("next")
         self.runCmd("next")
 
         # Try frame variable.
         self.expect("frame variable index", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['(int32_t) index = 512'])
 

lldb/test/API/lang/c/enum_types/TestEnumTypes.py

def test_command_line(self):
         self.runCmd("c", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # Look up information about the 'enum_test_days' enum type.
         # Check for correct display.
         self.expect("image lookup -t enum_test_days", DATA_TYPES_DISPLAYED_CORRECTLY,
                     substrs=['enum enum_test_days {',
                              'Monday',
                              'Tuesday',
                              'Wednesday',

lldb/test/API/lang/c/forward/TestForwardDeclaration.py

def do_test(self, dictionary=None):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # This should display correctly.
         # Note that the member fields of a = 1 and b = 2 is by design.
         self.expect(
             "frame variable --show-types *bar_ptr",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 '(bar) *bar_ptr = ',

lldb/test/API/lang/c/function_types/TestFunctionTypes.py

def runToBreakpoint(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)

lldb/test/API/lang/c/global_variables/TestGlobalVariables.py

def test_c_global_variables(self):
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # Test that the statically initialized variable can also be
         # inspected *with* a process.
         self.expect("target variable g_ptr", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['(int *)'])
         self.expect("target variable *g_ptr", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['42'])
 

lldb/test/API/lang/c/local_variables/TestLocalVariables.py

def test_c_local_variables(self):
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         self.expect("frame variable i", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['(unsigned int) i = 10'])

lldb/test/API/lang/c/modules/TestCModules.py

def test_expr(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # Enable logging of the imported AST.
         log_file = self.getBuildArtifact("lldb-ast-log.txt")
         self.runCmd("log enable lldb ast -f '%s'" % log_file)
 
         self.expect(
             "expr -l objc++ -- @import Darwin; 3",
             VARIABLES_DISPLAYED_CORRECTLY,

lldb/test/API/lang/c/register_variables/TestRegisterVariables.py

def test_and_run_command(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # Try some variables that should be visible
         frame = self.dbg.GetSelectedTarget().GetProcess(
         ).GetSelectedThread().GetSelectedFrame()
         if self.is_variable_in_register(frame, 'a'):
             register_variables_count += 1
             self.expect("expr a", VARIABLES_DISPLAYED_CORRECTLY,
                         patterns=[re_expr_equals('int', 2)])
def test_and_run_command(self):
         self.runCmd("continue")
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # Try some variables that should be visible
         frame = self.dbg.GetSelectedTarget().GetProcess(
         ).GetSelectedThread().GetSelectedFrame()
         if self.is_struct_pointer_in_register(frame, 'b', self.TraceOn()):
             register_variables_count += 1
             self.expect("expr b->m2", VARIABLES_DISPLAYED_CORRECTLY,
                         patterns=[re_expr_equals('int', 5)])
def test_and_run_command(self):
         self.runCmd("continue")
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # Try some variables that should be visible
         frame = self.dbg.GetSelectedTarget().GetProcess(
         ).GetSelectedThread().GetSelectedFrame()
         if self.is_variable_in_register(frame, 'f'):
             register_variables_count += 1
             self.expect("expr f", VARIABLES_DISPLAYED_CORRECTLY,
                         patterns=[re_expr_equals('float', '3.1')])

lldb/test/API/lang/c/set_values/TestSetValues.py

def test(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # main.c:15
         # Check that 'frame variable --show-types' displays the correct data
         # type and value.
         self.expect(
             "frame variable --show-types",
             VARIABLES_DISPLAYED_CORRECTLY,
             startstr="(char) i = 'a'")

lldb/test/API/lang/c/shared_lib/TestSharedLib.py

def common_setup(self, preload_symbols = True):
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)

lldb/test/API/lang/c/shared_lib_stripped_symbols/TestSharedLibStrippedSymbols.py

def common_setup(self):
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)

lldb/test/API/lang/cpp/class_types/TestClassTypes.py

def test_with_run_command(self):
         self.runCmd("process status")
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # We should be stopped on the ctor function of class C.
         self.expect(
             "frame variable --show-types this",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 'C *',
                 ' this = '])
def test_with_expr_parser(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # Continue on inside the ctor() body...
         self.runCmd("register read pc")
         self.runCmd("thread step-over")
 
         # Verify that 'frame variable this' gets the data type correct.
         self.expect("frame variable this", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['C *'])

lldb/test/API/lang/cpp/inlines/TestInlines.py

def runToBreakpoint(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)

lldb/test/API/lang/cpp/namespace_definitions/TestNamespaceDefinitions.py

def common_setup(self):
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)

lldb/test/API/lang/cpp/signed_types/TestSignedTypes.py

def test(self):
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped', 'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # Execute the puts().
         self.runCmd("thread step-over")
 
         # Test that signed types display correctly.
         self.expect(
             "frame variable --show-types --no-args",
             VARIABLES_DISPLAYED_CORRECTLY,
             patterns=[
                 "\((short int|short)\) the_signed_short = 99",
                 "\((signed char|char)\) the_signed_char = 'c'"],
             substrs=[
                 "(int) the_signed_int = 99",
                 "(long) the_signed_long = 99",
                 "(long long) the_signed_long_long = 99"])

lldb/test/API/lang/objc/conflicting-definition/TestConflictingDefinition.py

def test_frame_var_after_stop_at_implementation(self):
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # This should display correctly.
         self.expect(
             "expr 42",
             "A simple expression should execute correctly",
             substrs=[
                 "42"])
 
     def common_setup(self):
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
         self.registerSharedLibrariesWithTarget(target, self.shlib_names)
 
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)

lldb/test/API/lang/objc/forward-decl/TestForwardDecl.py

def do_test(self, dictionary=None):
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # This should display correctly.
         self.expect("expression [j getMember]", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["= 0x"])
 
     def test_expr(self):
         self.do_test()
 
     @no_debug_info_test
     @skipIf(compiler=no_match("clang"))
     @skipIf(compiler_version=["<", "7.0"])
     def test_debug_names(self):
         """Test that we are able to find complete types when using DWARF v5
         accelerator tables"""
         self.do_test(
             dict(CFLAGS_EXTRAS="-dwarf-version=5 -mllvm -accel-tables=Dwarf"))

lldb/test/API/lang/objc/hidden-ivars/TestHiddenIvars.py

def common_setup(self, strip):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
     def expr(self, strip):
         self.common_setup(strip)
 
         # This should display correctly.
         self.expect(
             "expression (j->_definer->foo)",
             VARIABLES_DISPLAYED_CORRECTLY,

lldb/test/API/lang/objc/modules-auto-import/TestModulesAutoImport.py

def test_expr(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         self.runCmd("settings set target.auto-import-clang-modules true")
 
         self.expect("p getpid()", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["pid_t"])

lldb/test/API/lang/objc/modules-incomplete/TestIncompleteModules.py

def test_expr(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         self.runCmd(
             "settings set target.clang-module-search-paths \"" +
             self.getSourceDir() +
             "\"")
 
         self.expect("expr @import myModule; 3", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["int", "3"])

lldb/test/API/lang/objc/modules/TestObjCModules.py

def test_expr(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         self.expect("expr @import Darwin; 3", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["int", "3"])
 
         self.expect("expr getpid()", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["pid_t"])
 
         self.expect(

lldb/test/API/lang/objc/objc-new-syntax/ObjCNewSyntaxTest.py

def runToBreakpoint(self):
 
         # The stop reason of the thread should be breakpoint.
         self.expect(
             "thread list",
             STOPPED_DUE_TO_BREAKPOINT,
             substrs=['stopped', 'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect(
-            "breakpoint list -f",
-            BREAKPOINT_HIT_ONCE,
-            substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)

lldb/test/API/lang/objc/real-definition/TestRealDefinition.py

def test_frame_var_after_stop_at_interface(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # Run and stop at Foo
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         self.runCmd("continue", RUN_SUCCEEDED)
 
         # Run at stop at main
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # This should display correctly.
         self.expect(
             "frame variable foo->_bar->_hidden_ivar",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 "(NSString *)",
                 "foo->_bar->_hidden_ivar = 0x"])
def test_frame_var_after_stop_at_implementation(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # Run and stop at Foo
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         self.runCmd("continue", RUN_SUCCEEDED)
 
         # Run at stop at main
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         # This should display correctly.
         self.expect(
             "frame variable foo->_bar->_hidden_ivar",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 "(NSString *)",
                 "foo->_bar->_hidden_ivar = 0x"])

lldb/test/API/lang/objc/single-entry-dictionary/TestObjCSingleEntryDictionary.py

def run_tests(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
-        self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
-                    substrs=[' resolved, hit count = 1'])
+        lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
         d1 = self.frame().FindVariable("d1")
         d1.SetPreferSyntheticValue(True)
         d1.SetPreferDynamicValue(lldb.eDynamicCanRunTarget)
 
         self.assertEqual(
             d1.GetNumChildren(), 1,
             "dictionary has != 1 child elements")