angr 9.2.87__py3-none-manylinux2014_x86_64.whl → 9.2.89__py3-none-manylinux2014_x86_64.whl

tests/analyses/reaching_definitions/test_dep_graph.py

@@ -1,432 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=no-self-use
-from random import randrange
-from unittest import main, mock, TestCase
-import networkx
-
-import claripy
-
-from angr.code_location import CodeLocation, ExternalCodeLocation
-from angr.knowledge_plugins.key_definitions.atoms import Atom, MemoryLocation, Register
-from angr.knowledge_plugins.key_definitions.definition import Definition
-from angr.analyses.reaching_definitions.dep_graph import DepGraph
-
-
-_PAST_N = set()
-
-
-def unique_randrange(range_):
-    n = randrange(range_)
-    while n in _PAST_N:
-        n = randrange(range_)
-    _PAST_N.add(n)
-    return n
-
-
-def _a_mock_definition(atom: Atom = None):
-    # Randomise code locations to forcefully produce "different" <Definition>s.
-    statement_index = unique_randrange(1000)
-    code_location = CodeLocation(0x42, statement_index)
-    return Definition(atom, code_location)
-
-
-class TestDepGraph(TestCase):
-    class ArchMock:
-        def __init__(self):
-            pass
-
-        @property
-        def bits(self):
-            return 32
-
-    class CFGMock:
-        def __init__(self, memory_data):
-            self._memory_data = memory_data
-
-        @property
-        def memory_data(self):
-            return self._memory_data
-
-    class MemoryDataMock:
-        def __init__(self, address, content, size, sort):
-            self._address = address
-            self._content = content
-            self._size = size
-            self._sort = sort
-
-        @property
-        def address(self):
-            return self._address
-
-        @property
-        def content(self):
-            return self._content
-
-        @property
-        def size(self):
-            return self._size
-
-        @property
-        def sort(self):
-            return self._sort
-
-    class SectionMock:
-        def __init__(self, is_writable):
-            self._is_writable = is_writable
-
-        @property
-        def is_writable(self):
-            return self._is_writable
-
-    class MainObjectMock:
-        def __init__(self, section):
-            self._section = section
-
-        def find_section_containing(self, _):
-            return self._section
-
-    class LoaderMock:
-        def __init__(self, main_object):
-            self._main_object = main_object
-
-        @property
-        def main_object(self):
-            return self._main_object
-
-    def setUp(self):
-        self.memory_address = 0x42424242
-
-        self.string_in_memory = "some string of data in memory"
-        self.string_in_memory_length = len(self.string_in_memory + "\x00")
-
-    def test_dep_graph_has_a_default_graph(self):
-        dep_graph = DepGraph()
-        self.assertEqual(isinstance(dep_graph.graph, networkx.DiGraph), True)
-
-    def test_dep_graph_refuses_to_instanciate_with_an_inadequate_graph(self):
-        a_graph = networkx.DiGraph([(1, 2)])
-        self.assertRaises(TypeError, DepGraph, a_graph)
-
-    def test_delegate_add_node_to_the_underlying_graph_object(self):
-        with mock.patch.object(networkx.DiGraph, "add_node") as digraph_add_node_mock:
-            definition = _a_mock_definition()
-            dep_graph = DepGraph()
-            dep_graph.add_node(definition)
-
-            digraph_add_node_mock.assert_called_once_with(definition)
-
-    def test_delegate_nodes_to_the_underlying_graph_object(self):
-        with mock.patch.object(networkx.DiGraph, "nodes") as digraph_nodes_mock:
-            dep_graph = DepGraph()
-            dep_graph.nodes()
-
-            digraph_nodes_mock.assert_called_once()
-
-    def test_delegate_predecessors_to_the_underlying_graph_object(self):
-        with mock.patch.object(networkx.DiGraph, "predecessors") as digraph_predecessors_mock:
-            definition = _a_mock_definition()
-            dep_graph = DepGraph()
-            dep_graph.predecessors(definition)
-
-            digraph_predecessors_mock.assert_called_once_with(definition)
-
-    def test_delegate_add_edge_to_the_underlying_graph_object(self):
-        with mock.patch.object(networkx.DiGraph, "add_edge") as digraph_add_edge_mock:
-            use = (_a_mock_definition(), _a_mock_definition())
-            labels = {"attribute1": "value1", "attribute2": "value2"}
-
-            dep_graph = DepGraph()
-            dep_graph.add_edge(*use, **labels)
-
-            digraph_add_edge_mock.assert_called_once_with(*use, **labels)
-
-    def test_transitive_closure_of_a_node(self):
-        dep_graph = DepGraph()
-
-        # A -> B, B -> D, C -> D
-        A = _a_mock_definition()
-        B = _a_mock_definition()
-        C = _a_mock_definition()
-        D = _a_mock_definition()
-        uses = [
-            (A, B),
-            (B, D),
-            (C, D),
-        ]
-
-        for use in uses:
-            dep_graph.add_edge(*use)
-
-        result = dep_graph.transitive_closure(D)
-        result_nodes = set(result.nodes)
-        result_edges = set(result.edges)
-
-        self.assertSetEqual(result_nodes, {D, B, C, A})
-        self.assertSetEqual(result_edges, {(B, D), (C, D), (A, B)})
-
-    def test_transitive_closure_includes_beginning_node_with_memoized_content(self):
-        dep_graph = DepGraph()
-        # A -> B
-        # B -> C
-        # C -> D
-        A = _a_mock_definition()
-        B = _a_mock_definition()
-        C = _a_mock_definition()
-        D = _a_mock_definition()
-        uses = [(A, B), (B, C), (C, D)]
-        for use in uses:
-            dep_graph.add_edge(*use)
-
-        closure_0 = dep_graph.transitive_closure(C)
-        self.assertNotIn(D, closure_0)
-
-        closure_1 = dep_graph.transitive_closure(D)
-        self.assertIn(D, closure_1)
-        self.assertTrue(closure_1.has_edge(A, B))
-        self.assertTrue(closure_1.has_edge(B, C))
-        self.assertTrue(closure_1.has_edge(C, D))
-
-    def test_transitive_closure_of_a_node_should_copy_labels_from_original_graph(self):
-        dep_graph = DepGraph()
-
-        # A -> B
-        A = _a_mock_definition()
-        B = _a_mock_definition()
-        uses = [(A, B)]
-
-        for use in uses:
-            dep_graph.add_edge(*use, label="some data")
-
-        result = dep_graph.transitive_closure(B).get_edge_data(A, B)["label"]
-
-        self.assertEqual(result, "some data")
-
-    def test_transitive_closure_of_a_node_on_a_graph_with_loops_should_still_terminate(self):
-        dep_graph = DepGraph()
-
-        # A -> B, B -> C, C -> D, D -> A
-        A = _a_mock_definition()
-        B = _a_mock_definition()
-        C = _a_mock_definition()
-        D = _a_mock_definition()
-        uses = [
-            (A, B),
-            (B, C),
-            (C, D),
-            (D, A),
-        ]
-
-        for use in uses:
-            dep_graph.add_edge(*use)
-
-        result = dep_graph.transitive_closure(C)
-        result_nodes = set(result.nodes)
-        result_edges = set(result.edges)
-
-        self.assertSetEqual(result_nodes, {A, B, C, D})
-        self.assertSetEqual(result_edges, {(A, B), (B, C), (C, D), (D, A)})
-
-    def test_contains_atom_returns_true_if_the_dependency_graph_contains_a_definition_of_the_given_atom(self):
-        dep_graph = DepGraph()
-
-        r0 = Register(8, 4)
-
-        # A -> B
-        A = _a_mock_definition(r0)
-        B = _a_mock_definition()
-
-        uses = [(A, B)]
-
-        for use in uses:
-            dep_graph.add_edge(*use)
-
-        result = dep_graph.contains_atom(r0)
-        self.assertTrue(result)
-
-    def test_contains_atom_returns_false_if_the_dependency_graph_does_not_contain_a_definition_of_the_given_atom(self):
-        dep_graph = DepGraph()
-
-        # A -> B
-        A = _a_mock_definition()
-        B = _a_mock_definition()
-
-        uses = [(A, B)]
-
-        for use in uses:
-            dep_graph.add_edge(*use)
-
-        result = dep_graph.contains_atom(Register(8, 4))
-        self.assertFalse(result)
-
-    def test_add_dependencies_for_concrete_pointers_of_fails_if_the_given_definition_is_not_in_the_graph(self):
-        dependency_graph = DepGraph()
-
-        definition = Definition(
-            Register(0, 4),
-            CodeLocation(0x42, 0),
-        )
-
-        with self.assertRaises(AssertionError) as cm:
-            dependency_graph.add_dependencies_for_concrete_pointers_of([claripy.BVS("TOP", 32)], definition, None, None)
-
-        ex = cm.exception
-        self.assertEqual(str(ex), "The given Definition must be present in the given graph.")
-
-    def test_add_dependencies_for_concrete_pointers_of_adds_a_definition_for_data_pointed_to_by_given_definition(self):
-        arch = self.ArchMock()
-        loader = self.LoaderMock(self.MainObjectMock(self.SectionMock(True)))
-
-        memory_datum = self.MemoryDataMock(
-            self.memory_address, str.encode(self.string_in_memory), len(self.string_in_memory), "string"
-        )
-        cfg = self.CFGMock({self.memory_address: memory_datum})
-
-        register_definition = Definition(
-            Register(0, 4),
-            None,
-        )
-
-        dependency_graph = DepGraph()
-        dependency_graph.add_node(register_definition)
-
-        dependency_graph.add_dependencies_for_concrete_pointers_of(
-            [claripy.BVV(self.memory_address, arch.bits)], register_definition, cfg, loader
-        )
-
-        memory_definition = Definition(
-            MemoryLocation(self.memory_address, self.string_in_memory_length),
-            ExternalCodeLocation(),
-        )
-
-        nodes = list(dependency_graph.nodes())
-        predecessors = list(dependency_graph.graph.predecessors(register_definition))
-        self.assertEqual(nodes, [register_definition, memory_definition])
-        self.assertListEqual(predecessors, [memory_definition])
-
-    def test_add_dependencies_for_concrete_pointers_of_does_nothing_if_data_pointed_to_by_definition_is_already_in_dependency_graph(  # noqa: E501
-        self,
-    ):
-        arch = self.ArchMock()
-        loader = self.LoaderMock(self.MainObjectMock(self.SectionMock(True)))
-
-        memory_datum = self.MemoryDataMock(
-            self.memory_address, str.encode(self.string_in_memory), len(self.string_in_memory), "string"
-        )
-        cfg = self.CFGMock({self.memory_address: memory_datum})
-
-        memory_location_definition = Definition(
-            MemoryLocation(self.memory_address, self.string_in_memory_length),
-            CodeLocation(0, 0),
-        )
-
-        register_definition = Definition(
-            Register(0, 4),
-            CodeLocation(0x42, 0),
-        )
-
-        dependency_graph = DepGraph(networkx.DiGraph([(memory_location_definition, register_definition)]))
-
-        nodes_before_call = dependency_graph.nodes()
-
-        dependency_graph.add_dependencies_for_concrete_pointers_of(
-            [claripy.BVV(self.memory_address, arch.bits)], register_definition, cfg, loader
-        )
-
-        self.assertEqual(nodes_before_call, dependency_graph.nodes())
-
-    def test_add_dependencies_for_concrete_pointers_of_does_nothing_if_pointer_is_not_concrete(self):
-        arch = self.ArchMock()
-        cfg = self.CFGMock({})
-        loader = self.LoaderMock(self.MainObjectMock(self.SectionMock(True)))
-
-        register_definition = Definition(
-            Register(0, 4),
-            CodeLocation(0x42, 0),
-        )
-
-        dependency_graph = DepGraph()
-        dependency_graph.add_node(register_definition)
-
-        nodes_before_call = dependency_graph.nodes()
-
-        dependency_graph.add_dependencies_for_concrete_pointers_of(
-            [claripy.BVS("TOP", arch.bits)],
-            register_definition,
-            cfg,
-            loader,
-        )
-
-        self.assertEqual(nodes_before_call, dependency_graph.nodes())
-
-    def test_add_dependencies_for_concrete_pointers_of_create_memory_location_with_undefined_data_if_data_pointed_to_by_definition_is_not_known(  # noqa: E501
-        self,
-    ):
-        arch = self.ArchMock()
-        loader = self.LoaderMock(self.MainObjectMock(self.SectionMock(True)))
-
-        datum_content = None
-        datum_size = 0x4242
-        memory_datum = self.MemoryDataMock(self.memory_address, datum_content, datum_size, "unknown")
-        cfg = self.CFGMock({self.memory_address: memory_datum})
-
-        memory_definition = Definition(
-            MemoryLocation(self.memory_address, datum_size),
-            ExternalCodeLocation(),
-        )
-
-        register_definition = Definition(
-            Register(0, 4),
-            CodeLocation(0x42, 0),
-        )
-
-        dependency_graph = DepGraph()
-        dependency_graph.add_node(register_definition)
-
-        dependency_graph.add_dependencies_for_concrete_pointers_of(
-            [claripy.BVV(self.memory_address, arch.bits)],
-            register_definition,
-            cfg,
-            loader,
-        )
-
-        nodes = list(dependency_graph.nodes())
-        predecessors = list(dependency_graph.graph.predecessors(register_definition))
-        self.assertEqual(nodes, [register_definition, memory_definition])
-        self.assertListEqual(predecessors, [memory_definition])
-
-    def test_add_dependencies_for_concrete_pointers_of_adds_a_definition_with_codelocation_in_binary_if_data_in_readonly_memory(  # noqa: E501
-        self,
-    ):
-        arch = self.ArchMock()
-
-        writable = False
-        loader = self.LoaderMock(self.MainObjectMock(self.SectionMock(writable)))
-
-        memory_datum = self.MemoryDataMock(
-            self.memory_address, str.encode(self.string_in_memory), len(self.string_in_memory), "string"
-        )
-        cfg = self.CFGMock({self.memory_address: memory_datum})
-
-        register_definition = Definition(
-            Register(0, 4),
-            CodeLocation(0x42, 0),
-        )
-
-        dependency_graph = DepGraph()
-        dependency_graph.add_node(register_definition)
-
-        dependency_graph.add_dependencies_for_concrete_pointers_of(
-            [claripy.BVV(self.memory_address, arch.bits)],
-            register_definition,
-            cfg,
-            loader,
-        )
-
-        origin_codelocation = CodeLocation(0, 0, info={"readonly": True})
-
-        predecessor = list(dependency_graph.graph.predecessors(register_definition))[0]
-        self.assertEqual(predecessor.codeloc, origin_codelocation)
-
-
-if __name__ == "__main__":
-    main()

