crosshair-tool 0.0.99__cp312-cp312-macosx_10_13_x86_64.whl

crosshair/libimpl/fractionlib_test.py

@@ -0,0 +1,80 @@
+import math
+from fractions import Fraction
+
+from crosshair.core import deep_realize
+from crosshair.core_and_libs import proxy_for_type
+from crosshair.statespace import POST_FAIL
+from crosshair.test_util import check_states
+from crosshair.tracers import ResumedTracing, is_tracing
+from crosshair.util import CrossHairInternal
+
+
+def test_fraction_realize(space):
+    n = proxy_for_type(int, "n")
+    d = proxy_for_type(int, "d")
+    with ResumedTracing():
+        space.add(d != 0)
+        deep_realize(Fraction(n, d))
+
+
+class UserFraction(Fraction):
+    def __int__(self):
+        if not is_tracing():
+            raise CrossHairInternal("tracing required while in user code")
+        return 1
+
+    def __round__(self, *a, **kw):
+        if not is_tracing():
+            raise CrossHairInternal("tracing required while in user code")
+        return super().__round__(*a, **kw)
+
+
+def test_user_fraction_tracing(space):
+    n = proxy_for_type(int, "n")
+    d = proxy_for_type(int, "d")
+    with ResumedTracing():
+        space.add(d != 0)
+        fraction = UserFraction(n, d)
+        round(fraction)  # (works via with_realized_args)
+        int(fraction)  # (custom interception)
+
+
+def test_fraction_copy_doesnt_realize(space):
+    n = proxy_for_type(int, "n")
+    with ResumedTracing():
+        space.add(n >= 0)
+        f1 = Fraction(n, 1)
+        f2 = f1.__copy__()
+        assert space.is_possible(f2.numerator == 2)
+        assert space.is_possible(f2.numerator == 3)
+
+
+def test_fraction_can_be_one_half() -> None:
+    def f(f: Fraction):
+        """post:_"""
+        return f != Fraction(1, 2)
+
+    check_states(f, POST_FAIL)
+
+
+def test_int_from_fraction(space) -> None:
+    n = proxy_for_type(int, "n")
+    d = proxy_for_type(int, "d")
+    with ResumedTracing():
+        space.add(d > 0)
+        space.add(n == d * 3)
+        f = Fraction(n, d)
+        assert space.is_possible(d == 3)
+        assert not space.is_possible(f.denominator != 1)
+        truncated_fraction = int(f)
+        assert space.is_possible(truncated_fraction == 3)
+        assert not space.is_possible(truncated_fraction != 3)
+
+
+def test_fraction_ceil_does_not_explode(space) -> None:
+    f = proxy_for_type(Fraction, "f")
+    with ResumedTracing():
+        math.ceil(f)
+
+
+# TODO: The math module is patched with deep_realize, but many of the usual operators may not work. Test.

crosshair/libimpl/functoolslib.py

@@ -0,0 +1,34 @@
+from functools import _lru_cache_wrapper, partial, reduce, update_wrapper, wraps
+
+from crosshair.core import register_patch
+
+# TODO: deal with lru_cache (note it needs to be intercepted at import-time)
+
+
+def _partial(func, *a1, **kw1):
+    if callable(func):
+        # We make a do-nothing wrapper to ensure that the tracer has a crack
+        # at this function when it is called.
+        def wrapper(*a2, **kw2):
+            return func(*a2, **kw2)
+
+        update_wrapper(wrapper, func)
+        return partial(wrapper, *a1, **kw1)
+    else:
+        raise TypeError
+
+
+def _reduce(function, *a, **kw):
+    return reduce(lambda x, y: function(x, y), *a, **kw)
+
+
+def make_registrations():
+    register_patch(partial, _partial)
+    register_patch(reduce, _reduce)
+
+    def call_with_skipped_cache(self, *a, **kw):
+        if not isinstance(self, _lru_cache_wrapper):
+            raise TypeError
+        return self.__wrapped__(*a, **kw)
+
+    register_patch(_lru_cache_wrapper.__call__, call_with_skipped_cache)

