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

tests/state_plugins/inspect/test_inspect.py

@@ -1,310 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,disable=no-self-use
-__package__ = __package__ or "tests.state_plugins.inspect"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import pyvex
-import claripy
-import archinfo
-
-import angr
-from angr import SimState, BP_AFTER, BP_BEFORE, SIM_PROCEDURES, concretization_strategies
-from angr.engines import ProcedureEngine, HeavyVEXMixin, SimInspectMixin
-
-from ...common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class InspectEngine(SimInspectMixin, HeavyVEXMixin):
-    pass
-
-
-class TestInspect(unittest.TestCase):
-    def test_inspect(self):
-        class counts:  # pylint:disable=no-init
-            mem_read = 0
-            mem_write = 0
-            reg_read = 0
-            reg_write = 0
-            tmp_read = 0
-            tmp_write = 0
-            expr = 0
-            statement = 0
-            instruction = 0
-            constraints = 0
-            variables = 0
-
-        def act_mem_read(state):  # pylint:disable=unused-argument
-            counts.mem_read += 1
-
-        def act_mem_write(state):  # pylint:disable=unused-argument
-            counts.mem_write += 1
-
-        def act_reg_read(state):  # pylint:disable=unused-argument
-            counts.reg_read += 1
-
-        def act_reg_write(state):  # pylint:disable=unused-argument
-            counts.reg_write += 1
-
-        def act_tmp_read(state):  # pylint:disable=unused-argument
-            counts.tmp_read += 1
-
-        def act_tmp_write(state):  # pylint:disable=unused-argument
-            counts.tmp_write += 1
-
-        def act_expr(state):  # pylint:disable=unused-argument
-            counts.expr += 1
-
-        def act_statement(state):  # pylint:disable=unused-argument
-            counts.statement += 1
-
-        def act_instruction(state):  # pylint:disable=unused-argument
-            counts.instruction += 1
-
-        def act_variables(state):  # pylint:disable=unused-argument
-            # print "CREATING:", state.inspect.symbolic_name
-            counts.variables += 1
-
-        #   def act_constraints(state): #pylint:disable=unused-argument
-        #       counts.constraints += 1
-
-        s = SimState(arch="AMD64", mode="symbolic")
-
-        s.inspect.b("mem_write", when=BP_AFTER, action=act_mem_write)
-        assert counts.mem_write == 0
-        s.memory.store(100, s.solver.BVV(10, 32))
-        assert counts.mem_write == 1
-
-        s.inspect.b("mem_read", when=BP_AFTER, action=act_mem_read)
-        s.inspect.b("mem_read", when=BP_AFTER, action=act_mem_read, mem_read_address=100)
-        s.inspect.b("mem_read", when=BP_AFTER, action=act_mem_read, mem_read_address=123)
-        s.inspect.b("mem_read", when=BP_BEFORE, action=act_mem_read, mem_read_length=3)
-        assert counts.mem_read == 0
-        s.memory.load(123, 4)
-        s.memory.load(223, 3)
-        assert counts.mem_read == 4
-
-        s.inspect.b("reg_read", when=BP_AFTER, action=act_reg_read)
-        assert counts.reg_read == 0
-        s.registers.load(16, size=8)
-        assert counts.reg_read == 1
-
-        s.inspect.b("reg_write", when=BP_AFTER, action=act_reg_write)
-        assert counts.reg_write == 0
-        s.registers.store(16, s.solver.BVV(10, 32))
-        assert counts.reg_write == 1
-        assert counts.mem_write == 1
-        assert counts.mem_read == 4
-        assert counts.reg_read == 1
-
-        s.inspect.b("tmp_read", when=BP_AFTER, action=act_tmp_read, tmp_read_num=0)
-        s.inspect.b("tmp_write", when=BP_AFTER, action=act_tmp_write, tmp_write_num=0)
-        s.inspect.b("expr", when=BP_AFTER, action=act_expr, expr_result=1016)
-        s.inspect.b("statement", when=BP_AFTER, action=act_statement)
-        s.inspect.b("instruction", when=BP_AFTER, action=act_instruction, instruction=1001)
-        s.inspect.b("instruction", when=BP_AFTER, action=act_instruction, instruction=1000)
-        irsb = pyvex.IRSB(b"\x90\x90\x90\x90\xeb\x0a", mem_addr=1000, arch=archinfo.ArchAMD64(), opt_level=0)
-        irsb.pp()
-        InspectEngine(None).process(s, irsb=irsb)
-        assert counts.reg_write == 7
-        assert counts.reg_read == 2
-        assert counts.tmp_write == 1
-        assert counts.tmp_read == 1
-        assert counts.expr == 3
-        assert counts.statement == 11
-        assert counts.instruction == 2
-        assert counts.constraints == 0
-        assert counts.mem_write == 1
-        assert counts.mem_read == 4
-
-        s = SimState(arch="AMD64", mode="symbolic")
-        s.inspect.b("symbolic_variable", when=BP_AFTER, action=act_variables)
-        s.memory.load(0, 10)
-        assert counts.variables == 1
-
-    def test_inspect_exit(self):
-        class counts:  # pylint:disable=no-init
-            exit_before = 0
-            exit_after = 0
-
-        def handle_exit_before(state):
-            counts.exit_before += 1
-            exit_target = state.inspect.exit_target
-            assert state.solver.eval(exit_target) == 0x3F8
-            # change exit target
-            state.inspect.exit_target = 0x41414141
-            assert state.inspect.exit_jumpkind == "Ijk_Boring"
-            assert state.inspect.exit_guard.is_true()
-
-        def handle_exit_after(state):  # pylint:disable=unused-argument
-            counts.exit_after += 1
-
-        s = SimState(arch="AMD64", mode="symbolic")
-        irsb = pyvex.IRSB(b"\x90\x90\x90\x90\xeb\x0a", mem_addr=1000, arch=archinfo.ArchAMD64())
-
-        # break on exit
-        s.inspect.b("exit", BP_BEFORE, action=handle_exit_before)
-        s.inspect.b("exit", BP_AFTER, action=handle_exit_after)
-
-        # step it
-        succ = HeavyVEXMixin(None).process(s, irsb=irsb).flat_successors
-
-        # check
-        assert succ[0].solver.eval(succ[0].ip) == 0x41414141
-        assert counts.exit_before == 1
-        assert counts.exit_after == 1
-
-    def test_inspect_syscall(self):
-        class counts:  # pylint:disable=no-init
-            exit_before = 0
-            exit_after = 0
-
-        def handle_syscall_before(state):
-            counts.exit_before += 1
-            syscall_name = state.inspect.syscall_name
-            assert syscall_name == "close"
-
-        def handle_syscall_after(state):
-            counts.exit_after += 1
-            syscall_name = state.inspect.syscall_name
-            assert syscall_name == "close"
-
-        s = SimState(arch="AMD64", mode="symbolic")
-        # set up to call so syscall close
-        s.regs.rax = 3
-        s.regs.rdi = 2
-
-        # break on syscall
-        s.inspect.b("syscall", BP_BEFORE, action=handle_syscall_before)
-        s.inspect.b("syscall", BP_AFTER, action=handle_syscall_after)
-
-        # step it
-        proc = SIM_PROCEDURES["posix"]["close"](is_syscall=True)
-        ProcedureEngine(None).process(s, procedure=proc, ret_to=s.ip)
-
-        # check counts
-        assert counts.exit_before == 1
-        assert counts.exit_after == 1
-
-    def test_inspect_concretization(self):
-        # some values for the test
-        x = claripy.BVS("x", 64)
-        y = claripy.BVS("y", 64)
-
-        #
-        # This tests concretization-time address redirection.
-        #
-
-        def change_symbolic_target(state):
-            if state.inspect.address_concretization_action == "store":
-                state.inspect.address_concretization_expr = claripy.BVV(0x1000, state.arch.bits)
-
-        s = SimState(arch="AMD64")
-        s.inspect.b("address_concretization", BP_BEFORE, action=change_symbolic_target)
-        s.memory.store(x, "A")
-        assert list(s.solver.eval_upto(x, 10)) == [0x1000]
-        assert list(s.solver.eval_upto(s.memory.load(0x1000, 1), 10)) == [0x41]
-
-        #
-        # This tests disabling constraint adding through siminspect -- the write still happens
-        #
-
-        def dont_add_constraints(state):
-            state.inspect.address_concretization_add_constraints = False
-
-        s = SimState(arch="AMD64")
-        s.inspect.b("address_concretization", BP_BEFORE, action=dont_add_constraints)
-        s.memory.store(x, "A")
-        assert len(s.solver.eval_upto(x, 10)) == 10
-
-        #
-        # This tests raising an exception if symbolic concretization fails (i.e., if the address
-        # is too unconstrained). The write aborts.
-        #
-
-        class UnconstrainedAbort(Exception):
-            def __init__(self, message, state):
-                Exception.__init__(self, message)
-                self.state = state
-
-        def abort_unconstrained(state):
-            print(state.inspect.address_concretization_strategy, state.inspect.address_concretization_result)
-            if (
-                isinstance(
-                    state.inspect.address_concretization_strategy,
-                    concretization_strategies.SimConcretizationStrategyRange,
-                )
-                and state.inspect.address_concretization_result is None
-            ):
-                raise UnconstrainedAbort("uh oh", state)
-
-        s = SimState(arch="AMD64")
-        s.memory.write_strategies.insert(0, concretization_strategies.SimConcretizationStrategyRange(128))
-        s.memory._write_address_range = 1
-        s.memory._write_address_range_approx = 1
-        s.add_constraints(y == 10)
-        s.inspect.b("address_concretization", BP_AFTER, action=abort_unconstrained)
-        s.memory.store(y, "A")
-        assert list(s.solver.eval_upto(s.memory.load(y, 1), 10)) == [0x41]
-
-        try:
-            s.memory.store(x, "A")
-            print("THIS SHOULD NOT BE REACHED")
-            assert False
-        except UnconstrainedAbort as e:
-            assert e.state.memory is s.memory
-
-    def test_inspect_engine_process(self):
-        p = angr.Project(os.path.join(test_location, "x86_64", "fauxware"), auto_load_libs=False)
-
-        def check_first_symbolic_fork(state):
-            succs = state.inspect.sim_successors.successors
-            succ_addr = [hex(s.addr) for s in succs]
-            assert len(succ_addr) == 2
-            assert "0x400692L" in succ_addr
-            assert "0x400699L" in succ_addr
-            print("Fork after:", hex(state.addr))
-            print("Successors:", succ_addr)
-
-        def check_second_symbolic_fork(state):
-            succs = state.inspect.sim_successors.successors
-            succ_addr = [hex(s.addr) for s in succs]
-            assert len(succ_addr) == 2
-            assert "0x4006dfL" in succ_addr
-            assert "0x4006e6L" in succ_addr
-            print("Fork after:", hex(state.addr))
-            print("Successors:", succ_addr)
-
-        def first_symbolic_fork(state):
-            return hex(state.addr) == "0x40068eL" and isinstance(state.inspect.sim_engine, HeavyVEXMixin)
-            # TODO: I think this latter check is meaningless with the eleventh hour refactor
-
-        def second_symbolic_fork(state):
-            return hex(state.addr) == "0x4006dbL" and isinstance(state.inspect.sim_engine, HeavyVEXMixin)
-
-        def check_state(state):
-            assert hex(state.inspect.sim_successors.addr) in ("0x40068eL", "0x4006dbL")
-
-        state = p.factory.entry_state(addr=p.loader.find_symbol("main").rebased_addr)
-        pg = p.factory.simulation_manager(state)
-        state.inspect.b("engine_process", when=BP_BEFORE, action=check_state, condition=first_symbolic_fork)
-        state.inspect.b(
-            "engine_process", when=BP_AFTER, action=check_first_symbolic_fork, condition=first_symbolic_fork
-        )
-        pg.run()
-
-        state = p.factory.entry_state(addr=p.loader.find_symbol("main").rebased_addr)
-        pg = p.factory.simulation_manager(state)
-        state.inspect.b("engine_process", when=BP_BEFORE, action=check_state, condition=second_symbolic_fork)
-        state.inspect.b(
-            "engine_process", when=BP_AFTER, action=check_second_symbolic_fork, condition=second_symbolic_fork
-        )
-        pg.run()
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/state_plugins/inspect/test_syscall_override.py

