"""
Test SBAddressRange APIs.
"""

import lldb
from lldbsuite.test.lldbtest import *


class AddressRangeTestCase(TestBase):
    NO_DEBUG_INFO_TESTCASE = True

    def setUp(self):
        TestBase.setUp(self)

        self.build()
        exe = self.getBuildArtifact("a.out")

        self.target = self.dbg.CreateTarget(exe)
        self.assertTrue(self.target, VALID_TARGET)
        self.launch_info = self.target.GetLaunchInfo()
        self.launch_info.SetWorkingDirectory(self.get_process_working_directory())

        self.bp1 = self.target.BreakpointCreateByName("main", "a.out")
        self.bp2 = self.target.BreakpointCreateByName("foo", "a.out")
        self.bp3 = self.target.BreakpointCreateByName("bar", "a.out")

        self.assertTrue(self.bp1.IsValid())
        self.assertTrue(self.bp2.IsValid())
        self.assertTrue(self.bp3.IsValid())

        self.addr1 = self.bp1.GetLocationAtIndex(0).GetAddress()
        self.addr2 = self.bp2.GetLocationAtIndex(0).GetAddress()
        self.addr3 = self.bp3.GetLocationAtIndex(0).GetAddress()

        self.assertTrue(self.addr1.IsValid())
        self.assertTrue(self.addr2.IsValid())
        self.assertTrue(self.addr3.IsValid())

    def test_address_range_default(self):
        """Testing default constructor."""
        empty_range = lldb.SBAddressRange()
        self.assertEqual(empty_range.IsValid(), False)

    def test_address_range_construction(self):
        """Make sure the construction and getters work."""
        range = lldb.SBAddressRange(self.addr1, 8)
        self.assertEqual(range.IsValid(), True)
        self.assertEqual(range.GetBaseAddress(), self.addr1)
        self.assertEqual(range.GetByteSize(), 8)

    def test_address_range_clear(self):
        """Make sure the clear method works."""
        range = lldb.SBAddressRange(self.addr1, 8)
        self.assertEqual(range.IsValid(), True)
        self.assertEqual(range.GetBaseAddress(), self.addr1)
        self.assertEqual(range.GetByteSize(), 8)

        range.Clear()
        self.assertEqual(range.IsValid(), False)

    def test_function(self):
        """Make sure the range works in SBFunction APIs."""

        # Setup breakpoints in main
        loc = self.bp1.GetLocationAtIndex(0)
        loc_addr = loc.GetAddress()
        func = loc_addr.GetFunction()
        ranges = func.GetRanges()
        self.assertEqual(ranges.GetSize(), 1)

        range = ranges.GetAddressRangeAtIndex(0)
        self.assertEqual(
            range.GetByteSize(),
            func.GetEndAddress().GetOffset() - func.GetStartAddress().GetOffset(),
        )
        self.assertEqual(
            range.GetBaseAddress().GetOffset(),
            func.GetStartAddress().GetOffset(),
        )

    def test_block(self):
        """Make sure the range works in SBBlock APIs."""
        loc = self.bp1.GetLocationAtIndex(0)
        loc_addr = loc.GetAddress()
        block = loc_addr.GetBlock()

        ranges = block.GetRanges()
        self.assertEqual(ranges.GetSize(), 1)

        range = ranges.GetAddressRangeAtIndex(0)
        self.assertEqual(
            range.GetByteSize(),
            block.GetRangeEndAddress(0).GetOffset()
            - block.GetRangeStartAddress(0).GetOffset(),
        )
        self.assertEqual(
            range.GetBaseAddress().GetOffset(),
            block.GetRangeStartAddress(0).GetOffset(),
        )

    def test_address_range_list(self):
        """Make sure the SBAddressRangeList works by adding and getting ranges."""
        range1 = lldb.SBAddressRange(self.addr1, 8)
        range2 = lldb.SBAddressRange(self.addr2, 16)
        range3 = lldb.SBAddressRange(self.addr3, 32)

        range_list = lldb.SBAddressRangeList()
        self.assertEqual(range_list.GetSize(), 0)

        range_list.Append(range1)
        range_list.Append(range2)
        range_list.Append(range3)
        self.assertEqual(range_list.GetSize(), 3)
        self.assertRaises(IndexError, lambda: range_list[3])

        range1_copy = range_list.GetAddressRangeAtIndex(0)
        self.assertEqual(range1.GetByteSize(), range1_copy.GetByteSize())
        self.assertEqual(
            range1.GetBaseAddress().GetOffset(),
            range1_copy.GetBaseAddress().GetOffset(),
        )

        range2_copy = range_list.GetAddressRangeAtIndex(1)
        self.assertEqual(range2.GetByteSize(), range2_copy.GetByteSize())
        self.assertEqual(
            range2.GetBaseAddress().GetOffset(),
            range2_copy.GetBaseAddress().GetOffset(),
        )

        range3_copy = range_list.GetAddressRangeAtIndex(2)
        self.assertEqual(range3.GetByteSize(), range3_copy.GetByteSize())
        self.assertEqual(
            range3.GetBaseAddress().GetOffset(),
            range3_copy.GetBaseAddress().GetOffset(),
        )

        range_list.Clear()
        self.assertEqual(range_list.GetSize(), 0)

    def test_address_range_list_len(self):
        """Make sure the len() operator works."""
        range = lldb.SBAddressRange(self.addr1, 8)

        range_list = lldb.SBAddressRangeList()
        self.assertEqual(len(range_list), 0)

        range_list.Append(range)
        self.assertEqual(len(range_list), 1)

    def test_address_range_list_iterator(self):
        """Make sure the SBAddressRangeList iterator works."""
        range1 = lldb.SBAddressRange(self.addr1, 8)
        range2 = lldb.SBAddressRange(self.addr2, 16)
        range3 = lldb.SBAddressRange(self.addr3, 32)

        range_list = lldb.SBAddressRangeList()
        range_list.Append(range1)
        range_list.Append(range2)
        range_list.Append(range3)
        self.assertEqual(range_list.GetSize(), 3)

        # Test the iterator
        for range in range_list:
            self.assertTrue(range.IsValid())

    def test_address_range_print_invalid(self):
        """Make sure the SBAddressRange can be printed when invalid."""
        range = lldb.SBAddressRange()
        self.assertEqual(str(range), "[0xffffffffffffffff-0xffffffffffffffff)")

    def test_address_range_print_resolved(self):
        """Make sure the SBAddressRange can be printed when resolved."""
        lldb.target = self.target
        error = lldb.SBError()
        process = self.target.Launch(self.launch_info, error)
        self.assertTrue(error.Success(), "Make sure process launched successfully")
        self.assertTrue(process, PROCESS_IS_VALID)
        self.assertState(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
        script = (
            "script "
            + "bp = lldb.target.GetBreakpointAtIndex(0);"
            + "loc = bp.GetLocationAtIndex(0);"
            + "loc_addr = loc.GetAddress();"
            + "func = loc_addr.GetFunction();"
            + "range = func.GetRanges().GetAddressRangeAtIndex(0);"
            + "print(range)"
        )

        interp = self.dbg.GetCommandInterpreter()
        result = lldb.SBCommandReturnObject()
        interp.HandleCommand(script, result, False)
        self.assertTrue(result.Succeeded(), "script command succeeded")
        # [0x1000-0x2000] // Resolved with target or addresses without sections
        self.assertRegex(result.GetOutput(), r"^\[0x[0-9a-f]+\-0x[0-9a-f]+\)")
        process.Kill()

    def test_address_range_print_no_section_resolved(self):
        """Make sure the SBAddressRange can be printed with no secion."""
        lldb.target = self.target
        error = lldb.SBError()
        process = self.target.Launch(self.launch_info, error)
        self.assertTrue(error.Success(), "Make sure process launched successfully")
        self.assertTrue(process, PROCESS_IS_VALID)
        self.assertState(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)

        loc = self.bp1.GetLocationAtIndex(0)
        loc_addr = loc.GetAddress()
        func = loc_addr.GetFunction()
        range = func.GetRanges().GetAddressRangeAtIndex(0)

        addr = lldb.SBAddress()
        addr.SetAddress(lldb.SBSection(), range.GetBaseAddress().GetOffset())
        self.assertFalse(addr.GetSection().IsValid())
        range = lldb.SBAddressRange(addr, range.GetByteSize())

        range_str = str(range)
        # [0x1000-0x2000] // Resolved with target or addresses without sections
        self.assertRegex(range_str, r"^\[0x[0-9a-f]+\-0x[0-9a-f]+\)$")
        process.Kill()

    def test_address_range_print_not_resolved(self):
        """Make sure the SBAddressRange can be printed when not resolved."""
        range = lldb.SBAddressRange(self.addr1, 8)
        range_str = str(range)
        # a.out[0x1000-0x2000] // Without target
        self.assertRegex(range_str, r"^a.out\[0x[0-9a-f]+\-0x[0-9a-f]+\)$")

    def test_address_range_list_print(self):
        """Make sure the SBAddressRangeList can be printed."""
        range1 = lldb.SBAddressRange(self.addr1, 8)
        range2 = lldb.SBAddressRange(self.addr2, 16)
        range3 = lldb.SBAddressRange(self.addr3, 32)
        self.dbg.SetAsync(True)

        range_list = lldb.SBAddressRangeList()
        self.assertEqual(range_list.GetSize(), 0)

        range_list.Append(range1)
        range_list.Append(range2)
        range_list.Append(range3)
        self.assertEqual(range_list.GetSize(), 3)

        range_list_str = str(range_list)
        self.assertTrue(range_list_str.startswith("["))
        self.assertGreater(range_list_str.count(","), 1)
        self.assertTrue(range_list_str.endswith("]"))

    def test_address_range_list_indexing(self):
        """Make sure the SBAddressRangeList can be printed."""
        range1 = lldb.SBAddressRange(self.addr1, 8)
        range2 = lldb.SBAddressRange(self.addr2, 16)
        range_list = lldb.SBAddressRangeList()
        range_list.Append(range1)
        range_list.Append(range2)

        self.assertEqual(range_list.GetSize(), 2)
        self.assertRaises(IndexError, lambda: range_list[2])
        self.assertRaises(TypeError, lambda: range_list["0"])
        self.assertEqual(range_list[0], range1)
        self.assertEqual(range_list[1], range2)
        self.assertEqual(range_list[-1], range2)
        self.assertEqual(range_list[-2], range1)