crosshair/libimpl/functoolslib_test.py

@@ -0,0 +1,56 @@
+import functools
+import inspect
+
+from crosshair.core import proxy_for_type, standalone_statespace
+from crosshair.libimpl.builtinslib import LazyIntSymbolicStr
+from crosshair.tracers import NoTracing, ResumedTracing
+
+
+def test_partial(space):
+    abc = LazyIntSymbolicStr(list(map(ord, "abc")))
+    xyz = LazyIntSymbolicStr(list(map(ord, "xyz")))
+    with ResumedTracing():
+        joiner = functools.partial(str.join, ",")
+        ret = joiner([abc, xyz])
+        assert ret == "abc,xyz"
+
+
+def test_partial_is_interceptable(space):
+    x = proxy_for_type(str, "x")
+    y = proxy_for_type(str, "y")
+    with ResumedTracing():
+        joiner = functools.partial(str.startswith, x)
+        # Ensure we don't explode
+        list(map(joiner, ["foo", y]))
+
+
+def test_partial_arg_is_inspectable(space):
+    with ResumedTracing():
+        joiner = functools.partial(str.join, ",")
+        assert isinstance(joiner, functools.partial)
+        assert inspect.getdoc(joiner.func) == inspect.getdoc(str.join)
+
+
+def test_reduce():
+    with standalone_statespace as space:
+        with NoTracing():
+            string = LazyIntSymbolicStr(list(map(ord, "12 oofoo 12")))
+            tostrip = LazyIntSymbolicStr(list(map(ord, "2")))
+        ret = functools.reduce(str.strip, [string, "1", "2"])
+        assert ret == " oofoo 1"
+
+
+_global_state = [42]
+
+
+@functools.lru_cache()
+def whaa(x: int) -> int:
+    _global_state[0] += 1
+    return _global_state[0]
+
+
+def test_lru_cache_is_ignored():
+    with standalone_statespace as space:
+        assert whaa(0) == 43
+        assert whaa(1) == 44
+        assert whaa(1) == 45

crosshair/libimpl/hashliblib.py

@@ -0,0 +1,30 @@
+import hashlib
+import sys
+
+from crosshair.core import register_patch, with_realized_args
+
+
+def make_registrations():
+    if sys.version_info < (3, 12):
+        # As of Python 3.12, SymbolicBytes can implement __buffer__() to be compatible
+        # with hash functions. Prior to that, we patch them manually:
+
+        to_patch = {hashlib.new: None}  # we don't use a set so that the patch order
+        # is deterministic, which matters for the patch_equivalence_test when
+        # run under pytest -n
+        for algo_string in sorted(hashlib.algorithms_available):
+            hash_constructor = getattr(hashlib, algo_string, None)
+            if hash_constructor is not None:
+                to_patch[hash_constructor] = None
+            try:
+                example_instance = hashlib.new(algo_string)
+            except ValueError:
+                if sys.version_info < (3, 9):
+                    # in 3.8, some "available" algorithms aren't available
+                    continue
+                else:
+                    raise
+            update_method = getattr((type(example_instance)), "update")
+            to_patch[update_method] = None
+        for fn in to_patch:
+            register_patch(fn, with_realized_args(fn))

crosshair/libimpl/hashliblib_test.py

@@ -0,0 +1,18 @@
+import hashlib
+
+from crosshair.core import proxy_for_type, standalone_statespace
+
+
+def test_sha384():
+    with standalone_statespace:
+        x = proxy_for_type(bytes, "x")
+        hashlib.new("sha384", x)
+        hashlib.sha384(x)
+
+
+def test_blake_via_update():
+    with standalone_statespace:
+        x = proxy_for_type(bytes, "x")
+        h = hashlib.blake2b()
+        h.update(x)
+        h.hexdigest()