@@ -1,90 +0,0 @@
-#!/usr/bin/env python3
-__package__ = __package__ or "tests.state_plugins.inspect"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ...common import bin_location, broken
-
-
-test_location = os.path.join(bin_location, "tests")
-
-target_addrs = {"i386": [0x080485C9], "x86_64": [0x4006ED], "ppc": [0x1000060C], "armel": [0x85F0], "mips": [0x4009FC]}
-
-avoid_addrs = {
-    "i386": [0x080485DD, 0x08048564],
-    "x86_64": [0x4006AA, 0x4006FD],
-    "ppc": [0x10000644, 0x1000059C],
-    "armel": [0x86F8, 0x857C],
-    "mips": [0x400A10, 0x400774],
-}
-
-corrupt_addrs = {
-    "i386": [0x80486B6, b"bO\xcc", lambda s: s.memory.store(s.regs.esp, s.regs.eax)],
-    "x86_64": [0x400742, b"\xd4&\xb0[\x41", lambda s: s.registers.store("rdx", 8)],
-    "ppc": [0x100006B8, b"\x05\xad\xc2\xea", lambda s: s.registers.store("r5", 8)],
-    "armel": [0x8678, b"\xbdM\xec3", lambda s: s.registers.store("r2", 8)],
-    "mips": [0x400918, b"[\xf8\x96@"[::-1], lambda s: s.registers.store("a2", 8)],
-}
-
-
-class TestSyscallOverride(unittest.TestCase):
-    def _run_fauxware_override(self, arch):
-        # auto_load_libs can't be disabled as the test fails
-        p = angr.Project(os.path.join(test_location, arch, "fauxware"), use_sim_procedures=False)
-        s = p.factory.full_init_state()
-
-        def overwrite_str(state):
-            state.posix.get_fd(1).write_data(b"HAHA\0")
-
-        queued_syscall_returns = []
-        queued_syscall_returns.append(None)  # let the mmap run
-        queued_syscall_returns.append(overwrite_str)  # prompt for username
-        queued_syscall_returns.append(0)  # username read
-        queued_syscall_returns.append(0)  # newline read
-        # queued_syscall_returns.append(0) # prompt for password -- why isn't this called?
-        queued_syscall_returns.append(None)  # password input
-        queued_syscall_returns.append(0)  # password \n input
-
-        def syscall_hook(state):
-            if not state.inspect.simprocedure.is_syscall:
-                return
-            try:
-                f = queued_syscall_returns.pop(0)
-                if f is None:
-                    return
-                state.inspect.simprocedure_result = f(state) if callable(f) else f
-            except IndexError:
-                return
-
-        s.inspect.make_breakpoint("simprocedure", s.inspect.BP_BEFORE, action=syscall_hook)
-
-        results = p.factory.simulation_manager(thing=s).explore(find=target_addrs[arch], avoid=avoid_addrs[arch])
-        stdin = results.found[0].posix.dumps(0)
-        assert b"SOSNEAKY" == stdin
-        stdout = results.found[0].posix.dumps(1)
-        assert b"HAHA\0" == stdout
-
-    def test_fauxware_override_x86_64(self):
-        self._run_fauxware_override("x86_64")
-
-    def test_fauxware_override_i386(self):
-        self._run_fauxware_override("i386")
-
-    @broken
-    def test_fauxware_override_ppc(self):
-        self._run_fauxware_override("ppc")
-
-    @broken
-    def test_fauxware_override_armel(self):
-        self._run_fauxware_override("armel")
-
-    @broken
-    def test_fauxware_override_mips(self):
-        self._run_fauxware_override("mips")
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/state_plugins/posix/test_file_struct_funcs.py

