crosshair-tool 0.0.56__cp39-cp39-macosx_11_0_arm64.whl → 0.0.100__cp39-cp39-macosx_11_0_arm64.whl

crosshair/libimpl/decimallib_ch_test.py

@@ -0,0 +1,78 @@
+import operator
+import sys
+from decimal import BasicContext, Decimal, ExtendedContext, localcontext
+from typing import Union
+
+import pytest  # type: ignore
+
+from crosshair.core_and_libs import MessageType, analyze_function, run_checkables
+from crosshair.test_util import ResultComparison, compare_results, compare_returns
+
+
+def _binary_op_under_context(ctx, op):
+    def run_op(d1, d2):
+        with localcontext(ctx):
+            return op(d1, d2)
+
+    return run_op
+
+
+def check_division(
+    decimal1: Decimal, decimal2: Union[Decimal, int, float]
+) -> ResultComparison:
+    """post: _"""
+    return compare_returns(operator.truediv, decimal1, decimal2)
+
+
+def check_pow(decimal1: Decimal, decimal2: Decimal) -> ResultComparison:
+    """post: _"""
+    return compare_results(operator.pow, decimal1, decimal2)
+
+
+def check_extended_context(
+    decimal1: Decimal, decimal2: Union[Decimal, int, float]
+) -> ResultComparison:
+    """post: _"""
+    return compare_results(
+        _binary_op_under_context(ExtendedContext, operator.truediv), decimal1, decimal2
+    )
+
+
+def check_basic_context(
+    decimal1: Decimal, decimal2: Union[Decimal, int, float]
+) -> ResultComparison:
+    """post: _"""
+    return compare_results(
+        _binary_op_under_context(BasicContext, operator.truediv), decimal1, decimal2
+    )
+
+
+def check_div_using_context_method(
+    decimal1: Decimal, decimal2: Union[Decimal, int, float]
+) -> ResultComparison:
+    """post: _"""
+    return compare_returns(BasicContext.divide, decimal1, decimal2)
+
+
+def check_div_using_context_parameter(
+    decimal1: Decimal, decimal2: Union[Decimal, int, float]
+) -> ResultComparison:
+    """post: _"""
+    return compare_returns(
+        lambda d1, d2: d1.divide(d2, context=BasicContext), decimal1, decimal2
+    )
+
+
+def check_create_decimal_from_float(float_number: float):
+    """post: _"""
+    return compare_results(BasicContext.create_decimal_from_float, float_number)
+
+
+# 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:
+    this_module = sys.modules[__name__]
+    messages = run_checkables(analyze_function(getattr(this_module, fn_name)))
+    errors = [m for m in messages if m.state > MessageType.PRE_UNSAT]
+    assert errors == []

crosshair/libimpl/decimallib_test.py

@@ -0,0 +1,76 @@
+from decimal import (
+    Decimal,
+    DivisionByZero,
+    ExtendedContext,
+    InvalidOperation,
+    localcontext,
+)
+
+import pytest
+
+from crosshair.core import proxy_for_type, standalone_statespace
+from crosshair.libimpl.decimallib import Decimal as PyDecimal
+from crosshair.tracers import NoTracing
+from crosshair.util import debug
+
+
+def test_mixed_decimal_addition() -> None:
+    d1 = Decimal("1.05")
+    with standalone_statespace:
+        d2 = proxy_for_type(Decimal, "d2")
+        debug("type(d2)", type(d2))
+        d1 + d2
+
+
+def test_external_decimal_context() -> None:
+    with localcontext(ExtendedContext):
+        Decimal("43.4") / 0  # does not raise
+    with pytest.raises(DivisionByZero):
+        Decimal("43.4") / 0
+    with pytest.raises(InvalidOperation):
+        Decimal("0") / 0
+    with pytest.raises(DivisionByZero):
+        PyDecimal("43.4") / 0
+    with standalone_statespace as space:
+        with NoTracing():
+            d1 = proxy_for_type(Decimal, "d1")
+        if d1 == 0:
+            d1 += 1
+        with pytest.raises(DivisionByZero):
+            d1 / 0
+        with pytest.raises(InvalidOperation):
+            (d1 - d1) / 0
+
+
+def test_context_method_on_symbolic():
+    with standalone_statespace:
+        ExtendedContext.exp(proxy_for_type(Decimal, "d"))
+        ExtendedContext.divide_int(Decimal(12), proxy_for_type(Decimal, "d"))
+        ExtendedContext.divide_int(Decimal(12), Decimal(2))
+
+
+def test_precision():
+    """post: _"""
+    d1, d2 = Decimal("3.4445"), Decimal("1.0023")
+    expected = Decimal("4.45")
+    assert d1 + d2 != expected
+    with standalone_statespace:
+        with localcontext() as ctx:
+            ctx.prec = 3
+            assert d1 + d2 == expected
+        with localcontext() as ctx:
+            ctx.prec = 1
+            assert +expected == Decimal("4")
+
+
+# Still working on this! (rn, issue with z3 int exponent vars becoming reals)
+# def test_decimal_end_to_end():
+#     def add_tax(price: Decimal):
+#         """post: _ != Decimal('1.05')"""
+#         ctx = ExtendedContext.copy()
+#         ctx.prec = 3
+#         with localcontext(ctx):
+#             return price + Decimal("0.05")
+#             # return price * Decimal("1.05")
+
+#     check_states(add_tax, POST_FAIL)

