crosshair-tool 0.0.99__cp312-cp312-macosx_10_13_x86_64.whl

crosshair/libimpl/jsonlib_ch_test.py

@@ -0,0 +1,42 @@
+import json
+import sys
+from typing import Dict, List, Tuple, Union
+
+import pytest  # type: ignore
+
+from crosshair.core_and_libs import MessageType, analyze_function, run_checkables
+from crosshair.options import AnalysisOptionSet
+from crosshair.test_util import compare_results
+
+
+def check_decode(s: str):
+    """post: _"""
+    return compare_results(json.loads, s)
+
+
+def check_encode_atomics(obj: Union[bool, float, str, int]):
+    """post: _"""
+    return compare_results(json.dumps, obj)
+
+
+def check_encode_containers(obj: Union[Dict[float, bool], Tuple[int, bool], List[str]]):
+    """post: _"""
+    return compare_results(json.dumps, obj)
+
+
+def check_encode_decode_roundtrip(obj: Union[bool, int, str]):
+    """post: _"""
+    return compare_results(lambda o: json.loads(json.dumps(o)), obj)
+
+
+# TODO: Test customized encoding stuff
+
+
+# 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 == []

crosshair/libimpl/jsonlib_test.py

@@ -0,0 +1,51 @@
+import json
+from typing import List
+
+import pytest
+
+from crosshair.core_and_libs import standalone_statespace
+from crosshair.statespace import POST_FAIL
+from crosshair.test_util import check_states
+
+
+def test_disallow_unicode_digits():
+    with standalone_statespace:
+        float("0E٠")  # This is a valid float!
+        with pytest.raises(json.JSONDecodeError):
+            json.loads("0E٠")  # But not a valid JSON float.
+
+
+@pytest.mark.demo("yellow")
+def test_dumps():
+    def f(lst: List[int]):
+        """
+        Can a JSON-serialized list be larger than 10 characters?
+
+        NOTE: Although this example is fast, most JSON serialization
+        tasks require at least a few minutes of analysis, and many may
+        not be solvable in any reasonable time frame.
+
+        post: len(_) <= 10
+        """
+        return json.dumps(lst)
+
+    check_states(f, POST_FAIL)
+
+
+@pytest.mark.demo("yellow")
+def test_loads():
+    def f(s: str):
+        """
+        Can we parse an empty JSON array out of a 3 character string?
+
+        NOTE: Although this example is fast, most JSON deserialization
+        tasks require at least a few minutes of analysis, and many may
+        not be solvable in any reasonable time frame.
+
+        pre: len(s) == 3
+        raises: json.JSONDecodeError
+        post: _ != []
+        """
+        return json.loads(s)
+
+    check_states(f, POST_FAIL)

crosshair/libimpl/mathlib.py