@@ -1,56 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,disable=no-self-use
-__package__ = __package__ or "tests.state_plugins.posix"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ...common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestFileStructFuncs(unittest.TestCase):
-    def check_state_1(self, state):
-        # Need to dump file.txt by path because program closes it
-        return (
-            state.posix.dump_file_by_path("file.txt") == b"testing abcdef"
-            and state.posix.dumps(0)[:4] == b"xyz\n"
-            and state.posix.dumps(1) == b"good1\n"
-            and state.posix.dumps(2) == b""
-        )
-
-    def check_state_2(self, state):
-        return (
-            state.posix.dump_file_by_path("file.txt") == b"testing abcdef"
-            and state.posix.dumps(0)[:4] == b"wxyz"
-            and state.posix.dumps(1) == b""
-            and state.posix.dumps(2) == b"good2\n"
-        )
-
-    def check_state_3(self, state):
-        return (
-            state.posix.dump_file_by_path("file.txt") == b"testing abcdef"
-            and state.posix.dumps(1) == b""
-            and state.posix.dumps(2) == b""
-        )
-
-    def test_file_struct_funcs(self):
-        test_bin = os.path.join(test_location, "x86_64", "file_func_test")
-        b = angr.Project(test_bin, auto_load_libs=False)
-
-        pg = b.factory.simulation_manager()
-        pg.active[0].options.discard("LAZY_SOLVES")
-        pg.explore()
-
-        assert len(pg.deadended) == 3
-
-        for p in pg.deadended:
-            assert self.check_state_1(p) or self.check_state_2(p) or self.check_state_3(p)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/state_plugins/posix/test_files.py

