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

646

None would be more pythonic

663–664

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

648

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

269

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

[tatyana-krasnukha]

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

269

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

654

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

669

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

669

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 = -1,
+            expected_hit_count = -1,
+            location_id = -1,
+            expected_location_hit_count = -1):
+    """
+    test - test context
+    bpno - breakpoint number to test
+    expected_locations - expected number of locations for this breakpoint. If (-1) this parameter is not tested.
+    expected_hit_count - expected hit count for this breakpoint. If (-1) this parameter is not tested.
+    location_id - If not (-1) sets the location ID for the breakpoint to test.
+    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() == True, "Breakpoint is not valid.")
+
+    if(expected_locations > -1):
+        test.assertTrue(expected_locations == bkpt.GetNumLocations(),
+                        "Expecting {} locations, got {}.".format(expected_locations, bkpt.GetNumLocations()))
+
+    if(expected_hit_count > -1):
+        test.assertTrue(expected_hit_count == bkpt.GetHitCount(),
+                        "Expecting hit count {}, got {}.".format(expected_hit_count, bkpt.GetHitCount()))
+
+    if(location_id > -1):
+        if(expected_location_hit_count > -1):
+            loc_bkpt = bkpt.FindLocationByID(location_id)
+            test.assertTrue(loc_bkpt.IsValid() == True, "Breakpoint is not valid.")
+            test.assertTrue(expected_location_hit_count == loc_bkpt.GetHitCount(),
+                        "Expected hit count {} , got {}.".format(expected_location_hit_count, bkpt.FindLocationByID(location_id).GetHitCount()))
+        else:
+            test.assertTrue(expected_location_hit_count > -1,
+                        "Expecting expected_location_hit_count >= 0, got -1.")
+
+
 # ==================================================
 # 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

def breakpoint_command_script_parameters(self):
 
         # 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"""
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target.IsValid(), "Created an invalid target.")
 
         # Add a breakpoint.

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_hit_count = 2)
+        lldbutil.check_breakpoint(self, bpno = 1, location_id = 1, expected_location_hit_count = 0)
+        lldbutil.check_breakpoint(self, bpno = 1, location_id = 2, expected_location_hit_count = 1)
+        lldbutil.check_breakpoint(self, bpno = 1, location_id = 3, 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,

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 test_memory_read(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 read commands.
 
         # (lldb) memory read -f d -c 1 `&argc`
         # 0x7fff5fbff9a0: 1
         self.runCmd("memory read -f d -c 1 `&argc`")
 
         # Find the starting address for variable 'argc' to verify later that the

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/bitfields/TestBitfields.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)
 
         # This should display correctly.
         self.expect(
             "frame variable --show-types bits",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 '(uint32_t:1) b1 = 1',
                 '(uint32_t:2) b2 = 3',

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(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 'days' enum type.
         # Check for correct display.
         self.expect("image lookup -t days", DATA_TYPES_DISPLAYED_CORRECTLY,
                     substrs=['enum 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")
         if configuration.is_reproducer_replay():
             log_file = self.getReproducerRemappedPath(log_file)
         self.runCmd("log enable lldb ast -f '%s'" % log_file)
 
         self.expect(

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_locations = 3, expected_hit_count = 1)
+        lldbutil.check_breakpoint(self, bpno = 1, location_id = 1, expected_location_hit_count = 1)
+        lldbutil.check_breakpoint(self, bpno = 1, location_id = 2, expected_location_hit_count = 0)
+        lldbutil.check_breakpoint(self, bpno = 1, location_id = 3, expected_location_hit_count = 0)
 
         # 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_locations = 3, expected_hit_count = 2)
+        lldbutil.check_breakpoint(self, bpno = 1, location_id = 1, expected_location_hit_count = 1)
+        lldbutil.check_breakpoint(self, bpno = 1, location_id = 2, expected_location_hit_count = 1)
+        lldbutil.check_breakpoint(self, bpno = 1, location_id = 3, expected_location_hit_count = 0)
 
         # 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_locations = 3, expected_hit_count = 3)
+        lldbutil.check_breakpoint(self, bpno = 1, location_id = 1, expected_location_hit_count = 1)
+        lldbutil.check_breakpoint(self, bpno = 1, location_id = 2, expected_location_hit_count = 1)
+        lldbutil.check_breakpoint(self, bpno = 1, location_id = 3, expected_location_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/bitfields/TestCppBitfields.py

def test_and_run_command(self):
           lldb.SBFileSpec("main.cpp", False))
 
         # 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 (lba.a)", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['unsigned int', '2'])
         self.expect("expr (lbb.b)", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['unsigned int', '3'])
         self.expect("expr (lbc.c)", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['unsigned int', '4'])
         self.expect("expr (lbd.a)", VARIABLES_DISPLAYED_CORRECTLY,

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/enum_types/TestCPP11EnumTypes.py

def image_lookup_for_enum_type(self, is_signed):
         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)
 
         # Look up information about the 'DayType' enum type.
         # Check for correct display.
         self.expect("image lookup -t DayType", DATA_TYPES_DISPLAYED_CORRECTLY,
                     patterns=['enum( struct| class) DayType {'],
                     substrs=['Monday',
                              'Tuesday',
                              'Wednesday',

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"])
 
     @skipUnlessDarwin
     def test_expr(self):
         self.do_test()

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 test_single_entry_dict(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.assertTrue(
             d1.GetNumChildren() == 1,
             "dictionary has != 1 child elements")