crosshair/libimpl/heapqlib.py

@@ -0,0 +1,47 @@
+import functools
+import heapq
+import types
+
+import _heapq
+
+from crosshair.core import register_patch
+from crosshair.util import debug, imported_alternative, name_of_type
+
+
+def _check_first_arg_is_list(fn):
+    functools.wraps(fn)
+
+    def wrapper(heap, *a, **kw):
+        if not isinstance(heap, list):
+            raise TypeError(
+                f"{fn.__name__} argument must be list, not {name_of_type(heap)}"
+            )
+        return fn(heap, *a, **kw)
+
+    return wrapper
+
+
+def make_registrations():
+    native_funcs = [
+        "_heapify_max",
+        "_heappop_max",
+        "_heapreplace_max",
+        "heapify",
+        "heappop",
+        "heappush",
+        "heappushpop",
+        "heapreplace",
+    ]
+    with imported_alternative("heapq", ("_heapq",)):
+
+        # The pure python version doesn't always check argument types:
+        heapq.heappush = heapq.heappush
+        heapq.heappop = _check_first_arg_is_list(heapq.heappop)
+
+        pure_fns = {name: getattr(heapq, name) for name in native_funcs}
+    for name in native_funcs:
+        native_fn = getattr(heapq, name)
+        pure_fn = pure_fns[name]
+        assert isinstance(native_fn, types.BuiltinFunctionType)
+        assert isinstance(pure_fn, types.FunctionType)
+        register_patch(native_fn, _check_first_arg_is_list(pure_fn))

crosshair/libimpl/heapqlib_test.py

@@ -0,0 +1,21 @@
+import heapq
+import sys
+from typing import List
+
+import pytest
+
+from crosshair.core import proxy_for_type
+from crosshair.tracers import ResumedTracing
+
+
+# TODO https://github.com/pschanely/CrossHair/issues/298
+@pytest.mark.skip(
+    reason="heapq get reloaded somehow in parallel ci run, ruining the intercepts",
+)
+def test_heapify(space):
+    items = proxy_for_type(List[int], "items")
+
+    with ResumedTracing():
+        space.add(len(items) == 3)
+        heapq.heapify(items)
+        assert not space.is_possible(items[0] > items[1])

crosshair/libimpl/importliblib.py

@@ -0,0 +1,18 @@
+from importlib._bootstrap import _find_and_load_unlocked  # type: ignore
+
+from crosshair import register_patch
+from crosshair.tracers import NoTracing
+
+
+# Do not import with tracing enabled.
+# (it's expensive, and won't behave deterministically)
+#
+# NOTE: The importlib._bootstrap._find_and_load_unlocked entry point covers both the
+# regular import statement, as well as loads via the importlib module.
+def __find_and_load_unlocked(*a, **kw):
+    with NoTracing():
+        return _find_and_load_unlocked(*a, **kw)
+
+
+def make_registrations() -> None:
+    register_patch(_find_and_load_unlocked, __find_and_load_unlocked)

crosshair/libimpl/importliblib_test.py

@@ -0,0 +1,38 @@
+import subprocess
+import sys
+
+from crosshair.main import Path, textwrap
+from crosshair.test_util import simplefs
+
+DYNAMIC_IMPORT = {
+    "__init__.py": "",
+    "outer.py": textwrap.dedent(
+        """\
+        def outerfn(x: int) -> int:
+            ''' post: _ == x '''
+            from .innerx import innerfn
+            return innerfn(x)
+        """
+    ),
+    "innerx.py": textwrap.dedent(
+        """
+        from crosshair.tracers import is_tracing
+        assert not is_tracing()
+        def innerfn(x: int) -> int:
+            return x
+        """
+    ),
+}
+
+
+def test_dynamic_import(tmp_path: Path):
+    # This imports another module while checking.
+    # The inner module asserts that tracing is not enabled.
+    simplefs(tmp_path, DYNAMIC_IMPORT)
+    ret = subprocess.run(
+        [sys.executable, "-m", "crosshair", "check", str(tmp_path / "outer.py")],
+        stdin=subprocess.DEVNULL,
+        capture_output=True,
+        text=True,
+    )
+    assert (ret.returncode, ret.stdout, ret.stderr) == (0, "", "")

