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

tests/sim/exec_func/test_mem_funcs.py

@@ -1,55 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.sim.exec_func"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ...common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestMemFuncs(unittest.TestCase):
-    def test_memmove(self):
-        # auto_load_libs can't be disabled as the testcase fails
-        proj = angr.Project(
-            os.path.join(test_location, "x86_64", "memmove"),
-            load_options={"auto_load_libs": True},
-            exclude_sim_procedures_list=["memmove"],
-        )
-        explorer = proj.factory.simulation_manager().explore(find=[0x4005D7])
-        s = explorer.found[0]
-        result = s.solver.eval(s.memory.load(s.registers.load(16, 8), 13), cast_to=bytes)
-        assert result == b"very useful.\x00"
-
-    def test_memcpy(self):
-        # auto_load_libs can't be disabled as the testcase fails
-        proj = angr.Project(
-            os.path.join(test_location, "x86_64", "memcpy"),
-            load_options={"auto_load_libs": True},
-            exclude_sim_procedures_list=["memcpy"],
-        )
-        explorer = proj.factory.simulation_manager().explore(find=[0x40065A])
-        s = explorer.found[0]
-        result = s.solver.eval(s.memory.load(s.registers.load(16, 8), 19), cast_to=bytes)
-        assert result == b"let's test memcpy!\x00"
-
-    def test_memset(self):
-        # auto_load_libs can't be disabled as the testcase fails
-        proj = angr.Project(
-            os.path.join(test_location, "x86_64", "memset"),
-            load_options={"auto_load_libs": True},
-            exclude_sim_procedures_list=["memset"],
-        )
-        explorer = proj.factory.simulation_manager().explore(find=[0x400608])
-        s = explorer.found[0]
-        result = s.solver.eval(s.memory.load(s.registers.load(16, 8), 50), cast_to=bytes)
-        assert result == b"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\x00"
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/sim/exec_func/test_str_funcs.py

