"""
Test breakpoint commands for a breakpoint ID with multiple locations.
"""

from __future__ import print_function


import lldb
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil


class BreakpointLocationsTestCase(TestBase):

    mydir = TestBase.compute_mydir(__file__)

    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24528")
    @expectedFailureAll(archs=["aarch64"], oslist=["linux"],
                        debug_info=["dwo"],
                        bugnumber="llvm.org/pr44037")
    def test_enable(self):
        """Test breakpoint enable/disable for a breakpoint ID with multiple locations."""
        self.build()
        self.breakpoint_locations_test()

    @expectedFailureAll(archs=["aarch64"], oslist=["linux"],
                        debug_info=["dwo"],
                        bugnumber="llvm.org/pr44037")
    def test_shadowed_cond_options(self):
        """Test that options set on the breakpoint and location behave correctly."""
        self.build()
        self.shadowed_bkpt_cond_test()


    @expectedFailureAll(archs=["aarch64"], oslist=["linux"],
                        debug_info=["dwo"],
                        bugnumber="llvm.org/pr44037")
    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 set_breakpoint (self):
        exe = self.getBuildArtifact("a.out")
        target = self.dbg.CreateTarget(exe)
        self.assertTrue(target, "Target %s is not valid"%(exe))

        # This should create a breakpoint with 3 locations.

        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",
            substrs=[
                "1: file = 'main.c', line = %d, exact_match = 0, locations = 3" %
                self.line],
            patterns=[
                "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",
                    error=True,
                    startstr="error: '3' is not a valid breakpoint ID.")

        # The 'breakpoint disable 1.*' command should disable all 3 locations.
        self.expect(
            "breakpoint disable 1.*",
            "All 3 breakpoint locatons disabled correctly",
            startstr="3 breakpoints disabled.")

        # Run the program.
        self.runCmd("run", RUN_SUCCEEDED)

        # We should not stopped on any breakpoint at all.
        self.expect("process status", "No stopping on any disabled breakpoint",
                    patterns=["^Process [0-9]+ exited with status = 0"])

        # The 'breakpoint enable 1.*' command should enable all 3 breakpoints.
        self.expect(
            "breakpoint enable 1.*",
            "All 3 breakpoint locatons enabled correctly",
            startstr="3 breakpoints enabled.")

        # The 'breakpoint disable 1.1' command should disable 1 location.
        self.expect(
            "breakpoint disable 1.1",
            "1 breakpoint locatons disabled correctly",
            startstr="1 breakpoints disabled.")

        # Run the program again.  We should stop on the two breakpoint
        # locations.
        self.runCmd("run", RUN_SUCCEEDED)

        # Stopped once.
        self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
                    substrs=["stop reason = breakpoint 1."])

        # Continue the program, there should be another stop.
        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"])