tests/analyses/reaching_definitions/test_function_handler.py

@@ -1,131 +0,0 @@
-#!/usr/bin/env python3
-# pylint:disable=missing-class-docstring,no-self-use
-__package__ = __package__ or "tests.analyses.reaching_definitions"  # pylint:disable=redefined-builtin
-
-from typing import TYPE_CHECKING
-import os
-from unittest import main, TestCase
-
-import claripy
-
-import angr
-from angr.analyses.reaching_definitions import FunctionHandler
-from angr.storage.memory_mixins.paged_memory.pages.multi_values import MultiValues
-from angr.errors import SimMemoryMissingError
-
-if TYPE_CHECKING:
-    from angr.analyses.reaching_definitions.rd_state import ReachingDefinitionsState
-    from angr.analyses.reaching_definitions import FunctionCallData
-
-from ...common import bin_location
-
-
-TESTS_LOCATION = os.path.join(bin_location, "tests")
-
-
-def load_cstring_from_loader_memory(project, addr: int, as_str: bool = False):
-    # This function loads a null-terminated string from the static memory region
-    s = b""
-    while True:
-        char_addr = addr + len(s)
-        try:
-            v = project.loader.memory.load(char_addr, 1)
-        except KeyError:
-            break
-        if v == b"\x00":
-            break
-        s += v
-    return s.decode("utf-8") if as_str else (s + b"\x00")
-
-
-def load_cstring_from_memory_definitions(ld, addr: int, as_str: bool = False):
-    # This function loads a null-terminated string from the memory definitions
-    s = b""
-    while True:
-        char_addr = addr + len(s)
-        try:
-            v = ld.memory.load(char_addr, 1).one_value().concrete_value
-        except SimMemoryMissingError:
-            break
-        if v == 0:
-            break
-        s += v.to_bytes(1, "little")
-    return s.decode("utf-8") if as_str else (s + b"\x00")
-
-
-class CustomFunctionHandler(FunctionHandler):
-    def __init__(self, project):
-        self.project = project
-        self.system_cmd = ""
-        self.strcpy_addr = None
-        self.sscanf_str_addr = None
-        self.sscanf_str = None
-        self.sscanf_fmtstr_addr = None
-        self.sscanf_fmtstr = None
-        self.sscanf_out_value = None
-        self.malloc_sizes = []
-
-    def handle_impl_malloc(self, state: "ReachingDefinitionsState", data: "FunctionCallData"):
-        ((src_atom,),) = data.args_atoms
-
-        src_value = state.get_values(src_atom).one_value().concrete_value
-        self.malloc_sizes.append(src_value)
-        data.depends(list(data.ret_atoms)[0], value=MultiValues(claripy.BVV(0x12345678, 64)))
-
-    def handle_impl___isoc99_sscanf(self, state: "ReachingDefinitionsState", data: "FunctionCallData"):
-        (str_atom,), (fmtstr_atom,), (out_atom,) = data.args_atoms[:3]
-
-        # string
-        str_addr = state.get_values(str_atom).one_value().concrete_value
-        self.sscanf_str_addr = str_addr
-        str_ = load_cstring_from_loader_memory(self.project, str_addr)
-        self.sscanf_str = str_
-
-        # format string: "%d"
-        fmtstr_addr = state.get_values(fmtstr_atom).one_value().concrete_value
-        self.sscanf_fmtstr_addr = fmtstr_addr
-        fmtstr = load_cstring_from_loader_memory(self.project, str_addr)
-        self.sscanf_fmtstr = fmtstr
-
-        # out pointer
-        (dst,) = state.pointer_to_atoms(state.get_values(out_atom), size=4, endness=state.arch.memory_endness)
-        (src,) = state.pointer_to_atoms(state.get_values(str_atom), size=len(str_), endness="Iend_BE")
-        self.sscanf_out_value = int(str_.strip(b"\x00"))
-        data.depends(dst, src, value=MultiValues(claripy.BVV(self.sscanf_out_value, 32)))
-
-    def handle_impl_strcpy(self, state: "ReachingDefinitionsState", data: "FunctionCallData"):
-        (dst_atom,), (src_atom,) = data.args_atoms
-
-        # Assume source is a constant string
-        src_addr = state.get_values(src_atom).one_value().concrete_value
-        self.strcpy_addr = src_addr
-        src_str = load_cstring_from_loader_memory(self.project, src_addr)
-        src_str_size = len(src_str)
-
-        (dst,) = state.pointer_to_atoms(state.get_values(dst_atom), size=src_str_size, endness="Iend_BE")
-        (src,) = state.pointer_to_atoms(state.get_values(src_atom), size=src_str_size, endness="Iend_BE")
-
-        data.depends(dst, src, value=MultiValues(claripy.BVV(src_str)))
-
-    def handle_impl_system(self, state: "ReachingDefinitionsState", data: "FunctionCallData"):
-        (cmd_atom,) = data.args_atoms[0]
-        cmd_addr = state.get_values(cmd_atom).one_value().concrete_value
-        self.system_cmd = load_cstring_from_memory_definitions(state.live_definitions, cmd_addr, as_str=True)
-
-
-class TestFunctionhandler(TestCase):
-    def test_function_handler_depends_has_endness(self):
-        filename = os.path.join(TESTS_LOCATION, "x86_64", "rda_function_handler")
-        project = angr.Project(filename, auto_load_libs=False)
-        _ = project.analyses.CFGFast()
-        handler = CustomFunctionHandler(project)
-        _ = project.analyses.ReachingDefinitions("main", function_handler=handler)
-
-        assert handler.system_cmd == "ABCDEFGH"
-        assert handler.sscanf_str == b"12345678\x00"
-        assert handler.sscanf_out_value == 12345678
-        assert handler.malloc_sizes == [20, 12345678]
-
-
-if __name__ == "__main__":
-    main()

