crosshair-tool 0.0.99__cp312-cp312-macosx_10_13_x86_64.whl

crosshair/libimpl/timelib.py

@@ -0,0 +1,72 @@
+import time as real_time
+from inspect import Signature
+from math import isfinite
+from typing import Any, Literal
+
+from crosshair.core import register_patch
+from crosshair.register_contract import register_contract
+from crosshair.statespace import context_statespace
+from crosshair.tracers import NoTracing
+
+
+class EarliestPossibleTime:
+    monotonic: float = 0.0
+    process_time: float = 0.0
+
+    def __init__(self, *a):
+        pass
+
+
+# Imprecision at high values becomes a sort of artificial problem
+_UNREALISTICALLY_LARGE_TIME_FLOAT = float(60 * 60 * 24 * 365 * 100_000)
+
+
+def _gte_last(kind: Literal["monotonic", "process_time"], value: Any) -> bool:
+    with NoTracing():
+        earliest_times = context_statespace().extra(EarliestPossibleTime)
+        threshold = getattr(earliest_times, kind)
+        setattr(earliest_times, kind, value)
+    return all([threshold <= value, value < _UNREALISTICALLY_LARGE_TIME_FLOAT])
+
+
+def _sleep(value: float) -> None:
+    with NoTracing():
+        earliest_times = context_statespace().extra(EarliestPossibleTime)
+    earliest_times.monotonic += value
+    return None
+
+
+def make_registrations():
+    register_contract(
+        real_time.time,
+        post=lambda __return__: __return__ > 0.0 and isfinite(__return__),
+        sig=Signature(parameters=[], return_annotation=float),
+    )
+    register_contract(
+        real_time.time_ns,
+        post=lambda __return__: __return__ > 0,
+        sig=Signature(parameters=[], return_annotation=int),
+    )
+    register_contract(
+        real_time.monotonic,
+        post=lambda __return__: _gte_last("monotonic", __return__)
+        and isfinite(__return__),
+        sig=Signature(parameters=[], return_annotation=float),
+    )
+    register_contract(
+        real_time.monotonic_ns,
+        post=lambda __return__: _gte_last("monotonic", __return__ / 1_000_000_000),
+        sig=Signature(parameters=[], return_annotation=int),
+    )
+    register_contract(
+        real_time.process_time,
+        post=lambda __return__: _gte_last("process_time", __return__)
+        and isfinite(__return__),
+        sig=Signature(parameters=[], return_annotation=float),
+    )
+    register_contract(
+        real_time.process_time_ns,
+        post=lambda __return__: _gte_last("process_time", __return__ / 1_000_000_000),
+        sig=Signature(parameters=[], return_annotation=int),
+    )
+    register_patch(real_time.sleep, _sleep)

crosshair/libimpl/timelib_test.py

@@ -0,0 +1,82 @@
+import time
+
+import pytest
+
+from crosshair.statespace import CANNOT_CONFIRM, CONFIRMED, POST_FAIL
+from crosshair.test_util import check_states
+
+
+@pytest.mark.demo
+def test_time():
+    def f():
+        """
+        Can time go backwards?
+
+        NOTE: CrossHair allows time() to produce ANY value.
+        Although highly unlikely, it's possible that the system clock
+        is set backwards while a program executes.
+        (BTW: use time.monotonic if you don't want it to go backwards!)
+
+        CrossHair's counterexample includes a monkey-patching context
+        manager that lets you reproduce the issue, e.g.:
+            with crosshair.patch_to_return({time.time: [2.0, 1.0]}):
+                f()
+
+        post: _ >= 0
+        """
+        start = time.time()
+        return time.time() - start
+
+    check_states(f, POST_FAIL)
+
+
+def test_time_ns():
+    def f():
+        """post: _ >= 0"""
+        start = time.time_ns()
+        return time.time_ns() - start
+
+    check_states(f, POST_FAIL)
+
+
+@pytest.mark.demo
+def test_monotonic():
+    def f():
+        """
+        Can time increase by one second between monotonic() calls?
+
+        post: _ != 1.0
+        """
+        start = time.monotonic()
+        end = time.monotonic()
+        return end - start
+
+    check_states(f, POST_FAIL)
+
+
+def test_monotonic_confirm():
+    def f():
+        """post: _ >= 0"""
+        start = time.monotonic()
+        return time.monotonic() - start
+
+    check_states(f, CONFIRMED)
+
+
+def test_monotonic_ns():
+    def f():
+        """post: _ >= 0"""
+        start = time.monotonic_ns()
+        return time.monotonic_ns() - start
+
+    check_states(f, CANNOT_CONFIRM)
+
+
+def test_sleep():
+    def f():
+        """post: _ >= 60.0"""
+        start = time.monotonic()
+        time.sleep(60.01)
+        return time.monotonic() - start
+
+    check_states(f, CANNOT_CONFIRM)