crosshair/libimpl/encodings/_encutil.py

@@ -1,7 +1,12 @@
 import codecs
-from collections.abc import ByteString
+import sys
 from dataclasses import dataclass
-from typing import Dict, List, Optional, Tuple, Type, Union
+from typing import List, Optional, Tuple, Type, Union
+
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer
+else:
+    from collections.abc import ByteString as Buffer
 
 from crosshair.core import realize
 from crosshair.libimpl.builtinslib import AnySymbolicStr, SymbolicBytes
@@ -20,6 +25,7 @@ class UnexpectedEndError(ChunkError):
 @dataclass
 class MidChunkError(ChunkError):
     _reason: str
+
     # _errlen: int = 1
     def reason(self) -> str:
         return self._reason
@@ -30,7 +36,7 @@ class _UnicodeDecodeError(UnicodeDecodeError):
         UnicodeDecodeError.__init__(self, enc, b"", start, end, reason)
         self.object = byts
 
-    def __ch_deep_realize__(self) -> object:
+    def __ch_deep_realize__(self, memo) -> object:
         enc, obj, reason = self.encoding, self.object, self.reason
         start, end = self.start, self.end
         return UnicodeDecodeError(
@@ -87,7 +93,7 @@ class StemEncoder:
     def decode(
         cls, input: bytes, errors: str = "strict"
     ) -> Tuple[Union[str, AnySymbolicStr], int]:
-        if not (isinstance(input, ByteString) and isinstance(errors, str)):
+        if not (isinstance(input, Buffer) and isinstance(errors, str)):
             raise TypeError
         parts: List[Union[str, AnySymbolicStr]] = []
         idx = 0
@@ -107,7 +113,7 @@ class StemEncoder:
                     continue
                 if errors == "replace":
                     idx += 1
-                    parts.append("\uFFFD")
+                    parts.append("\ufffd")
                     continue
 
                 # 2. Then fall back to native implementations if necessary:
@@ -127,24 +133,28 @@ class StemEncoder:
 
 def _getregentry(stem_encoder: Type[StemEncoder]):
     class StemIncrementalEncoder(codecs.BufferedIncrementalEncoder):
-        def _buffer_encode(self, input: str, errors: str, final: bool) -> bytes:
+        def _buffer_encode(
+            self, input: str, errors: str, final: bool
+        ) -> Tuple[bytes, int]:
             enc_name = stem_encoder.encoding_name
             out, idx, err = stem_encoder._encode_chunk(input, 0)
             assert isinstance(out, bytes)
             if not err:
-                return out
+                return (out, idx)
             if isinstance(err, UnexpectedEndError) or not final:
-                return out
+                return (out, idx)
             exc = UnicodeEncodeError(enc_name, input, idx, idx + 1, err.reason())
             replacement, idx = codecs.lookup_error(errors)(exc)
             if isinstance(replacement, str):
                 replacement = codecs.encode(replacement, enc_name)
-            return out + replacement
+            return (out + replacement, idx)
 
     class StemIncrementalDecoder(codecs.BufferedIncrementalDecoder):
         def _buffer_decode(
-            self, input: bytes, errors: str, final: bool
+            self, input: Buffer, errors: str, final: bool
         ) -> Tuple[str, int]:
+            if not isinstance(input, bytes):
+                input = memoryview(input).tobytes()
             enc_name = stem_encoder.encoding_name
             out, idx, err = stem_encoder._decode_chunk(input, 0)
             assert isinstance(out, str)
@@ -160,7 +170,7 @@ def _getregentry(stem_encoder: Type[StemEncoder]):
 
     class StemStreamWriter(codecs.StreamWriter):
         def encode(self, input: str, errors: str = "strict") -> Tuple[bytes, int]:
-            raise Exception
+            raise Exception  # TODO implement
 
     class StemStreamReader(codecs.StreamReader):
         def decode(self, input: bytes, errors: str = "strict") -> Tuple[str, int]:

crosshair/libimpl/fractionlib.py

@@ -0,0 +1,16 @@
+from fractions import Fraction
+
+from crosshair.core import SymbolicFactory, register_type
+from crosshair.statespace import force_true
+from crosshair.tracers import ResumedTracing
+
+
+def _make_fraction(factory: SymbolicFactory):
+    n, d = factory(int, "_numerator"), factory(int, "_denominator")
+    with ResumedTracing():
+        force_true(d > 0)
+        return Fraction(n, d)
+
+
+def make_registrations() -> None:
+    register_type(Fraction, _make_fraction)

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

@@ -1,22 +1,34 @@
-import functools as orig_functools
+from functools import _lru_cache_wrapper, partial, reduce, update_wrapper, wraps
 
-from crosshair.core import register_fn_type_patch, register_patch
+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):
-        return orig_functools.partial(lambda *a2, **kw2: func(*a2, **kw2), *a1, **kw1)
+        # 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 orig_functools.reduce(lambda x, y: function(x, y), *a, **kw)
+    return reduce(lambda x, y: function(x, y), *a, **kw)
 
 
 def make_registrations():