@@ -1,93 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.sim.exec_func"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ...common import bin_location
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestStrFuncs(unittest.TestCase):
-    def test_strncpy(self):
-        # auto_load_libs can't be disabled as the test cases failed.
-        strncpy_amd64 = angr.Project(
-            os.path.join(test_location, "x86_64", "strncpy"),
-            load_options={"auto_load_libs": True},
-            exclude_sim_procedures_list=["strncpy"],
-        )
-        explorer = strncpy_amd64.factory.simulation_manager()
-        explorer.explore(find=[0x4005FF])
-        s = explorer.found[0]
-        result = s.solver.eval(s.memory.load(s.regs.rax, 16), cast_to=bytes)
-        assert result == b"why hello there\0"
-
-    def test_strncpy_size(self):
-        # auto_load_libs can't be disabled as the test cases failed.
-        strncpy_size_amd64 = angr.Project(
-            os.path.join(test_location, "x86_64", "strncpy-size"),
-            load_options={"auto_load_libs": True},
-            exclude_sim_procedures_list=["strncpy"],
-        )
-        explorer = strncpy_size_amd64.factory.simulation_manager()
-        cfg = strncpy_size_amd64.analyses.CFG(objects=[strncpy_size_amd64.loader.main_object], normalize=True)
-        explorer.use_technique(angr.exploration_techniques.LoopSeer(cfg=cfg, bound=50))
-        explorer.explore(find=[0x40064C])
-        s = explorer.found[0]
-        result = s.solver.eval(s.memory.load(s.regs.rax, 40), cast_to=bytes)
-        assert result == b"just testing things\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
-
-    def test_strncpy_verify_null(self):
-        # auto_load_libs can't be disabled as the test cases failed.
-        strncpy_verify_null_amd64 = angr.Project(
-            os.path.join(test_location, "x86_64", "strncpy-verify-null"),
-            load_options={"auto_load_libs": True},
-            exclude_sim_procedures_list=["strncpy"],
-        )
-        explorer = strncpy_verify_null_amd64.factory.simulation_manager()
-        cfg = strncpy_verify_null_amd64.analyses.CFG(
-            objects=[strncpy_verify_null_amd64.loader.main_object], normalize=True
-        )
-        explorer.use_technique(angr.exploration_techniques.LoopSeer(cfg=cfg, bound=50))
-        explorer.explore(find=[0x40064C])
-        s = explorer.found[0]
-        result = s.solver.eval(s.memory.load(s.regs.rax, 40), cast_to=bytes)
-        assert result == b"just testing things\0\0\0\0\0\0\0\0\0\0\0\0\0\0AAAAAA\0"
-
-    def test_strstr_and_strncpy(self):
-        # auto_load_libs can't be disabled as the test cases failed.
-        strstr_and_strncpy_amd64 = angr.Project(
-            os.path.join(test_location, "x86_64", "strstr_and_strncpy"),
-            load_options={"auto_load_libs": True},
-            exclude_sim_procedures_list=["strstr"],
-        )
-        explorer = strstr_and_strncpy_amd64.factory.simulation_manager()
-        cfg = strstr_and_strncpy_amd64.analyses.CFG(
-            objects=[strstr_and_strncpy_amd64.loader.main_object], normalize=True
-        )
-        explorer.use_technique(angr.exploration_techniques.LoopSeer(cfg=cfg, bound=50))
-        explorer.explore(find=[0x400657])
-        s = explorer.found[0]
-        result = s.solver.eval(s.memory.load(s.regs.rax, 15), cast_to=bytes)
-        assert result == b"hi th hi there\0"
-
-    def test_strstr(self):
-        # auto_load_libs can't be disabled as the test cases failed.
-        strstr_amd64 = angr.Project(
-            os.path.join(test_location, "x86_64", "strstr"),
-            load_options={"auto_load_libs": True},
-            exclude_sim_procedures_list=["strstr"],
-        )
-        explorer = strstr_amd64.factory.simulation_manager()
-        explorer.explore(find=[0x4005FB])
-        s = explorer.found[0]
-        result = s.solver.eval(s.memory.load(s.regs.rax, 9), cast_to=bytes)
-        assert result == b"hi there\0"
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/sim/exec_func/test_syscall_result.py

@@ -1,39 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.sim.exec_func"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ...common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-arches = {"mips", "mipsel", "mips64", "x86_64", "ppc", "ppc64"}
-
-
-class TestSyscallResult(unittest.TestCase):
-    @staticmethod
-    def run_test_syscalls(arch):
-        p = angr.Project(os.path.join(test_location, arch, "test_ioctl"), exclude_sim_procedures_list=["ioctl"])
-        p.simos.syscall_library.procedures.pop("ioctl", None)
-
-        s = p.factory.entry_state()
-
-        simgr = p.factory.simulation_manager(thing=s)
-        simgr.run()
-        assert (
-            len(simgr.deadended) == 2
-        ), "for these architectures, libc checks if the bit is set. make sure it branches"
-
-    def test_syscalls(self):
-        for arch in arches:
-            with self.subTest(arch=arch):
-                self.run_test_syscalls(arch)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/sim/exec_insn/test_adc.py

@@ -1,44 +0,0 @@
-#!/usr/bin/env python3
-__package__ = __package__ or "tests.sim.exec_insn"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ...common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-# pylint: disable=missing-class-docstring
-# pylint: disable=no-self-use
-class TestAdc(unittest.TestCase):
-    def test_adc_i386(self):
-        proj = angr.Project(os.path.join(test_location, "i386", "test_adc"), load_options={"auto_load_libs": False})
-
-        start = 0x804840B
-        end = 0x804842E
-
-        state = proj.factory.blank_state(
-            addr=start,
-            remove_options={
-                angr.options.LAZY_SOLVES,
-            },
-            add_options={angr.options.SYMBOLIC_WRITE_ADDRESSES},
-        )
-
-        pg = proj.factory.simulation_manager(state, veritesting=False)
-        pg.explore(find=end)
-
-        found_state = pg.found[0]
-        result = found_state.solver.eval(found_state.regs.eax)
-        assert result == 0x1
-
-    def test_all(self):
-        self.test_adc_i386()
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/sim/exec_insn/test_ops.py