crosshair/libimpl/typeslib.py

@@ -0,0 +1,15 @@
+from types import MappingProxyType
+from typing import Any, Dict
+
+from crosshair.core import register_patch, register_type
+
+
+def _repr(map: MappingProxyType):
+    if not isinstance(map, MappingProxyType):
+        raise TypeError
+    return f"mappingproxy({repr(dict(map))})"
+
+
+def make_registrations():
+    register_type(MappingProxyType, lambda p, kt=Any, vt=Any: MappingProxyType(p(Dict[kt, vt])))  # type: ignore
+    register_patch(MappingProxyType.__repr__, _repr)

crosshair/libimpl/typeslib_test.py

@@ -0,0 +1,36 @@
+import sys
+from types import MappingProxyType
+from typing import Dict
+
+import pytest
+
+from crosshair import ResumedTracing
+from crosshair.core import deep_realize, proxy_for_type
+from crosshair.libimpl.builtinslib import SymbolicInt
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 9), reason="MappingProxyType not subscriptable in 3.8"
+)
+def test_mappingproxy_repr(space):
+    d = proxy_for_type(MappingProxyType[int, int], "d")
+    with ResumedTracing():
+        assert repr(d).startswith("mappingproxy(")
+
+
+def test_mappingproxy_deep_realize(space):
+    inner = proxy_for_type(Dict[int, int], "inner")
+    with ResumedTracing():
+        space.add(inner._inner.__len__() == 1)
+        key = next(iter(inner.keys()))
+    assert type(key) is SymbolicInt
+    orig = MappingProxyType(inner)
+    assert type(orig) is MappingProxyType
+    copy = deep_realize(orig)
+    assert type(copy) is MappingProxyType
+    with ResumedTracing():
+        val_from_orig = orig[key]
+        realized_key = deep_realize(key)
+    val_from_copy = copy[realized_key]
+    assert type(val_from_orig) is SymbolicInt
+    assert type(val_from_copy) is int

crosshair/libimpl/unicodedatalib.py

