crosshair-tool 0.0.99__cp312-cp312-macosx_10_13_x86_64.whl

crosshair/libimpl/iolib_test.py

@@ -0,0 +1,19 @@
+from io import StringIO
+
+import pytest
+
+from crosshair.core import deep_realize
+from crosshair.core_and_libs import standalone_statespace
+from crosshair.libimpl.iolib import BackedStringIO
+
+
+@pytest.mark.parametrize("nl", [None, "", "\n", "\r\n", "\r"])
+def test_StringIO_newlines(nl) -> None:
+    text = "CR\rCRNL\r\nNL\nEND"
+    concrete_input = StringIO(text, newline=nl)
+    concrete_output = concrete_input.readlines()
+    with standalone_statespace as space:
+        symbolic_input = BackedStringIO(text, newline=nl)
+        symbolic_output = deep_realize(symbolic_input.readlines())
+    print(nl, concrete_output)
+    assert symbolic_output == concrete_output

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.py

@@ -0,0 +1,44 @@
+import itertools as real_itertools
+import operator
+
+from crosshair import register_patch
+
+
+def identity(x):
+    return x
+
+
+def _accumulate(iterable, func=operator.add, **kw):
+    return real_itertools.accumulate(iterable, lambda a, b: func(a, b), **kw)
+
+
+def _dropwhile(predicate, iterable):
+    return real_itertools.dropwhile(lambda x: predicate(x), iterable)
+
+
+def _filterfalse(predicate, iterable):
+    return real_itertools.filterfalse(lambda x: predicate(x), iterable)
+
+
+def _groupby(iterable, key=identity):
+    if key is identity:
+        return real_itertools.groupby(iterable)
+    else:
+        return real_itertools.groupby(iterable, lambda x: key(x))
+
+
+def _starmap(function, iterable):
+    return real_itertools.starmap(lambda *a: function(*a), iterable)
+
+
+def _takewhile(predicate, iterable):
+    return real_itertools.takewhile(lambda x: predicate(x), iterable)
+
+
+def make_registrations():
+    register_patch(real_itertools.accumulate, _accumulate)
+    register_patch(real_itertools.dropwhile, _dropwhile)
+    register_patch(real_itertools.filterfalse, _filterfalse)
+    register_patch(real_itertools.groupby, _groupby)
+    register_patch(real_itertools.starmap, _starmap)
+    register_patch(real_itertools.takewhile, _takewhile)

crosshair/libimpl/itertoolslib_test.py

@@ -0,0 +1,44 @@
+import itertools
+from typing import List, Tuple
+
+import pytest
+
+from crosshair.core import proxy_for_type, standalone_statespace
+from crosshair.statespace import POST_FAIL, MessageType
+from crosshair.test_util import check_states
+from crosshair.tracers import NoTracing
+
+
+def test_keyfn_is_intercepted():
+    with standalone_statespace as space:
+        with NoTracing():
+            two = proxy_for_type(int, "two")
+        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,))]
+
+
+@pytest.mark.demo
+def test_accumulate():
+    def f(x: int) -> List[int]:
+        """
+        Does any list of the form [1, x, 3] accumulate to 10?
+
+        post: __return__[-1] != 10  # (false when x == 6)
+        """
+        return list(itertools.accumulate([1, x, 3]))
+
+    check_states(f, POST_FAIL)
+
+
+@pytest.mark.demo
+def test_product():
+    def f(n: int) -> List[Tuple[int, int]]:
+        """
+        Can 2 rolls of an n-sided die result in 2 and 3?
+
+        post: (2, 3) not in _
+        """
+        return list(itertools.product(range(1, n), range(1, n)))
+
+    check_states(f, POST_FAIL)