@@ -1,83 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-
-import unittest
-
-import claripy
-
-import angr
-
-# all the input values were generated via
-# [random.randrange(256) for _ in range(16)]
-# then set into the input registers via gdb
-# set $xmm0.v16_int8 = {...}
-# then read out as uint128s
-# p/x $xmm0.uint128
-# then single stepped and the result read out
-
-
-class TestOps(unittest.TestCase):
-    def test_irop_perm(self):
-        p = angr.load_shellcode("vpshufb xmm0,xmm1,xmm2", "amd64")
-
-        # concrete test
-        s1 = p.factory.blank_state()
-        s1.regs.xmm1 = 0x3C899A56814EE9B84C7B5D8394C85881
-        s1.regs.xmm2 = 0xA55C66A2CDEF1CBCD72B42078D1B7F8B
-        s2 = s1.step(num_inst=1).successors[0]
-        assert (s2.regs.xmm0 == 0x00567B00000056000081C84C00813C00).is_true()
-
-        # symbolic test
-        s3 = p.factory.blank_state()
-        s3.regs.xmm1 = claripy.BVS("xmm1", 128)
-        s3.regs.xmm2 = claripy.BVS("xmm2", 128)
-        s4 = s3.step(num_inst=1).successors[0]
-        s4.solver.add(s4.regs.xmm2 == 0xA55C66A2CDEF1CBCD72B42078D1B7F8B)
-        s4.solver.add(s4.regs.xmm0 == 0x00567B00000056000081C84C00813C00)
-        assert s4.solver.solution(s4.regs.xmm1, 0x3C899A56814EE9B84C7B5D8394C85881)
-
-    def test_irop_mulhi(self):
-        p = angr.load_shellcode("vpmulhw xmm0,xmm1,xmm2", "amd64")
-
-        # concrete test
-        s1 = p.factory.blank_state()
-        s1.regs.xmm1 = 0x3ACA92553C2526D4F20987AEAB250255
-        s1.regs.xmm2 = 0x1AEBCB281463274EC3CE6473619A8541
-        s2 = s1.step(num_inst=1).successors[0]
-        assert (s2.regs.xmm0 == 0x62E16A304CA05F60348D0C9DFA5FEE1).is_true()
-
-    def test_irop_catevenlanes(self):
-        p = angr.load_shellcode("pmulhrsw xmm0, xmm1", "amd64")
-
-        # concrete test
-        s1 = p.factory.blank_state()
-        s1.regs.xmm0 = 0x4713E06BF3235E97CA8CFDE0647D65FD
-        s1.regs.xmm1 = 0x31F1F86DA1DCE7DE252ADC78160E1016
-        s2 = s1.step(num_inst=1).successors[0]
-        assert (s2.regs.xmm0 == 0x1BBB01DE0976EE2BF07B009711500CD1).is_true()
-
-    def test_saturating_packing(self):
-        # SaturateSignedWordToUnsignedByte
-        p = angr.load_shellcode("vpackuswb xmm1, xmm0, xmm0", arch="amd64")
-        s = p.factory.blank_state()
-        s.regs.xmm0 = 0x0000_0001_7FFE_7FFF_8000_8001_FFFE_FFFF
-        s = s.step(num_inst=1).successors[0]
-        assert (s.regs.xmm1 == 0x00_01_FF_FF_00_00_00_00_0001FFFF00000000).is_true()
-
-        # "Pack with unsigned saturation"
-        p = angr.load_shellcode("vpackusdw xmm1, xmm0, xmm0", arch="amd64")
-        s = p.factory.blank_state()
-        s.regs.xmm0 = 0x00000001_7FFFFFFE_80000001_FFFFFFFE
-        s = s.step(num_inst=1).successors[0]
-        assert (s.regs.xmm1 == 0x0001_FFFF_0000_0000_0001FFFF00000000).is_true()
-
-        # SaturateSignedWordToSignedByte
-        p = angr.load_shellcode("vpacksswb xmm1, xmm0, xmm0", arch="amd64")
-        s = p.factory.blank_state()
-        s.regs.xmm0 = 0x0000_0001_7FFE_7FFF_8000_8001_FFFE_FFFF
-        s = s.step(num_inst=1).successors[0]
-        assert (s.regs.xmm1 == 0x00_01_7F_7F_80_80_FE_FF_00017F7F8080FEFF).is_true()
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/sim/exec_insn/test_rcr.py

