Fix a mis-feature with propagation of breakpoint options -> location options.

When an option was set at on a location, I was just copying the whole option set 
to the location, and letting it shadow the breakpoint options.  That was wrong since
it meant changes to unrelated options on the breakpoint would no longer take on this
location.  I added a mask of set options and use that for option propagation.

I also added a "location" property to breakpoints, and added SBBreakpointLocation.{G,S}etCommandLineCommands
since I wanted to use them to write some more test cases.

<rdar://problem/24397798>

llvm-svn: 309772

1 files changed, 101 insertions, 7 deletions

diff --git a/lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py b/lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py
index fdbd622f767..de24d8b002d 100644
--- a/lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py
+++ b/lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py
@@ -18,27 +18,40 @@ class BreakpointLocationsTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24528")
-    def test(self):
+    def test_enable(self):
         """Test breakpoint enable/disable for a breakpoint ID with multiple locations."""
         self.build()
         self.breakpoint_locations_test()
 
+    def test_shadowed_cond_options(self):
+        """Test that options set on the breakpoint and location behave correctly."""
+        self.build()
+        self.shadowed_bkpt_cond_test()
+
+
+    def test_shadowed_command_options(self):
+        """Test that options set on the breakpoint and location behave correctly."""
+        self.build()
+        self.shadowed_bkpt_command_test()
+
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.c', '// Set break point at this line.')
 
-    def breakpoint_locations_test(self):
-        """Test breakpoint enable/disable for a breakpoint ID with multiple locations."""
+    def set_breakpoint (self):
         exe = os.path.join(os.getcwd(), "a.out")
-        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, "Target %s is not valid"%(exe))
 
         # This should create a breakpoint with 3 locations.
-        lldbutil.run_break_set_by_file_and_line(
-            self, "main.c", self.line, num_expected_locations=3)
+        
+        bkpt = target.BreakpointCreateByLocation("main.c", self.line)
 
         # The breakpoint list should show 3 locations.
+        self.assertEqual(bkpt.GetNumLocations(), 3, "Wrong number of locations")
+        
         self.expect(
             "breakpoint list -f",
             "Breakpoint locations shown correctly",
@@ -49,6 +62,87 @@ class BreakpointLocationsTestCase(TestBase):
                 "where = a.out`func_inlined .+unresolved, hit count = 0",
                 "where = a.out`main .+\[inlined\].+unresolved, hit count = 0"])
 
+        return bkpt        
+
+    def shadowed_bkpt_cond_test(self):
+        """Test that options set on the breakpoint and location behave correctly."""
+        # Breakpoint option propagation from bkpt to loc used to be done the first time
+        # a breakpoint location option was specifically set.  After that the other options
+        # on that location would stop tracking the breakpoint.  That got fixed, and this test
+        # makes sure only the option touched is affected.
+
+        bkpt = self.set_breakpoint()
+        bkpt_cond = "1 == 0"
+        bkpt.SetCondition(bkpt_cond)
+        self.assertEqual(bkpt.GetCondition(), bkpt_cond,"Successfully set condition")
+        self.assertTrue(bkpt.location[0].GetCondition() == bkpt.GetCondition(), "Conditions are the same")
+
+        # Now set a condition on the locations, make sure that this doesn't effect the bkpt:
+        bkpt_loc_1_cond = "1 == 1"
+        bkpt.location[0].SetCondition(bkpt_loc_1_cond)
+        self.assertEqual(bkpt.location[0].GetCondition(), bkpt_loc_1_cond, "Successfully changed location condition")
+        self.assertNotEqual(bkpt.GetCondition(), bkpt_loc_1_cond, "Changed location changed Breakpoint condition")
+        self.assertEqual(bkpt.location[1].GetCondition(), bkpt_cond, "Changed another location's condition")
+
+        # Now make sure that setting one options doesn't fix the value of another:
+        bkpt.SetIgnoreCount(10)
+        self.assertEqual(bkpt.GetIgnoreCount(), 10, "Set the ignore count successfully")
+        self.assertEqual(bkpt.location[0].GetIgnoreCount(), 10, "Location doesn't track top-level bkpt.")
+
+        # Now make sure resetting the condition to "" resets the tracking:
+        bkpt.location[0].SetCondition("")
+        bkpt_new_cond = "1 == 3"
+        bkpt.SetCondition(bkpt_new_cond)
+        self.assertEqual(bkpt.location[0].GetCondition(), bkpt_new_cond, "Didn't go back to tracking condition")
+
+    def shadowed_bkpt_command_test(self):
+        """Test that options set on the breakpoint and location behave correctly."""
+        # Breakpoint option propagation from bkpt to loc used to be done the first time
+        # a breakpoint location option was specifically set.  After that the other options
+        # on that location would stop tracking the breakpoint.  That got fixed, and this test
+        # makes sure only the option touched is affected.
+
+        bkpt = self.set_breakpoint()
+        commands = ["AAAAAA", "BBBBBB", "CCCCCC"]
+        str_list = lldb.SBStringList()
+        str_list.AppendList(commands, len(commands))
+        
+        bkpt.SetCommandLineCommands(str_list)
+        cmd_list = lldb.SBStringList()
+        bkpt.GetCommandLineCommands(cmd_list)
+        list_size = str_list.GetSize()
+        self.assertEqual(cmd_list.GetSize() , list_size, "Added the right number of commands")
+        for i in range(0,list_size):
+            self.assertEqual(str_list.GetStringAtIndex(i), cmd_list.GetStringAtIndex(i), "Mismatched commands.")
+
+        commands = ["DDDDDD", "EEEEEE", "FFFFFF", "GGGGGG"]
+        loc_list = lldb.SBStringList()
+        loc_list.AppendList(commands, len(commands))
+        bkpt.location[1].SetCommandLineCommands(loc_list)
+        loc_cmd_list = lldb.SBStringList()
+        bkpt.location[1].GetCommandLineCommands(loc_cmd_list)
+
+        loc_list_size = loc_list.GetSize()
+        
+        # Check that the location has the right commands:
+        self.assertEqual(loc_cmd_list.GetSize() , loc_list_size, "Added the right number of commands to location")
+        for i in range(0,loc_list_size):
+            self.assertEqual(loc_list.GetStringAtIndex(i), loc_cmd_list.GetStringAtIndex(i), "Mismatched commands.")
+
+        # Check that we didn't mess up the breakpoint level commands:
+        self.assertEqual(cmd_list.GetSize() , list_size, "Added the right number of commands")
+        for i in range(0,list_size):
+            self.assertEqual(str_list.GetStringAtIndex(i), cmd_list.GetStringAtIndex(i), "Mismatched commands.")
+
+        # And check we didn't mess up another location:
+        untouched_loc_cmds = lldb.SBStringList()
+        bkpt.location[0].GetCommandLineCommands(untouched_loc_cmds)
+        self.assertEqual(untouched_loc_cmds.GetSize() , 0, "Changed the wrong location")
+
+    def breakpoint_locations_test(self):
+        """Test breakpoint enable/disable for a breakpoint ID with multiple locations."""
+        self.set_breakpoint()
+
         # The 'breakpoint disable 3.*' command should fail gracefully.
         self.expect("breakpoint disable 3.*",
                     "Disabling an invalid breakpoint should fail gracefully",
@@ -80,7 +174,7 @@ class BreakpointLocationsTestCase(TestBase):
             "1 breakpoint locatons disabled correctly",
             startstr="1 breakpoints disabled.")
 
-        # Run the program againt.  We should stop on the two breakpoint
+        # Run the program again.  We should stop on the two breakpoint
         # locations.
         self.runCmd("run", RUN_SUCCEEDED)