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

crosshair/patch_equivalence_test.py

@@ -1,6 +1,8 @@
 import copy
 import itertools
+import operator
 import re
+import sys
 from dataclasses import dataclass
 from typing import Callable, List, Mapping, Optional, Sequence, Tuple
 
@@ -9,7 +11,7 @@ import pytest  # type: ignore
 from crosshair.core import _PATCH_REGISTRATIONS
 from crosshair.core_and_libs import standalone_statespace
 from crosshair.test_util import ExecutionResult, summarize_execution
-from crosshair.util import debug, test_stack
+from crosshair.util import ch_stack, debug
 
 """
 Tests that the builtin and standard library patches behave like their
@@ -38,6 +40,7 @@ possible_args = [
     (42, int),  # isinstance
     (re.compile("(ab|a|b)"), r"\n", ""),  # re methods
     (bool, [1, 1, 0]),  # itertools.takewhile and friends
+    (operator.add, [1, 0], [1, 1]),  # multi-iterable map
     ([(1, 2), (3, 4)]),  # key-value pairs
     ([(1, 2), ([], 4)]),  # key-value pairs w/ unhashable key
 ]
@@ -56,22 +59,6 @@ for native_fn, patched_fn in _PATCH_REGISTRATIONS.items():
     )
 
 
-@dataclass(init=False)
-class ExecutionResultWithTb:
-    ret: object  # return value
-    exc: Optional[BaseException]
-    tb: Optional[str]
-    post_args: Sequence
-    post_kwargs: Mapping[str, object]
-
-    def __init__(self, result: ExecutionResult):
-        self.ret = result.ret
-        self.exc = result.exc
-        self.tb = test_stack(self.exc.__traceback__) if self.exc else None
-        self.post_args = result.post_args
-        self.post_kwargs = result.post_kwargs
-
-
 @pytest.mark.parametrize("native_fn,patched_fn", comparisons)
 @pytest.mark.parametrize(
     "args", possible_args, ids=lambda t: re.sub(r"[\W_]", "_", str(t))
@@ -85,7 +72,4 @@ def test_patch(native_fn: Callable, patched_fn: Callable, args: Sequence[object]
     with standalone_statespace:
         patched_result = summarize_execution(patched_fn, args2, {}, detach_path=False)
     debug("Patched result: ", patched_result)
-    if native_result != patched_result:
-        assert ExecutionResultWithTb(native_result) == ExecutionResultWithTb(
-            patched_result
-        )
+    assert native_result == patched_result

crosshair/path_cover.py

@@ -26,10 +26,10 @@ from crosshair.tracers import (
 )
 from crosshair.util import (
     ReferencedIdentifier,
+    ch_stack,
     debug,
     format_boundargs,
     name_of_type,
-    test_stack,
 )
 
 
@@ -95,9 +95,7 @@ def path_cover(
             cov = coverage.get_results(fn)
             debug("Realized args:", formatted_pre_args)
             if exc is not None:
-                debug(
-                    "user-level exception found", type(exc), exc, test_stack(exc_stack)
-                )
+                debug("user-level exception found", type(exc), exc, ch_stack(exc_stack))
                 exc_message = realize(str(exc)) if len(exc.args) > 0 else None
                 paths.append(
                     PathSummary(
@@ -135,7 +133,11 @@ def path_cover(
     selected: List[PathSummary] = []
     while paths:
         next_best = max(
-            paths, key=lambda p: len(p.coverage.offsets_covered - opcodes_found)
+            paths,
+            key=lambda p: (
+                len(p.coverage.offsets_covered - opcodes_found),  # high coverage
+                -len(p.formatted_args),  # with small input size
+            ),
         )
         cur_offsets = next_best.coverage.offsets_covered
         if coverage_type == CoverageType.OPCODE:

crosshair/path_search.py

@@ -12,15 +12,17 @@ from crosshair.options import AnalysisOptions
 from crosshair.statespace import RootNode, StateSpace, context_statespace
 from crosshair.tracers import CoverageResult, NoTracing, ResumedTracing
 from crosshair.util import (
-    CrosshairInternal,
+    CrossHairInternal,
+    ch_stack,
     debug,
     format_boundargs_as_dictionary,
-    test_stack,
 )
 
 
 class OptimizationKind(enum.Enum):
     SIMPLIFY = "SIMPLIFY"
+    # TODO: simplify mode is quite dumb atm; partly because eval_friendly_format
+    # realizes prior to generating the string.
     NONE = "NONE"
     MINIMIZE_INT = "MINIMIZE_INT"
 
@@ -57,7 +59,7 @@ def path_search(
             try:
                 return argument_formatter(args)
             except Exception as exc:
-                raise CrosshairInternal(str(exc)) from exc
+                raise CrossHairInternal(str(exc)) from exc
 
     if optimization_kind == OptimizationKind.SIMPLIFY:
         assert optimize_fn is None
@@ -99,7 +101,7 @@ def path_search(
                     "Aborting path, hit exception",
                     type(exc),
                     exc,
-                    test_stack(exc_stack),
+                    ch_stack(exc_stack),
                 )
                 return False
             debug("Path succeeded")

crosshair/path_search_test.py

@@ -34,8 +34,7 @@ def do_path_search(
 
 
 def test_optimize_options() -> None:
-    fninfo = FunctionInfo.from_fn(ten_over_difference)
-    opts = DEFAULT_OPTIONS
+    opts = DEFAULT_OPTIONS.overlay(AnalysisOptionSet(max_uninteresting_iterations=10))
     ret = do_path_search(
         ten_over_difference, opts, None, optimization_kind=OptimizationKind.SIMPLIFY
     )

crosshair/pathing_oracle.py

@@ -6,13 +6,16 @@ from z3 import ExprRef  # type: ignore
 
 from crosshair.statespace import (
     AbstractPathingOracle,
+    DetachedPathNode,
     ModelValueNode,
     NodeLike,
     RootNode,
     SearchTreeNode,
+    StateSpace,
     WorstResultNode,
 )
-from crosshair.util import CrosshairInternal, debug, in_debug
+from crosshair.util import CrossHairInternal, debug, in_debug
+from crosshair.z3util import z3And, z3Not, z3Or
 
 CodeLoc = Tuple[str, ...]
 
@@ -54,9 +57,13 @@ class CoveragePathingOracle(AbstractPathingOracle):
             {},
         )
 
+    # TODO: This falls apart for moderately sized with_equal_probabilities
+    # because that has many small probability decisions.
+    # (even just a 10% change could be much larger than it would be otherwise)
     _delta_probabilities = {-1: 0.1, 0: 0.25, 1: 0.9}
 
-    def pre_path_hook(self, root: RootNode) -> None:
+    def pre_path_hook(self, space: StateSpace) -> None:
+        root = space._root
         visits = self.visits
         _delta_probabilities = self._delta_probabilities
 
@@ -110,15 +117,17 @@ class CoveragePathingOracle(AbstractPathingOracle):
     def post_path_hook(self, path: Sequence[SearchTreeNode]) -> None:
         leading_locs = []
         leading_conditions: List[int] = []
-        for step, node in enumerate(path):
+        for step, node in enumerate(path[:-1]):
             if not isinstance(node, NodeLike):
                 continue
-            node = node.simplify()  # type: ignore
             if isinstance(node, WorstResultNode):
                 key = node.stacktail
                 if (key not in leading_locs) and (not isinstance(node, ModelValueNode)):
                     self.summarized_positions[key] += Counter(leading_conditions)
                 leading_locs.append(key)
+                next_node = path[step + 1]
+                if isinstance(next_node, DetachedPathNode):
+                    break
                 if step + 1 < len(path):
                     (is_positive, root_expr) = node.normalized_expr
                     expr_signature = (
@@ -126,13 +135,13 @@ class CoveragePathingOracle(AbstractPathingOracle):
                         if is_positive
                         else -self.internalize(root_expr)
                     )
-                    if path[step + 1].simplify() == node.positive.simplify():
+                    if next_node == node.positive:
                         leading_conditions.append(expr_signature)
-                    elif path[step + 1].simplify() == node.negative.simplify():
+                    elif next_node == node.negative:
                         leading_conditions.append(-expr_signature)
                     else:
-                        raise CrosshairInternal(
-                            f"{type(path[step])}{type(path[step+1])}"
+                        raise CrossHairInternal(
+                            f"{type(path[step])} was followed by {type(path[step+1])}"
                         )
         visits = self.visits
         prev_len = len(visits)
@@ -207,16 +216,50 @@ class PreferNegativeOracle(AbstractPathingOracle):
         return 0.25
 
 
+class ConstrainedOracle(AbstractPathingOracle):
+    """
+    A pathing oracle that prefers to take a path that satisfies
+    explicitly provided constraints.
+    """
+
+    def __init__(self, inner_oracle: AbstractPathingOracle):
+        self.inner_oracle = inner_oracle
+        self.exprs: List[ExprRef] = []
+
+    def prefer(self, expr: ExprRef):
+        self.exprs.append(expr)
+
+    def pre_path_hook(self, space: StateSpace) -> None:
+        self.space = space
+        self.exprs = []
+        self.inner_oracle.pre_path_hook(space)
+
+    def post_path_hook(self, path: Sequence["SearchTreeNode"]) -> None:
+        self.inner_oracle.post_path_hook(path)
+
+    def decide(
+        self, root, node: "WorstResultNode", engine_probability: Optional[float]
+    ) -> float:
+        # We always run the inner oracle in case it's tracking something about the path.
+        default_probability = self.inner_oracle.decide(root, node, engine_probability)
+        if not self.space.is_possible(z3And(*[node.expr, *self.exprs])):
+            return 0.0
+        elif not self.space.is_possible(z3And(*[z3Not(node.expr), *self.exprs])):
+            return 1.0
+        else:
+            return default_probability
+
+
 class RotatingOracle(AbstractPathingOracle):
     def __init__(self, oracles: List[AbstractPathingOracle]):
         self.oracles = oracles
         self.index = -1
 
-    def pre_path_hook(self, root: "RootNode") -> None:
+    def pre_path_hook(self, space: StateSpace) -> None:
         oracles = self.oracles
         self.index = (self.index + 1) % len(oracles)
         for oracle in oracles:
-            oracle.pre_path_hook(root)
+            oracle.pre_path_hook(space)
 
     def post_path_hook(self, path: Sequence["SearchTreeNode"]) -> None:
         for oracle in self.oracles:

crosshair/pathing_oracle_test.py

@@ -0,0 +1,21 @@
+import random
+
+import z3  # type: ignore
+
+from crosshair.pathing_oracle import ConstrainedOracle, PreferNegativeOracle
+from crosshair.statespace import RootNode, SimpleStateSpace, WorstResultNode
+
+
+def test_constrained_oracle():
+    oracle = ConstrainedOracle(PreferNegativeOracle())
+    x = z3.Int("x")
+    root = RootNode()
+    space = SimpleStateSpace()
+    oracle.pre_path_hook(space)
+    oracle.prefer(x >= 7)
+    rand = random.Random()
+    assert oracle.decide(root, WorstResultNode(rand, x < 7, space.solver), None) == 0.0
+    assert oracle.decide(root, WorstResultNode(rand, x >= 3, space.solver), None) == 1.0
+    assert (
+        oracle.decide(root, WorstResultNode(rand, x == 7, space.solver), None) == 0.25
+    )

crosshair/pure_importer_test.py

@@ -7,26 +7,10 @@ import pytest
 from crosshair.pure_importer import prefer_pure_python_imports
 
 
-@contextmanager
-def _pydantic_unloaded():
-    saved = {}
-    for k in list(sys.modules):
-        if k.startswith("pydantic"):
-            saved[k] = sys.modules.pop(k)
-    try:
-        yield
-    finally:
-        sys.modules.update(saved)
-
-
-@pytest.mark.skipif(
-    sys.version_info >= (3, 10), reason="no compiled pydantic on 3.10 (yet)"
+@pytest.mark.skip(
+    reason="We used to test pydantic here, but current version doesn't use Cython"
 )
 def test_prefer_pure_python_imports():
-    pydantic = importlib.import_module("pydantic")
-    assert pydantic.compiled
-
-    with _pydantic_unloaded():
-        with prefer_pure_python_imports():
-            pydantic = importlib.import_module("pydantic")
-            assert not pydantic.compiled
+    with prefer_pure_python_imports():
+        pydantic = importlib.import_module("pydantic")
+        assert not pydantic.compiled

crosshair/register_contract.py

@@ -1,8 +1,9 @@
 """API for registering contracts for external libraries."""
+
 from dataclasses import dataclass
 from inspect import Parameter, Signature, getmodule, ismethod, signature
 from types import MethodDescriptorType, ModuleType, WrapperDescriptorType
-from typing import Callable, Dict, List, Optional, Set, Union
+from typing import Callable, Dict, FrozenSet, List, Optional, Set, Union
 from weakref import ReferenceType
 
 from crosshair.fnutil import resolve_signature
@@ -27,11 +28,13 @@ REGISTERED_CONTRACTS: Dict[Callable, ContractOverride] = {}
 REGISTERED_MODULES: Set[ModuleType] = set()
 
 # Don't automatically register those functions.
-_NO_AUTO_REGISTER: Set[str] = {
-    "__init__",
-    "__init_subclass__",
-    "__new__",
-}
+_NO_AUTO_REGISTER: FrozenSet[str] = frozenset(
+    {
+        "__init__",
+        "__init_subclass__",
+        "__new__",
+    }
+)
 
 
 def required_param_names(sig: Signature) -> Set[str]:
@@ -200,6 +203,13 @@ def register_contract(
     return _internal_register_contract(fn, pre, post, sig, skip_body)
 
 
+def clear_contract_registrations():
+    global REGISTERED_CONTRACTS
+    REGISTERED_CONTRACTS.clear()
+    global REGISTERED_MODULES
+    REGISTERED_MODULES.clear()
+
+
 def get_contract(fn: Callable) -> Optional[ContractOverride]:
     """
     Get the contract associated to the given function, it the function was registered.

crosshair/register_contract_test.py

@@ -63,16 +63,6 @@ def test_register_randint():
         return randint(x, 10)
 
     randint_sig = None
-    # Stub parser is not available for python < 3.8.
-    if sys.version_info < (3, 8):
-        randint_sig = Signature(
-            parameters=[
-                Parameter("self", Parameter.POSITIONAL_OR_KEYWORD, annotation=Random),
-                Parameter("a", Parameter.POSITIONAL_OR_KEYWORD, annotation=int),
-                Parameter("b", Parameter.POSITIONAL_OR_KEYWORD, annotation=int),
-            ],
-            return_annotation=int,
-        )
     register_contract(
         Random.randint,
         pre=lambda a, b: a <= b,
@@ -109,12 +99,10 @@ def test_register_numpy_randint():
 
 def test_register_overload():
     @overload
-    def overld(a: int) -> int:
-        ...
+    def overld(a: int) -> int: ...
 
     @overload
-    def overld(a: str) -> str:
-        ...
+    def overld(a: str) -> str: ...
 
     def overld(a: Union[int, str]) -> Union[int, str]:
         if isinstance(a, int):