@@ -0,0 +1,179 @@
+import math
+import sys
+from numbers import Real
+
+import z3  # type: ignore
+
+from crosshair import NoTracing, register_patch
+from crosshair.core import with_realized_args
+from crosshair.libimpl.builtinslib import (
+    PreciseIeeeSymbolicFloat,
+    RealBasedSymbolicFloat,
+    SymbolicBool,
+    SymbolicIntable,
+    SymbolicValue,
+    smt_xor,
+)
+from crosshair.tracers import ResumedTracing
+from crosshair.util import name_of_type
+from crosshair.z3util import z3Not, z3Or
+
+
+def _is_positive(x):
+    if isinstance(x, SymbolicValue):
+        if isinstance(x, PreciseIeeeSymbolicFloat):
+            return SymbolicBool(z3Not(z3.fpIsNegative(x.var)))
+        elif isinstance(x, RealBasedSymbolicFloat):
+            return SymbolicBool(x.var >= 0)
+        else:
+            with ResumedTracing():
+                return x >= 0
+    else:
+        return math.copysign(1, x) == 1
+
+
+def _copysign(x, y):
+    if not isinstance(x, Real):
+        raise TypeError(f"must be real number, not {name_of_type(type(x))}")
+    if not isinstance(y, Real):
+        raise TypeError(f"must be real number, not {name_of_type(type(y))}")
+    with NoTracing():
+        x_is_positive = _is_positive(x)
+        y_is_positive = _is_positive(y)
+        # then invert as needed:
+    invert = smt_xor(x_is_positive, y_is_positive)
+    with NoTracing():
+        if isinstance(invert, SymbolicBool) and isinstance(
+            x, (PreciseIeeeSymbolicFloat, RealBasedSymbolicFloat)
+        ):
+            return type(x)(z3.If(invert.var, -x.var, x.var))
+        with ResumedTracing():
+            return -x if invert else x
+
+
+if sys.version_info >= (3, 9):
+
+    def _gcd(a=0, b=0):
+        while b:
+            a, b = b, a % b
+        return abs(a)
+
+else:  # (arguments were required in Python <= 3.8)
+
+    def _gcd(a, b):
+        while b:
+            a, b = b, a % b
+        return abs(a)
+
+
+def _isfinite(x):
+    with NoTracing():
+        if isinstance(x, (SymbolicIntable, RealBasedSymbolicFloat)):
+            return True
+        elif isinstance(x, PreciseIeeeSymbolicFloat):
+            return SymbolicBool(z3Not(z3Or(z3.fpIsNaN(x.var), z3.fpIsInf(x.var))))
+        else:
+            return math.isfinite(x)
+
+
+def _isnan(x):
+    with NoTracing():
+        if isinstance(x, (SymbolicIntable, RealBasedSymbolicFloat)):
+            return False
+        elif isinstance(x, PreciseIeeeSymbolicFloat):
+            return SymbolicBool(z3.fpIsNaN(x.var))
+        else:
+            return math.isnan(x)
+
+
+def _isinf(x):
+    with NoTracing():
+        if isinstance(x, (SymbolicIntable, RealBasedSymbolicFloat)):
+            return False
+        elif isinstance(x, PreciseIeeeSymbolicFloat):
+            return SymbolicBool(z3.fpIsInf(x.var))
+        else:
+            return math.isinf(x)
+
+
+_FUNCTIONS_WITH_REALIZATION = [
+    # TODO: we could attempt to implement some of these in the SMT solver
+    "acos",
+    "acosh",
+    "asin",
+    "asinh",
+    "atan",
+    "atan2",
+    "atanh",
+    "ceil",
+    "comb",
+    "cos",
+    "cosh",
+    "degrees",
+    "dist",
+    "erf",
+    "erfc",
+    "exp",
+    "expm1",
+    "fabs",
+    "factorial",
+    "floor",
+    "fmod",
+    "frexp",
+    "fsum",
+    "gamma",
+    "hypot",
+    "isclose",
+    "isqrt",
+    "ldexp",
+    "lgamma",
+    "log",
+    "log10",
+    "log1p",
+    "log2",
+    "modf",
+    "perm",
+    "pow",
+    "prod",
+    "radians",
+    "remainder",
+    "sin",
+    "sinh",
+    "sqrt",
+    "tan",
+    "tanh",
+    "trunc",
+]
+
+if sys.version_info >= (3, 9):
+    _FUNCTIONS_WITH_REALIZATION.extend(
+        [
+            "lcm",
+            "nextafter",
+            "ulp",
+        ]
+    )
+
+if sys.version_info >= (3, 11):
+    _FUNCTIONS_WITH_REALIZATION.extend(
+        [
+            "cbrt",
+            "exp2",
+        ]
+    )
+
+if sys.version_info >= (3, 12):
+    _FUNCTIONS_WITH_REALIZATION.append("sumprod")
+
+
+def make_registrations():
+    register_patch(math.copysign, _copysign)
+    register_patch(math.gcd, _gcd)
+    register_patch(math.isfinite, _isfinite)
+    register_patch(math.isnan, _isnan)
+    register_patch(math.isinf, _isinf)
+    for fn_name in _FUNCTIONS_WITH_REALIZATION:
+        fn = getattr(math, fn_name)
+        register_patch(
+            fn, with_realized_args(fn, deep=True)
+        )  # deep realization needed for Fraction instances

crosshair/libimpl/mathlib_ch_test.py

@@ -0,0 +1,44 @@
+import math
+import sys
+from typing import Union
+
+import pytest  # type: ignore
+
+from crosshair.core import realize
+from crosshair.core_and_libs import MessageType, analyze_function, run_checkables
+from crosshair.options import AnalysisOptionSet
+from crosshair.test_util import compare_results
+
+
+def check_copysign(
+    a: Union[int, float], b: Union[int, float], realize_a: bool, realize_b: bool
+):
+    """post: _"""
+    if realize_a:
+        a = realize(a)
+    if realize_b:
+        b = realize(b)
+    return compare_results(math.copysign, a, b)
+
+
+def check_gcd(a: int, b: int):
+    """
+    pre: all([-10 < a, a < 10, -10 < b, b < 10])  # for performance
+    post: _
+    """
+    return compare_results(math.gcd, a, b)
+
+
+# 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),
+            AnalysisOptionSet(max_uninteresting_iterations=50),
+        )
+    )
+    errors = [m for m in messages if m.state > MessageType.PRE_UNSAT]
+    assert errors == []