crosshair/libimpl/iolib.py

@@ -0,0 +1,216 @@
+import re
+from io import SEEK_CUR, SEEK_END, SEEK_SET, StringIO, TextIOBase
+from typing import Optional, Tuple, Union
+
+from crosshair import ResumedTracing, SymbolicFactory, register_type
+from crosshair.core import realize, register_patch
+from crosshair.tracers import NoTracing
+from crosshair.util import CrossHairValue, IgnoreAttempt
+
+_UNIVERSAL_NEWLINE_RE = re.compile(r"(\r\n|\r|\n)")
+
+
+class BackedStringIO(TextIOBase, CrossHairValue):
+    _contents: str
+    _pos: int
+    _discovered_newlines: set
+    _newline_mode: Optional[str]
+
+    def __init__(
+        self,
+        initial_value: Optional[str] = None,
+        newline: Optional[str] = "\n",
+        pos: int = 0,
+    ):
+        if not (isinstance(newline, (str, type(None)))):
+            raise TypeError
+        if newline not in (None, "", "\n", "\r", "\r\n"):
+            raise ValueError
+        if initial_value is None:
+            initial_value = ""
+        if not (isinstance(initial_value, str)):
+            raise TypeError
+        if pos < 0:
+            raise ValueError
+        self._newline_mode = newline
+        self._discovered_newlines = set()
+        self._pos = pos
+        self._contents = self._replace_newlines(initial_value) if initial_value else ""
+
+    def __repr__(self):
+        contents, newline_mode, pos = self._contents, self._newline_mode, self._pos
+        if pos == 0:
+            if newline_mode == "\n":
+                return f"BackedStringIO({contents!r})"
+            else:
+                return f"BackedStringIO({contents!r}, {newline_mode!r})"
+        return (
+            f"BackedStringIO({contents!r}, newline_mode={newline_mode!r}, pos={pos!r})"
+        )
+
+    def __ch_pytype__(self):
+        return StringIO
+
+    def __ch_realize__(self):
+        if self.closed:
+            raise ValueError
+        contents, newline_mode = realize(self._contents), realize(self._newline_mode)
+        with NoTracing():
+            sio = StringIO(contents, newline_mode)
+        sio.seek(realize(self._pos))
+        return sio
+
+    @property
+    def newlines(self) -> Union[None, str, Tuple[str, ...]]:  # type: ignore
+        discovered = self._discovered_newlines
+        # Fiddly! Trying to preserve the static tuple ordering that CPython has:
+        ret = tuple(nl for nl in ("\r", "\n", "\r\n") if nl in discovered)
+        if len(ret) > 1:
+            return ret
+        if len(ret) == 1:
+            return ret[0]
+        return None
+
+    def _replace_newlines(self, string: str) -> str:
+        newline_mode = self._newline_mode
+        if newline_mode is None:
+
+            def replace(match: re.Match) -> str:
+                self._discovered_newlines.add(match.group())
+                return "\n"
+
+            return _UNIVERSAL_NEWLINE_RE.sub(replace, string)
+        elif newline_mode == "":
+            self._discovered_newlines.update(_UNIVERSAL_NEWLINE_RE.findall(string))
+            return string
+        elif newline_mode == "\n":
+            return string
+        else:
+            return string.replace("\n", newline_mode)
+
+    def flush(self) -> None:
+        return
+
+    def getvalue(self) -> str:
+        return self._contents
+
+    def read(self, amount: Optional[int] = None) -> str:
+        if self.closed:
+            raise ValueError
+        if amount is None:
+            ret = self._contents[self._pos :]
+        else:
+            ret = self._contents[self._pos : self._pos + amount]
+        self._pos += len(ret)
+        return ret
+
+    def readable(self) -> bool:
+        if self.closed:
+            raise ValueError
+        return True
+
+    def readline(self, limit: Optional[int] = None) -> str:  # type: ignore
+        if self.closed:
+            raise ValueError
+        contents, pos = self._contents, self._pos
+        if limit is None:
+            limit = len(contents)
+        if self._newline_mode == "":
+            # All other modes would have normalized the contents to \n already.
+            for match in _UNIVERSAL_NEWLINE_RE.finditer(contents, pos, limit):
+                self._pos = match.end()
+                return contents[pos : match.end()]
+            self._pos = limit
+            return contents[pos:limit]
+        else:
+            nl = self._newline_mode or "\n"
+            nl_size = len(nl)
+            idx = contents.find(nl, pos, limit)
+            if idx == -1:
+                self._pos = limit
+                return contents[pos:limit]
+            else:
+                self._pos = idx + nl_size
+                return contents[pos : idx + nl_size]
+
+    def write(self, string: str) -> int:
+        if self.closed:
+            raise ValueError
+        contents, pos = self._contents, self._pos
+        contentslen = len(contents)
+        if not string:
+            return 0
+        writestr = self._replace_newlines(string)
+        writelen = len(writestr)
+        if pos > contentslen:
+            self._contents += "\u0000" * (pos - contentslen)
+            contentslen = pos
+        if pos == contentslen:
+            self._contents += writestr
+        else:
+            self._contents = contents[:pos] + writestr + contents[pos + writelen :]
+        self._pos = pos + writelen
+        # Don't return `writelen` because all the input characters were "written":
+        return len(string)
+
+    def seek(self, amount: int, whence: int = SEEK_SET) -> int:
+        if self.closed:
+            raise ValueError
+        if whence == SEEK_CUR:
+            if amount != 0:
+                raise OSError
+            pos = self._pos + amount
+        elif whence == SEEK_END:
+            if amount != 0:
+                raise OSError
+            pos = len(self._contents) + amount
+        elif whence == SEEK_SET:
+            if amount < 0:
+                raise ValueError
+            pos = amount
+        else:
+            raise ValueError
+        self._pos = pos
+        return pos
+
+    def seekable(self) -> bool:
+        if self.closed:
+            raise ValueError
+        return True
+
+    def tell(self) -> int:
+        if self.closed:
+            raise ValueError
+        return self._pos
+
+    def truncate(self, size: Optional[int] = None) -> int:
+        if self.closed:
+            raise ValueError
+        if size is None:
+            size = self._pos
+        self._contents = self._contents[:size]
+        return size
+
+    def writable(self) -> bool:
+        if self.closed:
+            raise ValueError
+        return True
+
+
+def make_string_io(factory: SymbolicFactory) -> BackedStringIO:
+    contents = factory(str)
+    newline_mode = factory(Optional[str])
+    with ResumedTracing():
+        if newline_mode not in (None, "", "\n", "\r", "\r\n"):
+            raise IgnoreAttempt
+        return BackedStringIO(contents, newline_mode)
+
+
+def _string_io(initial_value: str = "", newline="\n"):
+    return BackedStringIO(initial_value, newline)
+
+
+def make_registrations() -> None:
+    register_type(StringIO, make_string_io)
+    register_patch(StringIO, _string_io)
+    # TODO: register_type io.TextIO, BytesIO, ...

