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

tests/knowledge_plugins/functions/test_prototypes.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.knowledge_plugins.functions"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-import angr.calling_conventions
-from angr.sim_type import SimTypePointer
-
-from ...common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestPrototypes(unittest.TestCase):
-    def test_function_prototype(self):
-        proj = angr.Project(os.path.join(test_location, "x86_64", "all"), auto_load_libs=False)
-
-        func = angr.knowledge_plugins.Function(proj.kb.functions, 0x100000, name="strcmp")
-        func.prototype = angr.SIM_LIBRARIES["libc.so.6"].prototypes[func.name]
-        func.calling_convention = angr.calling_conventions.default_cc(proj.arch.name, platform="Linux")(proj.arch)
-
-    def test_find_prototype(self):
-        proj = angr.Project(os.path.join(test_location, "x86_64", "all"), auto_load_libs=False)
-
-        cfg = proj.analyses.CFG()
-
-        func = cfg.kb.functions.function(name="strcmp", plt=False)
-        func.calling_convention = angr.calling_conventions.default_cc(proj.arch.name, platform="Linux")(proj.arch)
-
-        func.find_declaration()
-
-        arg_locs = func.calling_convention.arg_locs(func.prototype)
-
-        assert len(arg_locs) == 2
-        assert arg_locs[0].reg_name == "rdi"
-        assert arg_locs[1].reg_name == "rsi"
-
-    def test_cpp_void_pointer(self):
-        proj = angr.Project(os.path.join(test_location, "x86_64", "void_pointer"), auto_load_libs=False)
-
-        cfg = proj.analyses.CFG()
-        proj.analyses.CompleteCallingConventions(recover_variables=True, analyze_callsites=True)
-
-        func = cfg.kb.functions.function(name="_ZdlPvm", plt=True)
-        assert isinstance(func.prototype.args[0], SimTypePointer)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/knowledge_plugins/key_definitions/test_atoms.py

@@ -1,24 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring
-from unittest import main, TestCase
-
-from archinfo import ArchMIPS32
-
-from angr.calling_conventions import SimRegArg
-from angr.knowledge_plugins.key_definitions.atoms import Atom, Register
-
-
-class TestAtoms(TestCase):
-    def test_from_argument_instanciate_a_Register_when_given_a_SimRegArg(self):
-        argument = SimRegArg("r0", 4)
-        arch = ArchMIPS32()
-
-        result = Atom.from_argument(argument, arch)
-
-        self.assertTrue(isinstance(result, Register))
-        self.assertEqual(result.reg_offset, arch.registers["r0"][0])
-        self.assertEqual(result.size, 4)
-
-
-if __name__ == "__main__":
-    main()

tests/knowledge_plugins/key_definitions/test_environment.py