@@ -1,26 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.sim.exec_insn"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import claripy
-
-import angr
-
-from ...common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestRcr(unittest.TestCase):
-    def test_rcr(self):
-        p = angr.Project(os.path.join(test_location, "i386", "rcr_test"), auto_load_libs=False)
-        result = p.factory.successors(p.factory.entry_state()).successors[0]
-        assert claripy.is_true(result.regs.cl == 8)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/sim/exec_insn/test_rol.py

@@ -1,51 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.sim.exec_insn"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ...common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestRol(unittest.TestCase):
-    def test_rol_x86_64(self):
-        binary_path = os.path.join(test_location, "x86_64", "test_rol.exe")
-
-        proj = angr.Project(binary_path, auto_load_libs=False)
-
-        initial_state = proj.factory.blank_state(addr=0x401000)
-        r_rax = initial_state.solver.BVS("rax", 64)
-        initial_state.regs.rax = r_rax
-
-        pg = proj.factory.simulation_manager(initial_state)
-        pg.explore(find=0x401013, avoid=0x401010)
-        found_state = pg.found[0]
-
-        result = found_state.solver.eval(r_rax)
-        assert result == 0x37B7AB70
-
-    def test_rol_i386(self):
-        binary_path = os.path.join(test_location, "i386", "test_rol.exe")
-
-        proj = angr.Project(binary_path, auto_load_libs=False)
-
-        initial_state = proj.factory.blank_state(addr=0x401000)
-        r_eax = initial_state.solver.BVS("eax", 32)
-        initial_state.regs.eax = r_eax
-
-        pg = proj.factory.simulation_manager(initial_state)
-        pg.explore(find=0x401013, avoid=0x401010)
-        found_state = pg.found[0]
-
-        result = found_state.solver.eval(r_eax)
-        assert result == 0x37B7AB70
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/sim/exec_insn/test_signed_div.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-__package__ = __package__ or "tests.sim.exec_insn"  # pylint:disable=redefined-builtin
-
-import os
-import subprocess
-import sys
-from unittest import main, skipUnless, TestCase
-
-import angr
-
-from ...common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-class TestSignedDiv(TestCase):
-    @skipUnless(sys.platform.startswith("linux"), "linux only")
-    def test_signed_div(self):
-        test_bin = os.path.join(test_location, "x86_64", "test_signed_div")
-        b = angr.Project(test_bin, auto_load_libs=False)
-
-        pg = b.factory.simulation_manager()
-        pg.explore()
-        out_angr = pg.deadended[0].posix.dumps(1)
-        with subprocess.Popen(test_bin, stdout=subprocess.PIPE) as proc:
-            stdout_real, _ = proc.communicate()
-
-        assert out_angr == stdout_real
-
-
-if __name__ == "__main__":
-    main()

tests/sim/exec_insn/test_sqrt.py