crosshair/libimpl/mathlib_test.py

@@ -0,0 +1,67 @@
+import math
+import sys
+
+import pytest
+
+from crosshair.core import proxy_for_type, standalone_statespace
+from crosshair.libimpl.builtinslib import (
+    ModelingDirector,
+    PreciseIeeeSymbolicFloat,
+    RealBasedSymbolicFloat,
+)
+from crosshair.statespace import POST_FAIL
+from crosshair.test_util import check_states
+from crosshair.tracers import NoTracing, ResumedTracing
+from crosshair.util import set_debug
+
+
+def test_copysign_e2e():
+    def can_find_minus_zero(x: float):
+        """post: math.copysign(1, _) == 1"""
+        if x == 0:
+            return x
+        return 1
+
+    check_states(can_find_minus_zero, POST_FAIL)
+
+
+@pytest.mark.parametrize(
+    "FloatType", [PreciseIeeeSymbolicFloat, RealBasedSymbolicFloat]
+)
+def test_copysign_symbolics(FloatType, space):
+    space.extra(ModelingDirector).global_representations[float] = FloatType
+    x = FloatType("x")
+    y = FloatType("y")
+    with ResumedTracing():
+        assert not space.is_possible(math.copysign(x, -0.0) > 0.0)
+        assert space.is_possible(math.copysign(x, y) > 0.0)
+        assert space.is_possible(math.copysign(x, y) < 0.0)
+
+
+def test_isfinite():
+    with standalone_statespace:
+        with NoTracing():
+            x = RealBasedSymbolicFloat("symfloat")
+        assert math.isfinite(x)
+        assert math.isfinite(2.3)
+        assert not math.isfinite(float("nan"))
+
+
+def test_isinf():
+    with standalone_statespace:
+        with NoTracing():
+            x = RealBasedSymbolicFloat("symfloat")
+        assert not math.isinf(x)
+        assert not math.isinf(float("nan"))
+        assert math.isinf(float("-inf"))
+
+
+def test_log():
+    with standalone_statespace as space:
+        with NoTracing():
+            i = proxy_for_type(int, "i")
+            f = proxy_for_type(float, "f")
+        space.add(i > 0)
+        space.add(f > 0)
+        math.log(i)
+        math.log(f)

crosshair/libimpl/oslib.py

@@ -0,0 +1,7 @@
+import os
+
+from crosshair.core import register_patch
+
+
+def make_registrations():
+    register_patch(os.fspath, os._fspath)

crosshair/libimpl/pathliblib_test.py

@@ -0,0 +1,10 @@
+from pathlib import PurePath
+
+from crosshair.core import proxy_for_type
+from crosshair.tracers import ResumedTracing
+
+
+def test_PurePath___init__(space):
+    pathstr = proxy_for_type(str, "pathstr")
+    with ResumedTracing():
+        PurePath(pathstr)

crosshair/libimpl/randomlib.py