tests/analyses/reaching_definitions/test_heap_allocator.py

@@ -1,46 +0,0 @@
-#!/usr/bin/env python3
-from unittest import main, TestCase
-
-from angr.analyses.reaching_definitions.heap_allocator import HeapAllocator
-from angr.knowledge_plugins.key_definitions.heap_address import HeapAddress
-from angr.knowledge_plugins.key_definitions.unknown_size import UNKNOWN_SIZE
-
-
-class TestHeapAllocator(TestCase):
-    UNKNOWN_SIZE_DEFAULT_CONCRETE_VALUE = 8
-
-    def setUp(self):
-        self.heap_allocator = HeapAllocator(self.UNKNOWN_SIZE_DEFAULT_CONCRETE_VALUE)
-
-    def test_allocate_returns_an_entry_address(self):
-        address = self.heap_allocator.allocate(0x10)
-        self.assertTrue(isinstance(address, HeapAddress))
-
-    def test_allocate_create_an_entry_after_the_previous_one(self):
-        size_of_first_chunck = 0x10
-        address = self.heap_allocator.allocate(size_of_first_chunck)
-        other_address = self.heap_allocator.allocate(0x10)
-
-        self.assertEqual(other_address.value - address.value, size_of_first_chunck)
-
-    def test_allocate_given_an_undefined_size_still_gives_a_concrete_address(self):
-        size_of_first_chunck = UNKNOWN_SIZE
-        address = self.heap_allocator.allocate(size_of_first_chunck)
-        other_address = self.heap_allocator.allocate(0x10)
-
-        self.assertEqual(other_address.value - address.value, self.UNKNOWN_SIZE_DEFAULT_CONCRETE_VALUE)
-
-    def test_allocated_addresses_keeps_track_of_memory_chuncks_in_use(self):
-        address = self.heap_allocator.allocate(0x10)
-
-        self.assertTrue(address in self.heap_allocator.allocated_addresses)
-
-    def test_free_removes_the_address_from_list_of_allocated_ones(self):
-        address = self.heap_allocator.allocate(0x10)
-        self.heap_allocator.free(address)
-
-        self.assertFalse(address in self.heap_allocator.allocated_addresses)
-
-
-if __name__ == "__main__":
-    main()