@@ -1,126 +0,0 @@
-#!/usr/bin/env python3
-from unittest import main, TestCase
-
-import claripy
-
-from angr.knowledge_plugins.key_definitions.environment import Environment
-from angr.knowledge_plugins.key_definitions.undefined import UNDEFINED
-
-
-class TestEnvironment(TestCase):
-    def setUp(self):
-        self.pointer_length = 8
-        self.pointer = 0x7FFFFFFFF00 - 0xFF
-
-    def test_get_returns_the_pointer_associated_with_an_existing_environment_variable(self):
-        name = "variable_name"
-        data = {claripy.BVV(self.pointer, self.pointer_length)}
-        environment = Environment(environment={name: data})
-
-        variable_names = {name}
-
-        result_values, _ = environment.get(variable_names)
-        self.assertEqual(result_values, data)
-
-    def test_get_returns_a_dataset_with_UNDEFINED_when_the_environment_variable_is_not_set(self):
-        environment = Environment(environment={})
-
-        name = "variable_name"
-        variable_names = {name}
-
-        result_values, _ = environment.get(variable_names)
-        self.assertEqual(result_values, {UNDEFINED})
-
-    def test_get_returns_values_associated_with_all_possible_given_names(self):
-        environment_data = {
-            "variable_name": {claripy.BVV(self.pointer, self.pointer_length)},
-            UNDEFINED: {UNDEFINED},
-        }
-        environment = Environment(environment=environment_data)
-
-        variable_names = {"variable_name", UNDEFINED}
-        expected_result = {claripy.BVV(self.pointer, self.pointer_length), UNDEFINED}
-
-        result_values, _ = environment.get(variable_names)
-        self.assertEqual(result_values, expected_result)
-
-    def test_get_fails_when_called_with_wrong_type_of_name(self):
-        environment = Environment(environment={})
-        variable_names = {claripy.BVV(0x42, 8 * 8)}
-
-        self.assertRaises(TypeError, environment.get, variable_names)
-
-    def test_get_result_tells_if_environment_knows_about_all_the_variables(self):
-        name = "variable_name"
-        data = {claripy.BVV(self.pointer, self.pointer_length)}
-        environment = Environment(environment={name: data})
-
-        name = "variable_name"
-        variable_names = {name}
-
-        _, has_unknown = environment.get(variable_names)
-        self.assertFalse(has_unknown)
-
-    def test_get_result_tells_if_environment_does_not_know_about_one_of_the_variable(self):
-        name = "variable_name"
-        data = {claripy.BVV(b"value\x00", 6 * 8)}
-        environment = Environment(environment={name: data})
-
-        name = "variable_name"
-        variable_names = {name, "unknown_name"}
-
-        _, has_unknown = environment.get(variable_names)
-        self.assertTrue(has_unknown)
-
-    def test_set_sets_associates_data_to_a_given_variable_name(self):
-        environment = Environment(environment={})
-
-        data = {claripy.BVV(b"value\x00", 6 * 8)}
-        environment.set("variable_name", data)
-
-        # Testing internal attribute which is not ideal, but I'am trying to not rely on any other behavior
-        # (e.g. without using `get`).
-        self.assertDictEqual(environment._environment, {"variable_name": data})
-
-    def test_set_sets_can_associate_data_to_UNDEFINED(self):
-        environment = Environment(environment={})
-
-        data = {claripy.BVV(b"value\x00", 6 * 8)}
-        environment.set(UNDEFINED, data)
-
-        # Testing internal attribute which is not ideal, but I'am trying to not rely on any other behavior
-        # (e.g. without using `get`).
-        self.assertDictEqual(environment._environment, {UNDEFINED: data})
-
-    def test_set_fails_when_wvariable_name_is_of_wrong_type(self):
-        environment = Environment(environment={})
-
-        data = {claripy.BVV(b"value\x00", 6 * 8)}
-
-        self.assertRaises(TypeError, environment.set, 0x42, data)
-
-    def test_merge_fails_when_merging_with_a_non_Environment_instance(self):
-        environment = Environment(environment={"variable_name": {claripy.BVV(b"value1\x00", 7 * 8)}})
-        other_environment = 0x42
-
-        self.assertRaises(TypeError, environment.merge, other_environment)
-
-    def test_merge_two_environments_merge_data_associated_with_each_variable(self):
-        first = "variable_name"
-        second = "other_variable_name"
-        environment = Environment(environment={first: {claripy.BVV(b"value1\x00", 7 * 8)}})
-        other_environment = Environment(environment={first: {claripy.BVV(b"value2\x00", 7 * 8)}, second: {UNDEFINED}})
-
-        expected_environment = Environment(
-            environment={
-                first: {claripy.BVV(b"value1\x00", 7 * 8), claripy.BVV(b"value2\x00", 7 * 8)},
-                second: {UNDEFINED},
-            }
-        )
-
-        env, _ = environment.merge(other_environment)
-        self.assertEqual(env, expected_environment)
-
-
-if __name__ == "__main__":
-    main()

tests/knowledge_plugins/key_definitions/test_heap_address.py

@@ -1,27 +0,0 @@
-#!/usr/bin/env python3
-from unittest import main, TestCase
-
-from angr.knowledge_plugins.key_definitions.heap_address import HeapAddress
-
-
-class TestHeapAddress(TestCase):
-    def test_expose_its_value_as_a_property(self):
-        address = HeapAddress(0x42)
-        self.assertEqual(address.value, 0x42)
-
-    def test_add_fails_if_value_added_is_not_int(self):
-        address = HeapAddress(0x0)
-        self.assertRaises(TypeError, address + 0x8)
-
-    def test_add_increase_the_heap_address_value_by_the_right_amount(self):
-        address = HeapAddress(0x0)
-        new_address = address + 0x8
-        self.assertEqual(new_address.value, 0x8)
-
-    def test_add_is_commutative(self):
-        address = HeapAddress(0x0)
-        self.assertEqual(address + 0x8, 0x8 + address)
-
-
-if __name__ == "__main__":
-    main()