@@ -1,56 +0,0 @@
-#!/usr/bin/env python3
-# pylint:disable=missing-class-docstring,no-self-use
-import math
-from unittest import TestCase, main
-
-import claripy
-import angr
-
-
-class TestSqrt(TestCase):
-    def test_sqrt_symbolic(self):
-        ins_bytes = b"\xf3\x0f\x51\xc9"  # sqrtss  xmm1, xmm1
-        proj = angr.load_shellcode(ins_bytes, "amd64", load_address=0)
-        state = proj.factory.blank_state(addr=0)
-
-        xmm1 = claripy.FPS("v", claripy.FSORT_FLOAT)
-        state.regs.xmm1 = xmm1.to_bv()
-        simgr = proj.factory.simgr(state)
-
-        simgr.step(num_inst=1)
-        assert len(simgr.active) == 1
-
-        final = simgr.active[0]
-        result = final.regs.xmm1[31:0].raw_to_fp()
-
-        a = int(final.solver.eval(xmm1, extra_constraints=(result == 2.0,)))
-        assert a == 4
-        b = int(final.solver.eval(xmm1, extra_constraints=(result == 4.0,)))
-        assert b == 16
-
-    def test_sqrt_concrete(self):
-        ins_bytes = b"\xf3\x0f\x51\xc9"  # sqrtss  xmm1, xmm1
-        proj = angr.load_shellcode(ins_bytes, "amd64", load_address=0)
-        state = proj.factory.blank_state(addr=0)
-
-        xmm1 = claripy.FPV(200000, claripy.FSORT_FLOAT)
-        state.regs.xmm1 = xmm1.to_bv()
-        simgr = proj.factory.simgr(state)
-
-        simgr.step(num_inst=1)
-        assert len(simgr.active) == 1
-
-        final = simgr.active[0]
-        result = final.regs.xmm1[31:0].raw_to_fp()
-
-        a = final.solver.eval(result)
-        assert abs(a - math.sqrt(200000)) < 0.001
-
-    def test_sqrt_concrete_eager_evaluation(self):
-        a = claripy.FPV(2.0, claripy.FSORT_DOUBLE)
-        b = claripy.fpSqrt(a)
-        assert abs(b.concrete_value - 1.414) < 0.001
-
-
-if __name__ == "__main__":
-    main()

tests/sim/options/test_0div.py

@@ -1,54 +0,0 @@
-#!/usr/bin/env python3
-__package__ = __package__ or "tests.sim.options"  # pylint:disable=redefined-builtin
-
-import os
-import sys
-import unittest
-
-import angr
-
-from ...common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-# pylint: disable=missing-class-docstring
-# pylint: disable=no-self-use
-@unittest.skipIf(sys.platform == "win32", "broken on windows")
-class Test0Div(unittest.TestCase):
-    def _run_0div(self, arch):
-        # check that we run in unicorn up to the zero-div site, fall back, try again in angr, and error correctly.
-        p = angr.Project(os.path.join(test_location, arch, "test_0div"), auto_load_libs=False)
-        s = p.factory.entry_state(add_options=angr.options.unicorn)
-        simgr = p.factory.simulation_manager(s)
-        simgr.run(n=5)
-        assert len(simgr.active) == 1
-        simgr.step()
-        assert len(simgr.errored) == 1
-        assert isinstance(simgr.errored[0].error, angr.errors.SimZeroDivisionException)
-
-    def test_0div_i386(self):
-        self._run_0div("i386")
-
-    def test_0div_x86_64(self):
-        self._run_0div("x86_64")
-
-    def test_symbolic_0div(self):
-        p = angr.load_shellcode(b"X", arch="amd64")
-        s = p.factory.blank_state()
-        s.regs.rax = s.solver.BVS("rax", 64)
-        s.regs.rcx = s.solver.BVS("rcx", 64)
-        s.regs.rdx = s.solver.BVS("rdx", 64)
-
-        s.options.add(angr.options.PRODUCE_ZERODIV_SUCCESSORS)
-        successors = s.step(insn_bytes=b"\x48\xf7\xf1")  # div rcx
-        assert len(successors.flat_successors) == 2
-
-        s.options.discard(angr.options.PRODUCE_ZERODIV_SUCCESSORS)
-        successors = s.step(insn_bytes=b"\x48\xf7\xf1")  # div rcx
-        assert len(successors.flat_successors) == 1
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/sim/options/test_symbolic_fd.py