@@ -0,0 +1,75 @@
+import sys
+import unicodedata
+
+from crosshair.core import register_patch, with_realized_args
+from crosshair.libimpl.builtinslib import AnySymbolicStr, SymbolicInt
+from crosshair.statespace import context_statespace
+from crosshair.tracers import NoTracing
+from crosshair.unicode_categories import UnicodeMaskCache
+
+
+def _decimal(ch: str) -> float:
+    codepoint = ord(ch)
+    with NoTracing():
+        if not isinstance(ch, AnySymbolicStr):
+            return unicodedata.decimal(ch)
+        space = context_statespace()
+        smt_codepoint = SymbolicInt._coerce_to_smt_sort(codepoint)
+        cache = space.extra(UnicodeMaskCache)
+        if not space.smt_fork(cache.decimal_exists()(smt_codepoint)):
+            raise ValueError
+        return SymbolicInt(cache.decimal_int()(smt_codepoint))
+
+
+def _digit(ch: str) -> float:
+    codepoint = ord(ch)
+    with NoTracing():
+        if not isinstance(ch, AnySymbolicStr):
+            return unicodedata.digit(ch)
+        space = context_statespace()
+        smt_codepoint = SymbolicInt._coerce_to_smt_sort(codepoint)
+        cache = space.extra(UnicodeMaskCache)
+        if not space.smt_fork(cache.digit_exists()(smt_codepoint)):
+            raise ValueError
+        return SymbolicInt(cache.digit_int()(smt_codepoint))
+
+
+def _numeric(ch: str) -> float:
+    codepoint = ord(ch)
+    with NoTracing():
+        if not isinstance(ch, AnySymbolicStr):
+            return unicodedata.numeric(ch)
+        space = context_statespace()
+        smt_codepoint = SymbolicInt._coerce_to_smt_sort(codepoint)
+        cache = space.extra(UnicodeMaskCache)
+        if not space.smt_fork(cache.numeric_exists()(smt_codepoint)):
+            raise ValueError
+        numerator = SymbolicInt(cache.numeric_numerator()(smt_codepoint))
+        denominator = SymbolicInt(cache.numeric_denominator()(smt_codepoint))
+    return numerator / float(denominator)
+
+
+def make_registrations():
+    register_patch(unicodedata.lookup, with_realized_args(unicodedata.lookup))
+    register_patch(unicodedata.name, with_realized_args(unicodedata.name))
+    register_patch(unicodedata.decimal, _decimal)
+    register_patch(unicodedata.digit, _digit)
+    register_patch(unicodedata.numeric, _numeric)
+    # TOOD: implement this using get_unicode_categories() - should be easy:
+    register_patch(unicodedata.category, with_realized_args(unicodedata.category))
+    register_patch(
+        unicodedata.bidirectional, with_realized_args(unicodedata.bidirectional)
+    )
+    register_patch(unicodedata.combining, with_realized_args(unicodedata.combining))
+    register_patch(
+        unicodedata.east_asian_width, with_realized_args(unicodedata.east_asian_width)
+    )
+    register_patch(unicodedata.mirrored, with_realized_args(unicodedata.mirrored))
+    register_patch(
+        unicodedata.decomposition, with_realized_args(unicodedata.decomposition)
+    )
+    register_patch(unicodedata.normalize, with_realized_args(unicodedata.normalize))
+    if sys.version_info >= (3, 8):
+        register_patch(
+            unicodedata.is_normalized, with_realized_args(unicodedata.is_normalized)
+        )

crosshair/libimpl/unicodedatalib_test.py

@@ -0,0 +1,42 @@
+import unicodedata
+from typing import *
+
+import pytest
+
+from crosshair.core_and_libs import NoTracing, standalone_statespace
+from crosshair.libimpl.builtinslib import LazyIntSymbolicStr
+
+
+def test_numeric():
+    with standalone_statespace as space:
+        with NoTracing():
+            fourstr = LazyIntSymbolicStr(list(map(ord, "4")))
+            halfstr = LazyIntSymbolicStr(list(map(ord, "\u00bd")))  # (1/2 character)
+        four = unicodedata.numeric(fourstr)
+        half = unicodedata.numeric(halfstr)
+        assert type(four) is float
+        assert four == 4.0
+        assert half == 0.5
+
+
+def test_decimal():
+    with standalone_statespace as space:
+        with NoTracing():
+            thai4 = LazyIntSymbolicStr(list(map(ord, "\u0e54")))  # (Thai numerial 4)
+            super4 = LazyIntSymbolicStr(list(map(ord, "\u2074")))  # (superscript 4)
+        four = unicodedata.decimal(thai4)
+        assert type(four) is int
+        assert four == 4
+        with pytest.raises(ValueError):
+            unicodedata.decimal(super4)
+
+
+def test_digit():
+    with standalone_statespace as space:
+        with NoTracing():
+            thai4 = LazyIntSymbolicStr(list(map(ord, "\u0e54")))  # (Thai numerial 4)
+            super4 = LazyIntSymbolicStr(list(map(ord, "\u2074")))  # (superscript 4)
+        four = unicodedata.digit(thai4)
+        assert type(four) is int
+        assert four == 4
+        assert unicodedata.digit(super4) == 4

crosshair/libimpl/urlliblib.py

@@ -0,0 +1,23 @@
+import sys
+import urllib.parse
+
+
+class DevNullDict:
+    def get(self, k, default):
+        return default
+
+    def __setitem__(self, k, v):
+        pass
+
+    def __len__(self):
+        return 0
+
+
+def make_registrations():
+    # Avoid nondeterminism in urllib by disabling internal caching.
+    if sys.version_info < (3, 11):
+        # TODO: This is destructive! But not terribly harmful. Consider alternatives.
+        urllib.parse._parse_cache = DevNullDict()  # type: ignore
+    else:
+        # (3.11 uses functools.lru_cache, which we disable elsewhere)
+        assert not hasattr(urllib.parse, "_parse_cache")