tests/knowledge_plugins/key_definitions/test_live_definitions.py

@@ -1,72 +0,0 @@
-#!/usr/bin/env python3
-from unittest import main, TestCase
-
-import archinfo
-
-from angr.storage.memory_mixins.paged_memory.pages.multi_values import MultiValues
-from angr.knowledge_plugins.key_definitions.atoms import Register, SpOffset
-from angr.knowledge_plugins.key_definitions.live_definitions import LiveDefinitions
-
-
-class TestLiveDefinitions(TestCase):
-    def setUp(self):
-        self.arch = archinfo.arch_arm.ArchARM()
-
-        sp_offset = self.arch.registers["sp"][0]
-        self.sp_register = Register(sp_offset, self.arch.bytes)
-
-    def test_get_sp_retrieves_the_value_of_sp_register(self):
-        live_definitions = LiveDefinitions(self.arch)
-
-        offset = SpOffset(self.arch.bits, 0)
-        address = live_definitions.stack_address(offset.offset)
-        sp_value = MultiValues(offset_to_values={0: {address}})
-
-        live_definitions.kill_and_add_definition(self.sp_register, None, sp_value)
-
-        retrieved_sp_value = live_definitions.get_sp()
-
-        self.assertEqual(retrieved_sp_value, live_definitions.stack_offset_to_stack_addr(offset.offset))
-
-    def test_get_sp_fails_if_there_are_different_definitions_for_sp_with_different_values(self):
-        # To get multiple definitions of SP cohabiting, we need to create a `LiveDefinitions` via `.merge`:
-        # Let's create the "base" `LiveDefinitions`, holding *DIFFERENT* values.
-        live_definitions = LiveDefinitions(self.arch)
-
-        offset = SpOffset(self.arch.bits, 0)
-        address = live_definitions.stack_address(offset.offset)
-        sp_value = MultiValues(offset_to_values={0: {address}})
-        other_offset = SpOffset(self.arch.bits, 20)
-        other_address = live_definitions.stack_address(other_offset.offset)
-        other_sp_value = MultiValues(offset_to_values={0: {other_address}})
-
-        live_definitions.kill_and_add_definition(self.sp_register, 0x0, sp_value)
-        other_live_definitions = LiveDefinitions(self.arch)
-        other_live_definitions.kill_and_add_definition(self.sp_register, 0x1, other_sp_value)
-        # Then merge them.
-        live_definitions_with_multiple_sps, _ = live_definitions.merge(other_live_definitions)
-
-        self.assertRaises(AssertionError, live_definitions_with_multiple_sps.get_sp)
-
-    def test_get_sp_retrieves_the_value_of_sp_register_even_if_it_has_several_definitions(self):
-        # To get multiple definitions of SP cohabiting, we need to create a `LiveDefinitions` via `.merge`:
-        # Let's create the "base" `LiveDefinitions`, holding *THE SAME* values.
-        live_definitions = LiveDefinitions(self.arch)
-
-        offset = SpOffset(self.arch.bits, 0)
-        address = live_definitions.stack_address(offset.offset)
-        sp_value = MultiValues(offset_to_values={0: {address}})
-
-        live_definitions.kill_and_add_definition(self.sp_register, 0x1, sp_value)
-        other_live_definitions = LiveDefinitions(self.arch)
-        other_live_definitions.kill_and_add_definition(self.sp_register, 0x2, sp_value)
-        # Then merge them.
-        live_definitions_with_multiple_sps, _ = live_definitions.merge(other_live_definitions)
-
-        retrieved_sp_value = live_definitions_with_multiple_sps.get_sp()
-
-        self.assertEqual(retrieved_sp_value, live_definitions.stack_offset_to_stack_addr(offset.offset))
-
-
-if __name__ == "__main__":
-    main()

tests/knowledge_plugins/test_dwarf_variables.py

