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

crosshair/statespace_test.py

@@ -1,15 +1,20 @@
 import time
 
+import pytest
 import z3  # type: ignore
 
+from crosshair.core import Patched, proxy_for_type
 from crosshair.statespace import (
     HeapRef,
     RootNode,
     SimpleStateSpace,
     SnapshotRef,
     StateSpace,
+    StateSpaceContext,
     model_value_to_python,
 )
+from crosshair.tracers import COMPOSITE_TRACER
+from crosshair.util import UnknownSatisfiability
 
 _HEAD_SNAPSHOT = SnapshotRef(-1)
 
@@ -27,6 +32,21 @@ def test_find_key_in_heap():
     assert isinstance(dictval, dict)
 
 
+def test_timeout() -> None:
+    num_ints = 100
+    space = StateSpace(time.monotonic() + 60_000, 0.1, RootNode())
+    with pytest.raises(UnknownSatisfiability):
+        with Patched(), StateSpaceContext(space), COMPOSITE_TRACER:
+            ints = [proxy_for_type(int, f"i{i}") for i in range(num_ints)]
+            for i in range(num_ints - 2):
+                t0 = time.monotonic()
+                if ints[i] * ints[i + 1] == ints[i + 2]:
+                    pass
+                ints[i + 1] += ints[i]
+    solve_time = time.monotonic() - t0
+    assert 0.05 < solve_time < 0.5
+
+
 def test_infinite_timeout() -> None:
     space = StateSpace(time.monotonic() + 1000, float("+inf"), RootNode())
     assert space.solver.check(True) == z3.sat
@@ -61,3 +81,28 @@ def test_model_value_to_python_AlgebraicNumRef():
     rt2 = z3.simplify(z3.Sqrt(2))
     assert type(rt2) == z3.AlgebraicNumRef
     model_value_to_python(rt2)
+
+
+def test_model_value_to_python_ArithRef():
+    # Tests that a plain z3.ArithRef can be exported as Python
+    # See https://github.com/pschanely/CrossHair/issues/381
+    rt2 = z3.ToInt(2 ** z3.Int("x"))
+    print("type(rt2)", type(rt2))
+    assert type(rt2) == z3.ArithRef
+    model_value_to_python(rt2)
+
+
+def test_smt_fanout(space: SimpleStateSpace):
+    option1 = z3.Bool("option1")
+    option2 = z3.Bool("option2")
+    space.add(z3.Xor(option1, option2))  # Ensure exactly one option can be set
+    exprs_and_results = [(option1, "result1"), (option2, "result2")]
+
+    result = space.smt_fanout(exprs_and_results, desc="choose_one")
+    assert result in ("result1", "result2")
+    if result == "result1":
+        assert space.is_possible(option1)
+        assert not space.is_possible(option2)
+    else:
+        assert not space.is_possible(option1)
+        assert space.is_possible(option2)

crosshair/stubs_parser.py