@@ -1,59 +0,0 @@
-#!/usr/bin/env python3
-# pylint:disable=missing-class-docstring,no-self-use
-__package__ = __package__ or "tests.sim.options"  # pylint:disable=redefined-builtin
-
-import os
-import unittest
-
-import angr
-
-from ...common import bin_location
-
-
-test_location = os.path.join(bin_location, "tests")
-
-
-def find(s):
-    return s.posix.dumps(1) == b"c0de\n"
-
-
-def avoid(s):
-    return s.posix.dumps(1) == b"nothing\n"
-
-
-class TestSymbolicFd(unittest.TestCase):
-    def test_symbolic_fd(self):
-        project = angr.Project(os.path.join(test_location, "x86_64", "symbolic_fd"))
-
-        for method_name in ("stat_test", "fstat_test", "open_test", "fopen_test", "fdopen_test"):
-            addr = project.loader.find_symbol(method_name).rebased_addr
-
-            # all files exist
-            state = project.factory.blank_state(addr=addr)
-            state.options["ALL_FILES_EXIST"] = True
-            simgr = project.factory.simgr(state)
-            while simgr.active != []:
-                simgr.explore(find=find, avoid=avoid)
-            assert simgr.avoid != [] and simgr.found == [], f"{method_name}: got {simgr.avoid} and {simgr.found}"
-
-            # any file might exist
-            state = project.factory.blank_state(addr=addr)
-            state.options["ALL_FILES_EXIST"] = False
-            state.options["ANY_FILE_MIGHT_EXIST"] = True
-            simgr = project.factory.simgr(state)
-            while simgr.active != []:
-                simgr.explore(find=find, avoid=avoid)
-            assert simgr.avoid != [] and simgr.found != [], f"{method_name}: got {simgr.avoid} and {simgr.found}"
-
-            # no file exists
-            state = project.factory.blank_state(addr=addr)
-            state.options["ALL_FILES_EXIST"] = False
-            state.options["ANY_FILE_MIGHT_EXIST"] = False
-            simgr = project.factory.simgr(state)
-            while simgr.active != []:
-                simgr.explore(find=find, avoid=avoid)
-            assert simgr.avoid == [] and simgr.found != [], f"{method_name}: got {simgr.avoid} and {simgr.found}"
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/sim/options/test_unsupported.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=missing-class-docstring,no-self-use,line-too-long
-
-import unittest
-
-import angr
-
-
-class TestUnsupported(unittest.TestCase):
-    def test_unsupported_syscall_simos(self):
-        p = angr.load_shellcode("int 0x80", "x86")
-        state = p.factory.entry_state()
-        state.regs.eax = 4
-
-        # test that by default trying to perform a syscall without SimUserspace causes the state to go errored
-        simgr = p.factory.simulation_manager(state)
-        simgr.step()
-        assert len(simgr.active) == 1
-        simgr.step()
-        assert len(simgr.active) == 0
-        assert len(simgr.errored) == 1
-
-        # test that when we set BYPASS_UNSUPPORTED_SYSCALLS, we get a syscall stub instead
-        state.options.add(angr.options.BYPASS_UNSUPPORTED_SYSCALL)
-        simgr = p.factory.simulation_manager(state)
-        simgr.step()
-        assert len(simgr.active) == 1
-        simgr.step()
-        assert len(simgr.active) == 1
-        assert len(simgr.errored) == 0
-
-
-if __name__ == "__main__":
-    unittest.main()