-    register_patch(orig_functools.partial, _partial)
-    register_patch(orig_functools.reduce, _reduce)
-    register_fn_type_patch(orig_functools._lru_cache_wrapper, lambda w: w.__wrapped__)
+    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

@@ -1,20 +1,36 @@
 import functools
+import inspect
 
 from crosshair.core import proxy_for_type, standalone_statespace
 from crosshair.libimpl.builtinslib import LazyIntSymbolicStr
-from crosshair.tracers import NoTracing
+from crosshair.tracers import NoTracing, ResumedTracing
 
 
-def test_partial():
-    with standalone_statespace as space:
-        with NoTracing():
-            abc = LazyIntSymbolicStr(list(map(ord, "abc")))
-            xyz = LazyIntSymbolicStr(list(map(ord, "xyz")))
+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():

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

@@ -1,20 +1,47 @@
+import functools
 import heapq
+import types
 
 import _heapq
 
 from crosshair.core import register_patch
-from crosshair.util import import_alternative
+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():
-    pureheapq = import_alternative("heapq", ("_heapq",))
-    native_funcs = [name for name in dir(_heapq) if not name.startswith("_")]
-    assert native_funcs == [
+    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:
-        register_patch(getattr(heapq, name), getattr(pureheapq, name))
+        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

@@ -1,18 +1,21 @@
 import heapq
+import sys
 from typing import List
 
-from crosshair.options import AnalysisOptionSet
-from crosshair.statespace import CONFIRMED, MessageType
-from crosshair.test_util import check_states
+import pytest
 
+from crosshair.core import proxy_for_type
+from crosshair.tracers import ResumedTracing
 
-def test_heapify():
-    def f(items: List[int]):
-        """
-        pre: len(items) == 3
-        post: _[0] <= _[1]
-        """
-        heapq.heapify(items)
-        return items
 
-    check_states(f, CONFIRMED)
+# 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/iolib.py

@@ -3,9 +3,9 @@ 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 CrossHairValue, realize, register_patch
+from crosshair.core import realize, register_patch
 from crosshair.tracers import NoTracing
-from crosshair.util import IgnoreAttempt
+from crosshair.util import CrossHairValue, IgnoreAttempt
 
 _UNIVERSAL_NEWLINE_RE = re.compile(r"(\r\n|\r|\n)")
 
@@ -83,6 +83,8 @@ class BackedStringIO(TextIOBase, CrossHairValue):
         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)
 
@@ -148,7 +150,8 @@ class BackedStringIO(TextIOBase, CrossHairValue):
         else:
             self._contents = contents[:pos] + writestr + contents[pos + writelen :]
         self._pos = pos + writelen
-        return 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:
@@ -210,4 +213,4 @@ def _string_io(initial_value: str = "", newline="\n"):
 def make_registrations() -> None:
     register_type(StringIO, make_string_io)
     register_patch(StringIO, _string_io)
-    # TODO: register_type(io.TextIO, )
+    # TODO: register_type io.TextIO, BytesIO, ...

crosshair/libimpl/ipaddresslib.py

@@ -0,0 +1,8 @@
+import ipaddress
+
+
+def make_registrations():
+    # ipaddress uses a homegrown internal netmask cache.
+    # There aren't many netmasks - load all of them (to avoid nondeterminism):
+    [ipaddress.IPv6Network._make_netmask(sz) for sz in range(129)]
+    [ipaddress.IPv4Network._make_netmask(sz) for sz in range(33)]

crosshair/libimpl/itertoolslib_test.py

@@ -13,7 +13,7 @@ def test_keyfn_is_intercepted():
     with standalone_statespace as space:
         with NoTracing():
             two = proxy_for_type(int, "two")
-            space.add(two.var == 2)
+        space.add(two == 2)
         ret = list((k, tuple(v)) for k, v in itertools.groupby([1, two, 3.0], type))
         assert ret == [(int, (1, 2)), (float, (3.0,))]