crosshair/libimpl/urlliblib_test.py

@@ -0,0 +1,19 @@
+from urllib.parse import urlparse
+
+from crosshair.options import AnalysisOptionSet
+from crosshair.statespace import POST_FAIL, MessageType
+from crosshair.test_util import check_states
+
+
+def test_urllib_parse():
+    def f(urlstring: str):
+        """
+        pre: len(urlstring) == 3
+        pre: urlstring[0:2] == "//"
+        pre: urlstring[2] != "["
+        pre: urlstring[2] != "]"
+        post: __return__.netloc != "h"
+        """
+        return urlparse(urlstring)
+
+    check_states(f, POST_FAIL)

crosshair/libimpl/weakreflib.py

@@ -0,0 +1,13 @@
+from weakref import ref
+
+from crosshair.core import register_patch
+
+
+def _ref_call(r):
+    if not isinstance(r, ref):
+        raise TypeError
+    return None
+
+
+def make_registrations():
+    register_patch(ref.__call__, _ref_call)

crosshair/libimpl/weakreflib_test.py

@@ -0,0 +1,69 @@
+from weakref import WeakKeyDictionary, WeakSet, WeakValueDictionary, proxy, ref
+
+import pytest
+
+from crosshair.tracers import ResumedTracing
+
+
+class Thing:
+    x: int = 0
+
+
+def test_weakref(space):
+    thing1 = Thing()
+    assert ref(thing1)() is thing1
+    with ResumedTracing():
+        assert ref(thing1)() is None
+
+
+def test_weakref_WeakKeyDictionary(space):
+    d = WeakKeyDictionary()
+    thing1 = Thing()
+    thing2 = Thing()
+    d[thing1] = 1
+    d[thing2] = 2
+    assert len(d) == 2
+    assert thing1 in d
+    assert set(d.keys()) == {thing1, thing2}
+    with ResumedTracing():
+        assert set(d.keys()) == set()
+        # You would expect the following assertions to work too
+        # However, they don't require getting the referred object, so they appear to still exist:
+        # assert thing1 not in d
+        # assert len(d) == 0
+
+
+def test_weakref_WeakValueDictionary(space):
+    d = WeakValueDictionary()
+    thing1 = Thing()
+    thing2 = Thing()
+    d[1] = thing1
+    d[2] = thing2
+    assert len(d) == 2
+    assert 1 in d
+    assert set(d.keys()) == {1, 2}
+    with ResumedTracing():
+        assert set(d.keys()) == set()
+        assert 1 not in d
+        # You would expect the length to update too.
+        # However, it doesn't require getting the referred object, so it appears to still exist:
+        # assert len(d) == 0
+
+
+@pytest.mark.xfail(reason="weakref.WeakSet is not yet supported")
+def test_weakref_WeakSet(space):
+    s = WeakSet()
+    thing1 = Thing()
+    s.add(thing1)
+    assert thing1 in s
+    with ResumedTracing():
+        assert thing1 not in s
+
+
+@pytest.mark.xfail(reason="weakref.proxy is not yet supported")
+def test_weakref_proxy(space):
+    thing1 = Thing()
+    thing1.x
+    p = proxy(thing1)
+    with pytest.raises(ReferenceError), ResumedTracing():
+        p.x

crosshair/libimpl/zliblib.py

@@ -0,0 +1,15 @@
+import zlib
+
+from crosshair.core import register_patch, with_realized_args
+
+
+def make_registrations():
+    for fn in (
+        zlib.adler32,
+        zlib.compress,
+        zlib.crc32,
+        zlib.decompress,
+        type(zlib.compressobj()).compress,
+        type(zlib.decompressobj()).decompress,
+    ):
+        register_patch(fn, with_realized_args(fn))

crosshair/libimpl/zliblib_test.py

@@ -0,0 +1,13 @@
+import zlib
+
+from crosshair.core import proxy_for_type, realize
+from crosshair.tracers import ResumedTracing
+
+
+def test_compress_on_symbolic(space):
+    buffer = proxy_for_type(bytes, "buffer")
+    with ResumedTracing():
+        space.add(len(buffer) == 1)
+        result = zlib.compress(buffer)
+    realized_buffer = realize(buffer)
+    assert zlib.decompress(result) == realized_buffer