@@ -1,69 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,disable=no-self-use
-__package__ = __package__ or "tests.state_plugins.posix"  # pylint:disable=redefined-builtin
-
-import os
-import sys
-import unittest
-
-import angr
-from angr.state_plugins.posix import Flags
-
-from ...common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestFile(unittest.TestCase):
-    def test_files(self):
-        s = angr.SimState(arch="AMD64")
-        s.posix.get_fd(1).write_data(b"HELLO")
-        s.posix.get_fd(1).write_data(b"WORLD")
-        assert s.posix.dumps(1) == b"HELLOWORLD"
-        assert s.posix.stdout.concretize() == [b"HELLO", b"WORLD"]
-
-        s = angr.SimState(arch="AMD64")
-        s.posix.get_fd(1).write_data(b"A" * 0x1000, 0x800)
-        assert s.posix.dumps(1) == b"A" * 0x800
-
-    def test_file_read_missing_content(self):
-        # test in tracing mode since the Reverse operator will not be optimized away
-        s = angr.SimState(arch="AMD64", mode="tracing")
-        fd = s.posix.open(b"/tmp/oops", Flags.O_RDWR)
-        length = s.posix.get_fd(fd).read(0xC00000, 100)
-
-        data = s.memory.load(0xC00000, length, endness="Iend_BE")
-        assert data.op != "Reverse", "Byte strings read directly out of a file should not have Reverse operators."
-        assert data.op == "BVS"
-        assert len(data.variables) == 1
-        assert "oops" in next(iter(data.variables))
-
-    @unittest.skipIf(sys.platform == "win32", "broken on windows")
-    def test_concrete_fs_resolution(self):
-        bin_path = os.path.join(test_location, "i386", "fauxware")
-        proj = angr.Project(bin_path, auto_load_libs=False)
-        state = proj.factory.entry_state(concrete_fs=True)
-        fd = state.posix.open(bin_path, Flags.O_RDONLY)
-        stat = state.posix.fstat(fd)
-        size = stat.st_size
-        int_size = state.solver.eval(size)
-
-        assert stat
-        assert int_size != 0
-        assert not state.solver.symbolic(size)
-
-    def test_sim_fs_resolution(self):
-        bin_path = os.path.join(test_location, "i386", "fauxware")
-        proj = angr.Project(bin_path, auto_load_libs=False)
-        state = proj.factory.entry_state()
-        fd = state.posix.open(bin_path, Flags.O_RDONLY)
-        stat = state.posix.fstat(fd)
-        size = stat.st_size
-
-        assert stat
-        assert state.solver.symbolic(size)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/state_plugins/posix/test_posix.py