tests/analyses/reaching_definitions/test_rd_state.py

@@ -1,78 +0,0 @@
-#!/usr/bin/env python3
-__package__ = __package__ or "tests.analyses.reaching_definitions"  # pylint:disable=redefined-builtin
-
-import os
-import random
-
-from unittest import main, mock, TestCase
-
-import archinfo
-
-from angr.analyses.reaching_definitions.heap_allocator import HeapAllocator
-from angr.analyses.reaching_definitions.rd_state import ReachingDefinitionsState
-from angr.analyses.reaching_definitions.subject import SubjectType
-from angr.knowledge_plugins.key_definitions.live_definitions import LiveDefinitions
-from angr.code_location import CodeLocation
-
-from ...common import bin_location
-
-
-TESTS_LOCATION = os.path.join(bin_location, "tests")
-
-
-class _MockFunctionSubject:  # pylint:disable=too-few-public-methods
-    class _MockFunction:  # pylint:disable=too-few-public-methods
-        def __init__(self):
-            self.addr = 0x42
-
-    def __init__(self):
-        self.type = SubjectType.Function
-        self.cc = None  # pylint:disable=invalid-name
-        self.content = self._MockFunction()
-
-
-class TestReachingDefinitionsState(TestCase):
-    def test_initializing_rd_state_for_ppc_without_rtoc_value_should_raise_an_error(self):
-        arch = archinfo.arch_ppc64.ArchPPC64()
-        self.assertRaises(
-            ValueError, ReachingDefinitionsState, CodeLocation(0x42, None), arch=arch, subject=_MockFunctionSubject()
-        )
-
-    def test_initializing_rd_state_for_ppc_with_rtoc_value(self):
-        arch = archinfo.arch_ppc64.ArchPPC64()
-        rtoc_value = random.randint(0, 0xFFFFFFFFFFFFFFFF)
-
-        state = ReachingDefinitionsState(
-            CodeLocation(0x42, None), arch=arch, subject=_MockFunctionSubject(), rtoc_value=rtoc_value
-        )
-
-        rtoc_offset = arch.registers["rtoc"][0]
-        rtoc_definition_value = state.registers.load(rtoc_offset, size=8)
-
-        self.assertIsNotNone(rtoc_definition_value.one_value())
-        v = rtoc_definition_value.one_value()
-        self.assertFalse(v.symbolic)
-        self.assertEqual(v.concrete_value, rtoc_value)
-
-    def test_rd_state_gets_a_default_heap_allocator(self):
-        arch = archinfo.arch_arm.ArchARM()
-        state = ReachingDefinitionsState(CodeLocation(0x42, None), arch, _MockFunctionSubject())
-
-        self.assertTrue(isinstance(state.heap_allocator, HeapAllocator))
-
-    def test_get_sp_delegates_to_the_underlying_live_definitions(self):  # pylint:disable=no-self-use
-        arch = archinfo.arch_arm.ArchARM()
-        live_definitions = LiveDefinitions(arch)
-
-        state = ReachingDefinitionsState(
-            CodeLocation(0x42, None), arch=arch, subject=_MockFunctionSubject(), live_definitions=live_definitions
-        )
-
-        with mock.patch.object(LiveDefinitions, "get_sp") as live_definitions_get_sp_mock:
-            state.get_sp()
-
-            live_definitions_get_sp_mock.assert_called_once()
-
-
-if __name__ == "__main__":
-    main()