@@ -1,240 +0,0 @@
-#!/usr/bin/env python3
-__package__ = __package__ or "tests.knowledge_plugins"  # pylint:disable=redefined-builtin
-
-import math
-import os
-from unittest import TestCase, main
-
-import angr
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestDwarfVariables(TestCase):
-    """
-    Test dwarf variables import and resolution of these variables
-    """
-
-    def setUp(self):
-        self.p = angr.Project(os.path.join(test_location, "x86_64", "various_variables"), load_debug_info=True)
-        self.p.kb.dvars.load_from_dwarf()
-        simgr = self.p.factory.simgr()
-        main_addr = self.p.loader.find_symbol("main").rebased_addr
-        simgr.explore(find=main_addr)
-        self.s = simgr.found[0]
-        self.addr2line = self.p.loader.main_object.addr_to_line
-
-    # tests for global variables
-
-    def test_resolve_a(self):
-        a = self.s.dvars["a"]
-        computed_result = []
-        for i in range(9):
-            computed_result.append(a.array(i).mem.concrete)
-        expected_result = [1, 2, 3, 4, 5, 6, 7, 8, 9]
-        self.assertEqual(computed_result, expected_result, 'global variable "a" array values is computed wrong')
-
-    def test_resolve_pointer(self):
-        pointer = self.s.dvars["pointer"]
-        computed_result = pointer.deref.mem.concrete
-        expected_result = 0
-        self.assertEqual(
-            computed_result, expected_result, 'global variable "pointer" dereferences value is computed wrong'
-        )
-
-    def test_resolve_pointer2(self):
-        pointer2 = self.s.dvars["pointer2"]
-        computed_result = pointer2.deref.mem.concrete
-        expected_result = 1
-        self.assertEqual(
-            computed_result, expected_result, 'global variable "pointer2" dereferences value is computed wrong'
-        )
-
-    def test_resolve_global_var(self):
-        global_var = self.s.dvars["global_var"]
-        computed_result = global_var.mem.concrete
-        expected_result = 7
-        self.assertEqual(computed_result, expected_result, 'global variable "global_var" value is computed wrong')
-
-    def test_resolve_extern_var(self):
-        extern_var = self.s.dvars["extern_var"]
-        computed_result = extern_var.mem.concrete
-        expected_result = 42
-        self.assertEqual(computed_result, expected_result, 'global variable "extern_var" value is computed wrong')
-
-    def test_resolve_global_struct(self):
-        global_struct = self.s.dvars["global_struct"]
-
-        computed_struct_array = []
-        a = global_struct.member("struct_array")
-        for i in range(3):
-            computed_struct_array.append(a.array(i).mem.concrete)
-
-        computed_result = [
-            global_struct.member("struct_fun").mem.concrete,
-            global_struct.member("struct_int").mem.concrete,
-            global_struct.member("struct_ll").mem.concrete,
-            global_struct.member("struct_char").mem.concrete,
-            global_struct.member("struct_strref").string.concrete,
-            global_struct.member("struct_pointer").mem.concrete,
-            computed_struct_array,
-            # struct_float is tested below,
-            # struct_double is tested below,
-            global_struct.member("struct_my_type").mem.concrete,
-        ]
-
-        expected_result = [
-            self.p.loader.find_symbol("variable_scopes").rebased_addr,
-            42,
-            256,
-            b"a",
-            b"hello",
-            self.s.dvars["dummy"].addr,
-            [9, 8, 7],
-            # 1.141,
-            # 1.141,
-            16,
-        ]
-
-        self.assertEqual(
-            computed_result, expected_result, 'global variable "global_struct" members value is computed wrong'
-        )
-
-        struct_float = global_struct.member("struct_float").mem.concrete
-        struct_double = global_struct.member("struct_double").mem.concrete
-        self.assertTrue(
-            math.isclose(struct_float, 1.141, rel_tol=1e-7) and math.isclose(struct_double, 1.141, rel_tol=1e-7)
-        )
-
-    # tests for local variables
-
-    def test_sum_in_global(self):
-        simgr = self.p.factory.simgr()
-        addr = self.p.loader.find_symbol("sum_in_global").rebased_addr
-        simgr.explore(find=addr)
-        simgr.move(from_stash="found", to_stash="active")
-        simgr.step()
-        simgr.step()
-        s = simgr.active[0]
-        result = []
-        for _ in range(9):
-            result.append(s.dvars["global_var"].mem.concrete)
-            simgr.step()
-            s = simgr.active[0]
-        ref = [7, 8, 10, 13, 17, 22, 28, 35, 43]
-        self.assertEqual(result, ref)
-
-    def test_sum_in_local(self):
-        simgr = self.p.factory.simgr()
-        addr = self.p.loader.find_symbol("sum_in_local").rebased_addr
-        simgr.explore(find=addr)
-        simgr.move(from_stash="found", to_stash="active")
-        simgr.step()
-        s = simgr.active[0]
-        local_var = s.dvars["local_var"].mem.concrete
-        ref = 0
-        self.assertEqual(local_var, ref)
-
-    def test_variable_scopes(self):
-        simgr = self.p.factory.simgr()
-        filename = "/home/lukas/Software/angr-dev/binaries/tests_src/various_variables.c"
-        lines_strings = [
-            (78, b"He"),
-            (80, b"llo "),
-            # (84, b"Wor"),  # FIXME fails
-            (88, b"ld!\n"),
-        ]
-        for line, expected_string in lines_strings:
-            addr = {addr for addr in self.addr2line if (filename, line) in self.addr2line[addr]}.pop()
-            simgr.explore(find=addr)
-            s = simgr.found[0]
-            computed_string = s.dvars["string"].string.concrete
-            self.assertEqual(expected_string, computed_string)
-            simgr.move(from_stash="found", to_stash="active")
-
-    def test_sum_in_static(self):
-        simgr = self.p.factory.simgr()
-        filename = "/home/lukas/Software/angr-dev/binaries/tests_src/various_variables.c"
-        line = 47
-        addr = {addr for addr in self.addr2line if (filename, line) in self.addr2line[addr]}.pop()
-        simgr.explore(find=addr)
-        s = simgr.found[0]
-        computed_value = s.dvars["static_var"].mem.concrete
-        self.assertEqual(computed_value, 0)
-
-    def test_local_in_loop(self):
-        simgr = self.p.factory.simgr()
-        filename = "/home/lukas/Software/angr-dev/binaries/tests_src/various_variables.c"
-        line = 55
-        addr = {addr for addr in self.addr2line if (filename, line) in self.addr2line[addr]}.pop()
-        simgr.explore(find=addr)
-        s = simgr.found[0]
-        computed_value = s.dvars["local_in_loop"].mem.concrete
-        self.assertEqual(computed_value, 9)
-
-    def test_local_in_if(self):
-        simgr = self.p.factory.simgr()
-        filename = "/home/lukas/Software/angr-dev/binaries/tests_src/various_variables.c"
-        line = 68
-        addr = {addr for addr in self.addr2line if (filename, line) in self.addr2line[addr]}.pop()
-        simgr.explore(find=addr)
-        s = simgr.found[0]
-        computed_value = s.dvars["local_in_if"].mem.concrete
-        self.assertEqual(computed_value, 52)
-
-    def test_resolve_local_struct(self):
-        simgr = self.p.factory.simgr()
-        filename = "/home/lukas/Software/angr-dev/binaries/tests_src/various_variables.c"
-        line = 144
-        addr = {addr for addr in self.addr2line if (filename, line) in self.addr2line[addr]}.pop()
-        simgr.explore(find=addr)
-        s = simgr.found[0]
-        local_struct = s.dvars["local_struct"]
-
-        computed_struct_array = []
-        a = local_struct.member("struct_array")
-        for i in range(3):
-            computed_struct_array.append(a.array(i).mem.concrete)
-
-        computed_result = [
-            local_struct.member("struct_fun").mem.concrete,
-            local_struct.member("struct_int").mem.concrete,
-            local_struct.member("struct_ll").mem.concrete,
-            local_struct.member("struct_char").mem.concrete,
-            local_struct.member("struct_strref").string.concrete,
-            local_struct.member("struct_pointer").mem.concrete,
-            computed_struct_array,
-            # struct_float is tested below,
-            # struct_double is tested below,
-            local_struct.member("struct_my_type").mem.concrete,
-        ]
-
-        expected_result = [
-            self.p.loader.find_symbol("variable_scopes").rebased_addr,
-            42,
-            256,
-            b"a",
-            b"hello",
-            s.dvars["local_pointer"].mem.concrete,
-            [9, 8, 7],
-            # 1.141,
-            # 1.141,
-            16,
-        ]
-
-        self.assertEqual(
-            computed_result, expected_result, 'local variable "local_struct" members value is computed wrong'
-        )
-
-        struct_float = local_struct.member("struct_float").mem.concrete
-        struct_double = local_struct.member("struct_double").mem.concrete
-        self.assertTrue(
-            math.isclose(struct_float, 1.141, rel_tol=1e-7) and math.isclose(struct_double, 1.141, rel_tol=1e-7)
-        )
-
-
-if __name__ == "__main__":
-    main()

