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

crosshair/main.py

@@ -36,7 +36,7 @@ from crosshair.core_and_libs import (
     installed_plugins,
     run_checkables,
 )
-from crosshair.diff_behavior import diff_behavior
+from crosshair.diff_behavior import ExceptionEquivalenceType, diff_behavior
 from crosshair.fnutil import (
     FUNCTIONINFO_DESCRIPTOR_TYPES,
     FunctionInfo,
@@ -60,9 +60,9 @@ from crosshair.path_cover import (
 from crosshair.path_search import OptimizationKind, path_search
 from crosshair.pure_importer import prefer_pure_python_imports
 from crosshair.register_contract import REGISTERED_CONTRACTS
-from crosshair.statespace import NotDeterministic
 from crosshair.util import (
     ErrorDuringImport,
+    NotDeterministic,
     add_to_pypath,
     debug,
     format_boundargs,
@@ -85,14 +85,6 @@ def analysis_kind(argstr: str) -> Sequence[AnalysisKind]:
         ret = [AnalysisKind[part.strip()] for part in argstr.split(",")]
     except KeyError:
         raise ValueError
-    if AnalysisKind.hypothesis in ret:
-        try:
-            import hypothesis
-
-            if hypothesis.__version_info__ < (6, 0, 0):
-                raise Exception("CrossHair requires hypothesis version >= 6.0.0")
-        except ImportError as e:
-            raise Exception("Unable to import the hypothesis library") from e
     return ret
 
 
@@ -273,6 +265,21 @@ def command_line_parser() -> argparse.ArgumentParser:
         type=str,
         help="second fully-qualified function to compare",
     )
+    diffbehavior_parser.add_argument(
+        "--exception_equivalence",
+        metavar="EXCEPTION_EQUIVALENCE",
+        type=ExceptionEquivalenceType,
+        default=ExceptionEquivalenceType.TYPE_AND_MESSAGE,
+        choices=ExceptionEquivalenceType.__members__.values(),
+        help=textwrap.dedent(
+            """\
+            Decide how to treat exceptions, while searching for a counter-example.
+            `ALL` treats all exceptions as equivalent,
+            `SAME_TYPE`, considers matches on the type.
+            `TYPE_AND_MESSAGE` matches for the same type and message.
+            """
+        ),
+    )
     cover_parser = subparsers.add_parser(
         "cover",
         formatter_class=argparse.RawTextHelpFormatter,
@@ -413,7 +420,6 @@ def command_line_parser() -> argparse.ArgumentParser:
                 PEP316     : check PEP316 contracts (docstring-based)
                 icontract  : check icontract contracts (decorator-based)
                 deal       : check deal contracts (decorator-based)
-                hypothesis : check hypothesis tests
             """
             ),
         )
@@ -442,7 +448,9 @@ def run_watch_loop(
             active_messages = {}
         else:
             time.sleep(0.1)
-            max_uninteresting_iterations *= 2
+            max_uninteresting_iterations = min(
+                max_uninteresting_iterations * 2, 100_000_000
+            )
         for curstats, messages in watcher.run_iteration(max_uninteresting_iterations):
             messages = [m for m in messages if m.state > MessageType.PRE_UNSAT]
             stats.update(curstats)
@@ -529,10 +537,10 @@ def messages_merged(
 _MOTD = [
     "Did I miss a counterexample? Let me know: https://github.com/pschanely/CrossHair/issues/new",
     "Help me be faster! Add to my benchmark suite: https://github.com/pschanely/crosshair-benchmark",
-    "Consider sharing your CrossHair experience on YouTube, Twitter, your blog, ... even TikTok.",
+    "Please consider sharing your CrossHair experience with others on social media.",
     "Questions? Ask at https://github.com/pschanely/CrossHair/discussions/new?category=q-a",
     "Consider signing up for CrossHair updates at https://pschanely.github.io",
-    # Use CrossHair? We'd like to reference your work here: ...
+    "Come say hello in the discord chat; we are friendly! https://discord.gg/rUeTaYTWbb",
 ]
 
 
@@ -688,10 +696,11 @@ def diffbehavior(
     (fn_name1, fn_name2) = (args.fn1, args.fn2)
     fn1 = checked_fn_load(fn_name1, stderr)
     fn2 = checked_fn_load(fn_name2, stderr)
+    exception_equivalence = args.exception_equivalence
     if fn1 is None or fn2 is None:
         return 2
     options.stats = Counter()
-    diffs = diff_behavior(fn1, fn2, options)
+    diffs = diff_behavior(fn1, fn2, options, exception_equivalence)
     debug("stats", options.stats)
     if isinstance(diffs, str):
         print(diffs, file=stderr)
@@ -765,9 +774,11 @@ def cover(
                 ctxfn,
                 options,
                 args.coverage_type,
-                arg_formatter=format_boundargs_as_dictionary
-                if example_output_format == ExampleOutputFormat.ARG_DICTIONARY
-                else format_boundargs,
+                arg_formatter=(
+                    format_boundargs_as_dictionary
+                    if example_output_format == ExampleOutputFormat.ARG_DICTIONARY
+                    else format_boundargs
+                ),
             )
         except NotDeterministic:
             print(
@@ -851,16 +862,24 @@ def check(
     if isinstance(entities, int):
         return entities
     full_options = DEFAULT_OPTIONS.overlay(report_verbose=False).overlay(options)
-    for entity in entities:
-        debug("Check ", getattr(entity, "__name__", str(entity)))
-        for message in run_checkables(analyze_any(entity, options)):
-            line = describe_message(message, full_options)
-            if line is None:
-                continue
-            stdout.write(line + "\n")
-            debug("Traceback for output message:\n", message.traceback)
-            if message.state > MessageType.PRE_UNSAT:
-                any_problems = True
+    checkables = [c for e in entities for c in analyze_any(e, options)]
+    if not checkables:
+        extra_help = ""
+        if full_options.analysis_kind == [AnalysisKind.asserts]:
+            extra_help = "\nHINT: Ensure that your functions to analyze lead with assert statements."
+        print(
+            "WARNING: Targets found, but contain no checkable functions." + extra_help,
+            file=stderr,
+        )
+
+    for message in run_checkables(checkables):
+        line = describe_message(message, full_options)
+        if line is None:
+            continue
+        stdout.write(line + "\n")
+        debug("Traceback for output message:\n", message.traceback)
+        if message.state > MessageType.PRE_UNSAT:
+            any_problems = True
     return 1 if any_problems else 0
 
 
@@ -936,6 +955,7 @@ def mypy_and_check(cmd_args: Optional[List[str]] = None) -> None:
         _mypy_out, mypy_err, mypy_ret = api.run(mypy_cmd_args)
         print(mypy_err, file=sys.stderr)
         if mypy_ret != 0:
+            print(_mypy_out, file=sys.stdout)
             sys.exit(mypy_ret)
     engage_auditwall()
     debug("Running crosshair with these args:", check_args)

crosshair/main_test.py

@@ -61,7 +61,12 @@ def call_check(
 def call_diffbehavior(fn1: str, fn2: str) -> Tuple[int, List[str]]:
     buf: io.StringIO = io.StringIO()
     errbuf: io.StringIO = io.StringIO()
-    retcode = diffbehavior(Namespace(fn1=fn1, fn2=fn2), DEFAULT_OPTIONS, buf, errbuf)
+    retcode = diffbehavior(
+        Namespace(fn1=fn1, fn2=fn2, exception_equivalence="type_and_message"),
+        DEFAULT_OPTIONS,
+        buf,
+        errbuf,
+    )
     lines = [
         ls for ls in buf.getvalue().split("\n") + errbuf.getvalue().split("\n") if ls
     ]
@@ -246,19 +251,28 @@ def test_no_args_prints_usage(root):
     assert re.search(r"^usage", out)
 
 
-def DISABLE_TODO_test_assert_mode_e2e(root):
+def test_assert_mode_e2e(root, capsys: pytest.CaptureFixture[str]):
     simplefs(root, ASSERT_BASED_FOO)
-    try:
-        sys.stdout = io.StringIO()
-        exitcode = unwalled_main(["check", root / "foo.py", "--analysis_kind=asserts"])
-    finally:
-        out = sys.stdout.getvalue()
-        sys.stdout = sys.__stdout__
-    assert exitcode == 1
+    exitcode = unwalled_main(["check", str(root / "foo.py"), "--analysis_kind=asserts"])
+    (out, err) = capsys.readouterr()
+    assert err == ""
     assert re.search(
-        r"foo.py\:8\: error\: AssertionError\:  when calling foofn\(x \= 100\)", out
+        r"foo.py\:8\: error\: AssertionError\:  when calling foofn\(100\)", out
     )
     assert len([ls for ls in out.split("\n") if ls]) == 1
+    assert exitcode == 1
+
+
+def test_assert_without_checkable(root, capsys: pytest.CaptureFixture[str]):
+    simplefs(root, SIMPLE_FOO)
+    exitcode = unwalled_main(["check", str(root / "foo.py"), "--analysis_kind=asserts"])
+    (out, err) = capsys.readouterr()
+    assert (
+        err
+        == "WARNING: Targets found, but contain no checkable functions.\nHINT: Ensure that your functions to analyze lead with assert statements.\n"
+    )
+    assert out == ""
+    assert exitcode == 0
 
 
 def test_directives(root):
@@ -359,6 +373,35 @@ def test_check_circular_with_guard(root):
         assert retcode == 0
 
 
+def test_check_not_deterministic(root) -> None:
+    NOT_DETERMINISTIC_FOO = {
+        "foo.py": """
+_GLOBAL_THING = [42]
+
+def wonky_foo(i: int) -> int:
+    '''post: True'''
+    _GLOBAL_THING[0] += 1
+    if i > _GLOBAL_THING[0]:
+        pass
+    return True
+_GLOBAL_THING = [True]
+
+def regular_foo(i: int) -> int:
+    '''post: True'''
+    return i
+"""
+    }
+    simplefs(root, NOT_DETERMINISTIC_FOO)
+    with add_to_pypath(root):
+        retcode, lines, errlines = call_check([str(root / "foo.py")])
+        assert errlines == []
+        assert (
+            "NotDeterministic: Found a different execution paths after making the same decisions"
+            in lines[0]
+        )
+        assert retcode == 1
+
+
 def test_watch(root):
     # Just to make sure nothing explodes
     simplefs(root, SIMPLE_FOO)
@@ -456,7 +499,7 @@ def test_main_as_subprocess(tmp_path: Path):
     # the testing process.
     simplefs(tmp_path, SIMPLE_FOO)
     completion = subprocess.run(
-        [sys.executable, "-m", "crosshair", "check", str(tmp_path)],
+        [sys.executable, "-Werror", "-m", "crosshair", "check", str(tmp_path)],
         stdin=subprocess.DEVNULL,
         capture_output=True,
         text=True,
@@ -468,7 +511,7 @@ def test_main_as_subprocess(tmp_path: Path):
 
 def test_mypycrosshair_command():
     example_file = join(
-        split(__file__)[0], "examples", "icontract", "bugs_detected", "wrong_sign.py"
+        split(__file__)[0], "examples", "PEP316", "bugs_detected", "showcase.py"
     )
     completion = subprocess.run(
         [
@@ -481,8 +524,10 @@ def test_mypycrosshair_command():
         capture_output=True,
         text=True,
     )
-    assert completion.stderr.strip() == ""
-    assert completion.returncode == 1
+    assert completion.stderr.strip() == "", f"stderr was '''{completion.stderr}'''"
+    if completion.returncode != 1:
+        print(completion.stdout)
+        assert False, f"Return code was {completion.returncode}"
 
 
 def test_describe_message():

crosshair/objectproxy.py

@@ -10,11 +10,36 @@ from crosshair.tracers import NoTracing
 # (which is BSD licenced)
 #
 
+_MISSING = object()
+
+
+def proxy_inplace_op(proxy, op, *args):
+    my_original_value = proxy._wrapped()
+    my_new_value = op(my_original_value, *args)
+    # We need to return our own identity if (and only if!) the underlying value does.
+    if my_new_value is my_original_value:
+        return proxy
+    else:
+        object.__setattr__(proxy, "_inner", my_new_value)
+        return my_new_value
+
 
 class ObjectProxy:
-    def _wrapped(self):
+    def _realize(self):
         raise NotImplementedError
 
+    def _wrapped(self):
+        with NoTracing():
+            inner = _MISSING
+            try:
+                inner = object.__getattribute__(self, "_inner")
+            except AttributeError:
+                pass
+            if inner is _MISSING:
+                inner = self._realize()
+                object.__setattr__(self, "_inner", inner)
+            return inner
+
     def __get_module__(self) -> str:
         return self._wrapped().__module__
 
@@ -233,40 +258,40 @@ class ObjectProxy:
         return other | self._wrapped()
 
     def __iadd__(self, other):
-        return operator.iadd(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.iadd, other)
 
     def __isub__(self, other):
-        return operator.isub(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.isub, other)
 
     def __imul__(self, other):
-        return operator.imul(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.imul, other)
 
     def __itruediv__(self, other):
-        return operator.itruediv(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.itruediv, other)
 
     def __ifloordiv__(self, other):
-        return operator.iflootdiv(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.ifloordiv, other)
 
     def __imod__(self, other):
-        return operator.imod(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.imod, other)
 
     def __ipow__(self, other, *args):
-        return operator.ipow(self._wrapped(), other, *args)
+        return proxy_inplace_op(self, operator.ipow, other, *args)
 
     def __ilshift__(self, other):
-        return operator.ilshift(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.ilshift, other)
 
     def __irshift__(self, other):
-        return operator.irshift(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.irshift, other)
 
     def __iand__(self, other):
-        return operator.iand(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.iand, other)
 
     def __ixor__(self, other):
-        return operator.ixor(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.ixor, other)
 
     def __ior__(self, other):
-        return operator.ior(self._wrapped(), other)
+        return proxy_inplace_op(self, operator.ior, other)
 
     def __neg__(self):
         return -self._wrapped()
@@ -335,7 +360,7 @@ class ObjectProxy:
         return copy.copy(self._wrapped())
 
     def __deepcopy__(self, memo):
-        ret = copy.deepcopy(self._wrapped())
+        ret = copy.deepcopy(self._wrapped(), memo)
         memo[id(self)] = ret
         return ret
 

crosshair/objectproxy_test.py

@@ -1,4 +1,4 @@
-import unittest
+import pytest
 
 from crosshair.objectproxy import ObjectProxy
 
@@ -7,21 +7,35 @@ class ObjectWrap(ObjectProxy):
     def __init__(self, obj):
         object.__setattr__(self, "_o", obj)
 
-    def _wrapped(self):
+    def _realize(self):
         return object.__getattribute__(self, "_o")
 
 
-class ObjectProxyTest(unittest.TestCase):
-    def test_object_proxy(self) -> None:
+class TestObjectProxy:
+    def test_object_proxy_over_list(self) -> None:
         i = [1, 2, 3]
         proxy = ObjectWrap(i)
-        self.assertEqual(i, proxy)
+        assert i == proxy
         proxy.append(4)
-        self.assertEqual([1, 2, 3, 4], proxy)
-        self.assertEqual([1, 2, 3, 4, 5], proxy + [5])
-        self.assertEqual([2, 3], proxy[1:3])
-        self.assertEqual([1, 2, 3, 4], proxy)
-
-
-if __name__ == "__main__":
-    unittest.main()
+        assert [1, 2, 3, 4] == proxy
+        assert [1, 2, 3, 4, 5] == proxy + [5]
+        assert [2, 3] == proxy[1:3]
+        assert [1, 2, 3, 4] == proxy
+
+    def test_inplace_identities(self) -> None:
+        proxy = ObjectWrap(3.0)
+        orig_proxy = proxy
+        proxy += 1.0
+        assert proxy is not orig_proxy
+        proxy = ObjectWrap([1, 2])
+        orig_proxy = proxy
+        proxy += [3, 4]
+        assert proxy is orig_proxy
+
+    def test_object_proxy_over_float(self) -> None:
+        proxy = ObjectWrap(4.5)
+        proxy //= 2.0
+        assert 2.0 == proxy
+        proxy = ObjectWrap(5.0)
+        proxy /= 2.0
+        assert 2.5 == proxy