@@ -1,72 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-
-import unittest
-
-from angr import SimState, SimFile
-
-
-class TestPosix(unittest.TestCase):
-    def test_file_create(self):
-        # Create a state first
-        state = SimState(arch="AMD64", mode="symbolic")
-
-        # Create a file
-        fd = state.posix.open(b"test", 1)
-
-        assert fd == 3
-
-    def test_file_read(self):
-        state = SimState(arch="AMD64", mode="symbolic")
-
-        content = state.solver.BVV(0xBADF00D, 32)
-        content_size = content.size() // 8
-
-        fd = state.posix.open(b"test", 1)
-        simfd = state.posix.get_fd(fd)
-        simfd.write_data(content)
-        simfd.seek(0)
-        simfd.read(0xC0000000, content_size)
-
-        data = state.memory.load(0xC0000000, content_size)
-
-        assert data is content
-
-    def test_file_seek(self):
-        # TODO: Make this test more complete
-
-        state = SimState(arch="AMD64", mode="symbolic")
-
-        # Normal seeking
-        fd = state.posix.open(b"test1", 1)
-        simfd = state.posix.get_fd(fd)
-        simfd.seek(0, "start")
-        assert state.solver.is_true(simfd.tell() == 0)
-        state.posix.close(fd)
-
-        # TODO: test case: seek cannot go beyond the file size or current file pos
-
-        # seek should not work for stdin/stdout/stderr
-        assert state.solver.is_false(state.posix.get_fd(0).seek(0))
-        assert state.solver.is_false(state.posix.get_fd(1).seek(0))
-        assert state.solver.is_false(state.posix.get_fd(2).seek(0))
-
-        # Seek from the end
-        state.fs.insert("test2", SimFile(name="qwer", size=20))
-        fd = state.posix.open(b"test2", 1)
-        simfd = state.posix.get_fd(fd)
-        simfd.seek(0, "end")
-        assert state.solver.is_true(simfd.tell() == 20)
-        state.posix.close(fd)
-
-        # seek to a symbolic position (whence symbolic end)
-        fd = state.posix.open(b"unknown_size", 1)
-        simfd = state.posix.get_fd(fd)
-        real_end = state.fs.get("unknown_size").size
-        simfd.seek(0, "end")
-        assert real_end is simfd.tell()
-        state.posix.close(fd)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/state_plugins/solver/test_simsolver.py