@@ -0,0 +1,178 @@
+import random
+from functools import partial
+from inspect import Parameter, Signature
+from typing import Any, Callable, List, Optional, Union
+
+from crosshair import NoTracing, SymbolicFactory, register_type
+from crosshair.libimpl.builtinslib import SymbolicInt
+from crosshair.register_contract import register_contract
+
+
+class ExplicitRandom(random.Random):
+    def __new__(cls, *a):
+        return super().__new__(ExplicitRandom, 0)
+
+    def __init__(
+        self,
+        future_values: Optional[List[Union[int, float]]] = None,
+        idx: int = 0,
+        intgen: Callable[[int], int] = lambda c: 0,
+        floatgen: Callable[[], float] = lambda: 0.0,
+    ):
+        self._future_values = future_values if future_values else []
+        self._idx = idx
+        self._intgen = intgen
+        self._floatgen = floatgen
+        super().__init__()
+
+    def __copy__(self):
+        # Just a regular copy. (otherwise, we'd be deferring to getstate/setstate)
+        cls = self.__class__
+        result = cls.__new__(cls)
+        result.__dict__.update(self.__dict__)
+        return result
+
+    def __ch_deepcopy__(self, memo):
+        # We pretend this is a deepcopy, but it isn't.
+        # That way, the values lazily added to _future_values will be the same in each
+        # instance, even though we don't know what they are at the time of the deep
+        # copy.
+        return self.__copy__()
+
+    def __repr__(self) -> str:
+        return f"crosshair.libimpl.randomlib.ExplicitRandom({self._future_values!r})"
+
+    def __reduce__(self):
+        return (ExplicitRandom, (self._future_values, self._idx))
+
+    def random(self) -> float:
+        idx = self._idx
+        future_values = self._future_values
+        if idx >= len(future_values):
+            future_values.append(self._floatgen())
+        intorfloat = self._future_values[idx]
+        if isinstance(intorfloat, int):
+            ret = 1.0 / abs(intorfloat) if intorfloat != 0 else 0.0
+        else:
+            ret = intorfloat
+        self._idx += 1
+        return ret
+
+    def _randbelow(self, cap: int) -> int:
+        idx = self._idx
+        future_values = self._future_values
+        if idx >= len(future_values):
+            future_values.append(self._intgen(cap))
+        intorfloat = future_values[idx]
+        if isinstance(intorfloat, float):
+            ret = abs(hash(intorfloat)) % cap
+        else:
+            ret = intorfloat
+        self._idx += 1
+        return ret
+
+    def getrandbits(self, k: int) -> int:
+        return self._randbelow(2**k)
+
+
+def genint(factory: SymbolicFactory, cap: int):
+    # TODO: conditionally use SymbolicBoundedInt here and below
+    with NoTracing():
+        symbolic_int = SymbolicInt(factory.varname + factory.space.uniq(), int)
+        factory.space.add(0 <= symbolic_int.var)
+        factory.space.add(symbolic_int.var < SymbolicInt._coerce_to_smt_sort(cap))
+        return symbolic_int
+
+
+def genfloat(factory: SymbolicFactory):
+    with NoTracing():
+        symbolic_float: Any = factory(float)
+        factory.space.add(0.0 <= symbolic_float.var)
+        factory.space.add(symbolic_float.var < 1.0)
+        return symbolic_float
+
+
+def make_registrations() -> None:
+    register_type(
+        random.Random,
+        lambda p: ExplicitRandom([], 0, partial(genint, p), partial(genfloat, p)),
+    )
+
+    register_contract(
+        random.Random.random,
+        post=lambda __return__: 0.0 <= __return__ < 1.0,
+        sig=Signature(
+            parameters=[
+                Parameter("self", Parameter.POSITIONAL_OR_KEYWORD),
+            ],
+            return_annotation=float,
+        ),
+    )
+    register_contract(
+        random.Random.randint,
+        pre=lambda a, b: a <= b,
+        post=lambda __return__, a, b: a <= __return__ <= b,
+        sig=Signature(
+            parameters=[
+                Parameter("self", Parameter.POSITIONAL_OR_KEYWORD),
+                Parameter("a", Parameter.POSITIONAL_OR_KEYWORD, annotation=int),
+                Parameter("b", Parameter.POSITIONAL_OR_KEYWORD, annotation=int),
+            ],
+            return_annotation=int,
+        ),
+    )
+    register_contract(
+        random.Random.randrange,
+        pre=lambda start, stop, step: (
+            (step == 1 and start >= 1)
+            if stop is None
+            else (start != stop and step != 0 and (stop - start > 0) == (step > 0))
+        ),
+        post=lambda __return__, start, stop, step, _int=int: (
+            (0 <= __return__ < start if stop is None else start <= __return__ < stop)
+            and (step == 1 or (__return__ - start) % step == 0)
+        ),
+        sig=Signature(
+            parameters=[
+                Parameter("self", Parameter.POSITIONAL_OR_KEYWORD),
+                Parameter("start", Parameter.POSITIONAL_OR_KEYWORD, annotation=int),
+                Parameter(
+                    "stop",
+                    Parameter.POSITIONAL_OR_KEYWORD,
+                    default=None,
+                    annotation=Optional[int],
+                ),
+                Parameter(
+                    "step", Parameter.POSITIONAL_OR_KEYWORD, default=1, annotation=int
+                ),
+                Parameter(
+                    "_int", Parameter.POSITIONAL_OR_KEYWORD, default=int, annotation=int
+                ),
+            ],
+            return_annotation=int,
+        ),
+    )
+    register_contract(
+        random.Random.uniform,
+        post=lambda __return__, a, b: min(a, b) <= __return__ <= max(a, b),
+        sig=Signature(
+            parameters=[
+                Parameter("self", Parameter.POSITIONAL_OR_KEYWORD),
+                Parameter("a", Parameter.POSITIONAL_OR_KEYWORD, annotation=float),
+                Parameter("b", Parameter.POSITIONAL_OR_KEYWORD, annotation=float),
+            ],
+            return_annotation=float,
+        ),
+    )
+    register_contract(
+        random.Random.getrandbits,
+        pre=lambda k: k >= 0,
+        post=lambda __return__, k: 0 <= __return__ < 2**k,
+        sig=Signature(
+            parameters=[
+                Parameter("self", Parameter.POSITIONAL_OR_KEYWORD),
+                Parameter("k", Parameter.POSITIONAL_OR_KEYWORD, annotation=int),
+            ],
+            return_annotation=int,
+        ),
+    )