@@ -22,8 +22,6 @@ def signature_from_stubs(fn: Callable) -> Tuple[List[Signature], bool]:
     """
     Try to find signature(s) for the given function in the stubs.
 
-    Note: this feature is only available for Python >= 3.8.
-
     For overloaded functions, all signatures found will be returned.
 
     :param fn: The function to lookup a signature for.

crosshair/test_util.py

@@ -2,7 +2,20 @@ import pathlib
 import sys
 from copy import deepcopy
 from dataclasses import dataclass, replace
-from typing import Callable, Iterable, List, Mapping, Optional, Sequence, Set, Tuple
+from decimal import Decimal
+from math import isnan
+from numbers import Real
+from typing import (
+    Callable,
+    Collection,
+    Iterable,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+)
 
 from crosshair.core import (
     AnalysisMessage,
@@ -14,21 +27,27 @@ from crosshair.core import (
 )
 from crosshair.options import AnalysisOptionSet
 from crosshair.statespace import context_statespace
-from crosshair.tracers import NoTracing, is_tracing
+from crosshair.tracers import NoTracing, ResumedTracing
 from crosshair.util import (
-    IgnoreAttempt,
-    UnexploredPath,
+    assert_tracing,
+    ch_stack,
     debug,
     in_debug,
+    is_iterable,
     is_pure_python,
     name_of_type,
-    test_stack,
-    true_type,
 )
 
 ComparableLists = Tuple[List, List]
 
 
+class _Missing:
+    pass
+
+
+_MISSING = _Missing()
+
+
 def simplefs(path: pathlib.Path, files: dict) -> None:
     for name, contents in files.items():
         subpath = path / name
@@ -54,8 +73,8 @@ def check_states(
         )
     elif expected == MessageType.CONFIRMED:
         local_opts = AnalysisOptionSet(
-            per_condition_timeout=10,
-            per_path_timeout=5,
+            per_condition_timeout=60,
+            per_path_timeout=20,
             max_uninteresting_iterations=sys.maxsize,
         )
     elif expected == MessageType.POST_ERR:
@@ -123,9 +142,40 @@ def check_messages(checkables: Iterable[Checkable], **kw) -> ComparableLists:
     return (msgs, [AnalysisMessage(**kw)])
 
 
-def nan_equal(a, b):
-    if a != a and b != b:  # handle float('nan')
+_NAN_ABLE = (Decimal, Real)
+
+
+def flexible_equal(a: object, b: object) -> bool:
+    if a is b:
         return True
+    if type(a) is type(b) and type(a).__eq__ is object.__eq__:
+        # If types match and it uses identity-equals, we can't do much. Assume equal.
+        return True
+    if isinstance(a, _NAN_ABLE) and isinstance(b, _NAN_ABLE) and isnan(a) and isnan(b):
+        return True
+    if (
+        is_iterable(a)
+        and not isinstance(a, Collection)
+        and is_iterable(b)
+        and not isinstance(b, Collection)
+    ):  # unsized iterables compare by contents
+        a, b = list(a), list(b)  # type: ignore
+    if (
+        type(a) == type(b)
+        and isinstance(a, Collection)
+        and not isinstance(a, (str, bytes, Set))
+    ):
+        # Recursively apply flexible_equal for most containers:
+        if len(a) != len(b):  # type: ignore
+            return False
+        if isinstance(a, Mapping):
+            for k, v in a.items():
+                if not flexible_equal(v, b.get(k, _MISSING)):  # type: ignore
+                    return False
+            return True
+        else:
+            return all(flexible_equal(ai, bi) for ai, bi in zip(a, b))  # type: ignore
+
     return a == b
 
 
@@ -133,6 +183,7 @@ def nan_equal(a, b):
 class ExecutionResult:
     ret: object  # return value
     exc: Optional[BaseException]  # exception raised, if any
+    tb: Optional[str]
     # args after the function terminates:
     post_args: Sequence
     post_kwargs: Mapping[str, object]
@@ -141,7 +192,7 @@ class ExecutionResult:
         if not isinstance(other, ExecutionResult):
             return False
         return (
-            nan_equal(self.ret, other.ret)
+            flexible_equal(self.ret, other.ret)
             and type(self.exc) == type(other.exc)
             and self.post_args == other.post_args
             and self.post_kwargs == other.post_kwargs
@@ -152,7 +203,7 @@ class ExecutionResult:
         if self.exc:
             exc = self.exc
             exc_type = name_of_type(type(exc))
-            tb = test_stack(exc.__traceback__)
+            tb = self.tb or "(missing traceback)"
             ret = f"exc={exc_type}: {str(exc)} {tb}"
         else:
             ret = f"ret={self.ret!r}"
@@ -178,7 +229,8 @@ def summarize_execution(
     if not kwargs:
         kwargs = {}
     ret: object = None
-    exc = None
+    exc: Optional[Exception] = None
+    tbstr: Optional[str] = None
     try:
         possibly_symbolic_ret = fn(*args, **kwargs)
         if detach_path:
@@ -199,13 +251,14 @@ def summarize_execution(
     except Exception as e:
         exc = e
         if detach_path:
-            context_statespace().detach_path()
+            context_statespace().detach_path(e)
         exc = deep_realize(exc)
         # NOTE: deep_realize somehow empties the __traceback__ member; re-assign it:
         exc.__traceback__ = e.__traceback__
+        tbstr = ch_stack(currently_handling=exc)
         if in_debug():
-            debug("hit exception:", type(exc), exc, test_stack(exc.__traceback__))
-    return ExecutionResult(ret, exc, args, kwargs)
+            debug("hit exception:", type(exc), exc, tbstr)
+    return ExecutionResult(ret, exc, tbstr, args, kwargs)
 
 
 @dataclass
@@ -235,8 +288,8 @@ def compare_returns(fn: Callable, *a: object, **kw: object) -> ResultComparison:
     return comparison
 
 
+@assert_tracing(True)
 def compare_results(fn: Callable, *a: object, **kw: object) -> ResultComparison:
-    assert is_tracing()
     original_a = deepcopy(a)
     original_kw = deepcopy(kw)
     symbolic_result = summarize_execution(fn, a, kw)
@@ -245,16 +298,25 @@ def compare_results(fn: Callable, *a: object, **kw: object) -> ResultComparison:
     concrete_kw = deep_realize(original_kw)
 
     # Check that realization worked, too:
-    for idx, arg in enumerate(concrete_a):
-        if true_type(arg) != type(arg):
+    with NoTracing():
+        labels_and_args = [
+            *(
+                (f"Argument {idx + 1}", a[idx], arg)
+                for idx, arg in enumerate(concrete_a)
+            ),
+            *((f"Keyword argument '{k}'", kw[k], v) for k, v in concrete_kw.items()),
+        ]
+        for label, symbolic_arg, concrete_arg in labels_and_args:
+            with ResumedTracing():
+                symbolic_type = type(symbolic_arg)
+                concrete_type = type(concrete_arg)
+            true_concrete_type = type(concrete_arg)
             assert (
-                False
-            ), f"Argument {idx + 1} was {true_type(arg)} afer realization; expected {type(arg)}"
-    for k, v in concrete_kw.items():
-        if true_type(v) != type(v):
+                true_concrete_type == concrete_type
+            ), f"{label} did not realize. It is {true_concrete_type} instead of {concrete_type}."
             assert (
-                False
-            ), f"Keyword argument '{k}' was {true_type(v)} afer realization; expected {type(arg)}"
+                true_concrete_type == symbolic_type
+            ), f"{label} should realize to {symbolic_type}; it is {true_concrete_type} instead."
 
     with NoTracing():
         concrete_result = summarize_execution(

crosshair/test_util_test.py

@@ -0,0 +1,26 @@
+from crosshair.test_util import flexible_equal
+
+
+def test_flexible_equal():
+    assert float("nan") != float("nan")
+    assert flexible_equal(float("nan"), float("nan"))
+    assert flexible_equal((42, float("nan")), (42, float("nan")))
+    assert not flexible_equal([float("nan"), 11], [float("nan"), 22])
+
+    def gen():
+        yield 11
+        yield 22
+
+    assert flexible_equal(gen(), iter([11, 22]))
+    assert not flexible_equal(gen(), iter([11, 22, 33]))
+    assert not flexible_equal(gen(), iter([11]))
+
+    ordered_set_1 = {10_000, 20_000} | {30_000}
+    ordered_set_2 = {30_000, 20_000} | {10_000}
+    assert list(ordered_set_1) != list(ordered_set_2)  # (different orderings)
+    assert flexible_equal(ordered_set_1, ordered_set_2)
+
+    ordered_dict_1 = {1: 2, 3: 4}
+    ordered_dict_2 = {3: 4, 1: 2}
+    assert list(ordered_dict_1.items()) != list(ordered_dict_2.items())
+    assert flexible_equal(ordered_dict_1, ordered_dict_2)

crosshair/tools/check_init_and_setup_coincide.py

@@ -1,13 +1,10 @@
 #!/usr/bin/env python3
 
 """Check that the distribution and crosshair/__init__.py are in sync."""
-import email
 import subprocess
 import sys
 from typing import Dict, Optional
 
-import pkg_resources
-
 import crosshair
 
 

crosshair/tools/generate_demo_table.py

@@ -107,7 +107,7 @@ def divide_stdlib_module(
     modulename: str, items: list[tuple[str, str, str]]
 ) -> dict[str, list[tuple[str, str, str]]]:
     ret = defaultdict(list)
-    for (name, color, src) in items:
+    for name, color, src in items:
         if name.endswith("_method"):
             name = name.removesuffix("_method")
             (classname, methodname) = name.split("_", 1)
@@ -120,7 +120,7 @@ def divide_stdlib_module(
 
 
 stdlib = {}
-for (modulename, items) in stdlib_demos().items():
+for modulename, items in stdlib_demos().items():
     stdlib[modulename] = divide_stdlib_module(modulename, items)