@@ -1,58 +0,0 @@
-#!/usr/bin/env python3
-# pylint:disable=no-self-use
-
-import struct
-import unittest
-
-import claripy
-
-import angr
-
-
-class TestSolverEvalCasting(unittest.TestCase):
-    """
-    Basic test cases of SimSolver::eval's `cast_to` function.
-    """
-
-    def test_eval_cast_bvv_to_bytes(self):
-        s = angr.SimState(arch="AMD64", mode="symbolic")
-        assert s.solver.eval(claripy.BVV(0, 0), cast_to=bytes) == b""
-        assert s.solver.eval(claripy.BVV(0, 8), cast_to=bytes) == b"\x00"
-        assert s.solver.eval(claripy.BVV(0x12345678, 32), cast_to=bytes) == b"\x12\x34\x56\x78"
-
-    def test_eval_cast_bvv_to_bytes__non_8bit_length_multiple(self):
-        s = angr.SimState(arch="AMD64", mode="symbolic")
-        for nbits in [1, 2, 7]:
-            with self.subTest(nbits=nbits):
-                with self.assertRaises(ValueError):
-                    s.solver.eval(claripy.BVV(0, nbits), cast_to=bytes)
-
-    def test_eval_cast_fpv_to_bytes(self):
-        s = angr.SimState(arch="AMD64", mode="symbolic")
-        value = 1.23456
-        fpv = claripy.FPV(value, claripy.FSORT_FLOAT)
-        assert s.solver.eval(fpv, cast_to=bytes) == struct.pack(">f", value)
-        fpv = claripy.FPV(value, claripy.FSORT_DOUBLE)
-        assert s.solver.eval(fpv, cast_to=bytes) == struct.pack(">d", value)
-
-    def test_eval_cast_fpv_to_int(self):
-        s = angr.SimState(arch="AMD64", mode="symbolic")
-        value = 1.23456
-        fpv = claripy.FPV(value, claripy.FSORT_FLOAT)
-        assert s.solver.eval(fpv, cast_to=int) == int.from_bytes(struct.pack(">f", value), "big")
-        fpv = claripy.FPV(value, claripy.FSORT_DOUBLE)
-        assert s.solver.eval(fpv, cast_to=int) == int.from_bytes(struct.pack(">d", value), "big")
-
-    def test_eval_cast_bool_to_bytes(self):
-        s = angr.SimState(arch="AMD64", mode="symbolic")
-        assert s.solver.eval(claripy.BoolV(False), cast_to=bytes) == b"\x00"
-        assert s.solver.eval(claripy.BoolV(True), cast_to=bytes) == b"\x01"
-
-    def test_eval_cast_bool_to_int(self):
-        s = angr.SimState(arch="AMD64", mode="symbolic")
-        assert s.solver.eval(claripy.BoolV(False), cast_to=int) == 0
-        assert s.solver.eval(claripy.BoolV(True), cast_to=int) == 1
-
-
-if __name__ == "__main__":
-    unittest.main()