crosshair/libimpl/randomlib_test.py

@@ -0,0 +1,120 @@
+import copy
+import random
+
+import pytest
+
+from crosshair.core_and_libs import proxy_for_type, standalone_statespace
+from crosshair.libimpl.randomlib import ExplicitRandom
+from crosshair.statespace import CANNOT_CONFIRM, CONFIRMED, POST_FAIL, MessageType
+from crosshair.test_util import check_states
+from crosshair.tracers import ResumedTracing
+
+
+def test_ExplicitRandom():
+    rng = ExplicitRandom([1, 2])
+    assert rng.randrange(0, 10) == 1
+    assert rng.choice(["a", "b", "c"]) == "c"
+    assert rng.choice(["a", "b", "c"]) == "a"
+    assert rng.random() == 0.0
+    assert repr(rng) == "crosshair.libimpl.randomlib.ExplicitRandom([1, 2, 0, 0.0])"
+
+
+def test_ExplicitRandom_copy():
+    rng = ExplicitRandom([1, 2])
+    (rng2,) = copy.deepcopy([rng])
+    assert rng.randint(0, 5) == 1
+    assert rng2.randint(0, 5) == 1
+    assert rng.randint(0, 5) == 2
+    assert rng2.randint(0, 5) == 2
+
+
+def test_proxy_random():
+    with standalone_statespace as space:
+        rng = proxy_for_type(random.Random, "rng")
+        i = rng.randrange(5, 10)
+        with ResumedTracing():
+            assert space.is_possible(i == 5)
+            assert space.is_possible(i == 9)
+            assert not space.is_possible(i == 4)
+
+
+def test_global_randrange():
+    assert random.randrange(10, 20, 5) in (10, 15)  # confirm we've got the args right
+
+    def f():
+        """post: _ in (10, 15)"""
+        return random.randrange(10, 20, 5)
+
+    check_states(f, CONFIRMED)
+
+
+def test_global_randrange_only_upperbound():
+    assert random.randrange(2) in (0, 1)  # confirm we've got the args right
+
+    def f():
+        """post: _ in (0, 1)"""
+        return random.randrange(2)
+
+    check_states(f, CONFIRMED)
+
+
+@pytest.mark.demo
+def test_randrange():
+    def f():
+        """
+        Can random.randrange() produce the value at low end of the range?
+
+        NOTE: CrossHair's random generator can produce any possible valid
+        value.
+        The counterexample includes a monkey-patching context
+        manager that lets you reproduce the issue, e.g.:
+            with crosshair.patch_to_return({random.Random.randrange: [20]}):
+                f()
+
+        post: _ != 10
+        """
+        return random.randrange(10, 20)
+
+    check_states(f, POST_FAIL)
+
+
+@pytest.mark.demo
+def test_uniform():
+    assert 10.0 <= random.uniform(10, 20) <= 20.0  # confirm we've got the args right
+
+    def f():
+        """
+        Can random.uniform() produce the value at high end of the range?
+
+        NOTE: CrossHair's random generator can produce any possible valid
+        value.
+        The counterexample includes a monkey-patching context
+        manager that lets you reproduce the issue, e.g.:
+            with crosshair.patch_to_return({random.Random.uniform: [20.0]}):
+                f()
+
+        post: _ != 20.0
+        """
+        return random.uniform(10, 20)
+
+    check_states(f, POST_FAIL)
+
+
+def test_global_uniform_inverted_args():
+    assert -2.0 <= random.uniform(10, -2) <= 10.0  # confirm we've got the args right
+
+    def f():
+        """post: -2.0 <= _ <= 10.0"""
+        return random.uniform(10, -2)
+
+    check_states(f, CONFIRMED)
+
+
+def test_global_getrandbits():
+    assert 0 <= random.getrandbits(3) < 8
+
+    def f():
+        """post: 0<= _ < 8"""
+        return random.getrandbits(3)
+
+    check_states(f, CONFIRMED)