crosshair/libimpl/iolib_ch_test.py

@@ -0,0 +1,128 @@
+import sys
+from io import StringIO
+from typing import List, Optional, Tuple, Union
+
+import pytest  # type: ignore
+
+from crosshair.core_and_libs import MessageType, analyze_function, run_checkables
+from crosshair.libimpl.iolib import BackedStringIO
+from crosshair.test_util import compare_returns
+
+
+def _do_something(s: Union[StringIO, BackedStringIO], opname: str) -> object:
+    if opname == "closed":
+        return s.closed
+    elif opname == "flush":
+        s.flush()
+    elif opname == "read":
+        return s.read()
+    elif opname == "readlines":
+        return s.readlines()
+    elif opname == "readable":
+        return s.readable()
+    elif opname == "seek":
+        return s.seek(1)
+    elif opname == "seekable":
+        return s.seekable()
+    elif opname == "tell":
+        return s.tell()
+    elif opname == "truncate":
+        return s.truncate()
+    elif opname == "writable":
+        return s.writable()
+    elif opname == "write":
+        return s.write("")
+    return None
+
+
+def check_stringio_readlines(s: StringIO, hint: int):
+    """post: _"""
+
+    def readlines(s, hint: int):
+        return s.readlines(hint)
+
+    return compare_returns(readlines, s, hint)
+
+
+def check_stringio_writelines(s: StringIO, lines: List[str]):
+    """post: _"""
+
+    def writelines(s, lines: List[str]):
+        retval = s.writelines(lines)
+        return (retval, s.tell(), s.getvalue())
+
+    return compare_returns(writelines, s, lines)
+
+
+def check_stringio_seek1(s: StringIO, o1: int, w1: int):
+    """post: _"""
+
+    def seek_double(s, o1: int, w1: int) -> int:
+        s.seek(o1, w1)
+        return s.tell()
+
+    return compare_returns(seek_double, s, o1, w1)
+
+
+def check_stringio_seek_seek(s: StringIO, o1: int, w1: int, o2: int, w2: int):
+    """post: _"""
+
+    def seek_seek(s, o1: int, w1: int, o2: int, w2: int) -> int:
+        s.seek(o1, w1)
+        s.seek(o2, w2)
+        return s.tell()
+
+    return compare_returns(seek_seek, s, o1, w1, o2, w2)
+
+
+def check_stringio_seek_write(s: StringIO, o1: int, w1: int, ws: str):
+    """post: _"""
+    # crosshair: max_uninteresting_iterations=15
+
+    def seek_write(s, o1: int, w1: int, ws: str) -> Tuple[int, int, str]:
+        s.seek(o1, w1)
+        retval = s.write(ws)
+        return (retval, s.tell(), s.getvalue())
+
+    return compare_returns(seek_write, s, o1, w1, ws)
+
+
+def check_stringio_write_newlines(newline_mode: str, ws: str):
+    """post: _"""
+
+    def write_newlines(newline_mode: Optional[str], ws: str):
+        if newline_mode in (None, "", "\n", "\r", "\r\n"):
+            s = BackedStringIO("", newline_mode)
+            s.write(ws)
+            return s.newlines
+
+    return compare_returns(write_newlines, newline_mode, ws)
+
+
+def check_stringio_simple_operation(s: StringIO, opname: str):
+    """post: _"""
+
+    def simple_operation(s, opname: str) -> object:
+        return _do_something(s, opname)
+
+    return compare_returns(simple_operation, s, opname)
+
+
+def check_stringio_operation_while_closed(s: StringIO, opname: str):
+    """post: _"""
+
+    def closed_operation(s, opname: str) -> object:
+        s.close()
+        return _do_something(s, opname)
+
+    return compare_returns(closed_operation, s, opname)
+
+
+# This is the only real test definition.
+# It runs crosshair on each of the "check" functions defined above.
+@pytest.mark.parametrize("fn_name", [fn for fn in dir() if fn.startswith("check_")])
+def test_builtin(fn_name: str) -> None:
+    fn = getattr(sys.modules[__name__], fn_name)
+    messages = run_checkables(analyze_function(fn))
+    errors = [m for m in messages if m.state > MessageType.PRE_UNSAT]
+    assert errors == []