tests/knowledge_plugins/test_kb_plugins.py

@@ -1,91 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.knowledge_plugins"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import networkx
-
-import angr
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestKbPlugins(unittest.TestCase):
-    def test_kb_plugins(self):
-        p = angr.Project(os.path.join(test_location, "x86_64", "fauxware"), auto_load_libs=False)
-
-        assert isinstance(p.kb.data, angr.knowledge_plugins.Data)
-        assert isinstance(p.kb.functions, angr.knowledge_plugins.FunctionManager)
-        assert isinstance(p.kb.variables, angr.knowledge_plugins.VariableManager)
-        assert isinstance(p.kb.labels, angr.knowledge_plugins.Labels)
-        assert isinstance(p.kb.comments, angr.knowledge_plugins.Comments)
-
-        assert isinstance(p.kb.callgraph, networkx.Graph)
-        assert isinstance(p.kb.resolved_indirect_jumps, dict)
-        assert isinstance(p.kb.unresolved_indirect_jumps, set)
-
-        assert dir(p.kb) is not None
-        for plugin in [
-            "data",
-            "functions",
-            "variables",
-            "labels",
-            "comments",
-            "callgraph",
-            "resolved_indirect_jumps",
-            "unresolved_indirect_jumps",
-        ]:
-            assert plugin in dir(p.kb)
-
-    def test_kb_plugins_typed(self):
-        p = angr.Project(os.path.join(test_location, "x86_64", "fauxware"), auto_load_libs=False)
-
-        for plugin in [
-            angr.knowledge_plugins.Data,
-            angr.knowledge_plugins.FunctionManager,
-            angr.knowledge_plugins.VariableManager,
-            angr.knowledge_plugins.Labels,
-            angr.knowledge_plugins.Comments,
-        ]:
-            assert p.kb.get_knowledge(plugin) is None
-
-        for plugin in [
-            angr.knowledge_plugins.Data,
-            angr.knowledge_plugins.FunctionManager,
-            angr.knowledge_plugins.VariableManager,
-            angr.knowledge_plugins.Labels,
-            angr.knowledge_plugins.Comments,
-        ]:
-            assert isinstance(p.kb.request_knowledge(plugin), plugin)
-
-        # The default plugins should have been instantiated by `request_knowledge`, and should now be available
-        for plugin in [
-            angr.knowledge_plugins.Data,
-            angr.knowledge_plugins.FunctionManager,
-            angr.knowledge_plugins.VariableManager,
-            angr.knowledge_plugins.Labels,
-            angr.knowledge_plugins.Comments,
-        ]:
-            assert isinstance(p.kb.request_knowledge(plugin), plugin)
-
-        # Check that explicitly creating and registering new kind of plugin also works
-        class TestPlugin(angr.knowledge_plugins.KnowledgeBasePlugin):
-            def __init__(self, kb=None):
-                self._kb = kb
-
-        # Assert that unknown plugins return None when using "get_knowledge"
-        assert p.kb.get_knowledge(TestPlugin) is None
-
-        t = TestPlugin(p.kb)
-        p.kb.register_plugin("test_plugin", t)
-
-        assert p.kb.get_knowledge(TestPlugin) == t
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/knowledge_plugins/test_kb_plugins_dwarf.py

@@ -1,36 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.knowledge_plugins"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ..common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestKbPluginsDwarf(unittest.TestCase):
-    def test_kb_plugins_dwarf(self):
-        p = angr.Project(
-            os.path.join(test_location, "x86_64", "state_merge_0"),
-            load_options={
-                "load_debug_info": True,
-                "auto_load_libs": False,
-            },
-        )
-        assert isinstance(p.kb.variables, angr.knowledge_plugins.VariableManager)
-        p.kb.variables.load_from_dwarf()
-
-        ret = p.kb.variables.global_manager.get_global_variables(6295620)
-        assert len(ret) == 1
-
-        v = ret.pop()
-        assert v.name == "buf"
-
-
-if __name__ == "__main__":
-    unittest.main()