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

crosshair/libimpl/builtinslib_ch_test.py

@@ -1,5 +1,6 @@
 import operator
 import sys
+from math import isnan
 from numbers import Integral
 from typing import (
     Any,
@@ -19,7 +20,7 @@ import pytest  # type: ignore
 
 from crosshair.core import realize
 from crosshair.core_and_libs import MessageType, analyze_function, run_checkables
-from crosshair.test_util import ResultComparison, compare_results
+from crosshair.test_util import ResultComparison, compare_results, compare_returns
 
 _TRICKY_UNICODE = (
     "A\u01f2",  # upper followed by title cased character
@@ -29,9 +30,9 @@ _TRICKY_UNICODE = (
 )
 
 
-def check_abs(x: float) -> ResultComparison:
+def check_abs(x: Union[int, bool, float]) -> ResultComparison:
     """post: _"""
-    return compare_results(abs, x)
+    return compare_returns(abs, x)
 
 
 def check_ascii(x: object) -> ResultComparison:
@@ -56,12 +57,21 @@ def check_chr(x: int) -> ResultComparison:
 
 # NOTE: dir() is not expected to be compatible.
 
+_NAN_SENTINAL: Tuple = tuple()
+# (anything that is copyable and compares equal with itself)
 
-def check_divmod(x: Union[int, float], y: Union[int, float]) -> ResultComparison:
+
+def check_divmod(
+    numerator: Union[int, float], denominator: Union[int, float]
+) -> ResultComparison:
     """post: _"""
-    if y == 0 or x == 0:
+    if numerator == 0 or denominator == 0:
         pass
-    return compare_results(divmod, x, y)
+    return compare_returns(
+        lambda n, d: [_NAN_SENTINAL if isnan(x) else x for x in divmod(n, d)],
+        numerator,
+        denominator,
+    )
 
 
 def check_eval(expr: str):
@@ -84,7 +94,12 @@ def check_eval(expr: str):
 def check_float(o: Union[str, int, float]) -> ResultComparison:
     """post: _"""
     # TODO this isn't hitting most of the branches we care about right now.
-    return compare_results(float, o)
+    return compare_returns(float, o)
+
+
+def check_float_sub(float_a: float, float_b: float) -> ResultComparison:
+    """post: _"""
+    return compare_returns(lambda a, b: a - b, float_a, float_b)
 
 
 def check_format(x: object, f: str) -> ResultComparison:
@@ -101,7 +116,7 @@ def check_format_dunder(obj: Union[int, float], fmt: str) -> ResultComparison:
         pass
     # TODO: do not realize `fmt` here- instead we should intercept the native
     # __format__ calls to check for a symbolic format string.
-    return compare_results(lambda o, f: o.__format__(f), obj, realize(fmt))
+    return compare_returns(lambda o, f: o.__format__(f), obj, realize(fmt))
 
 
 # CrossHair proxies don't have the same attributes as native:
@@ -113,7 +128,13 @@ def check_format_dunder(obj: Union[int, float], fmt: str) -> ResultComparison:
 # def check_hasattr(o: str, n: str) -> ResultComparison:
 
 
-def check_hash(o: Union[int, str]) -> ResultComparison:
+def check_hash(o: Union[int, str, bytes, tuple]) -> ResultComparison:
+    """post: _"""
+    return compare_results(hash, o)
+
+
+# We test frozenset explicitly because it's trickier:
+def check_frozenset_hash(o: frozenset) -> ResultComparison:
     """post: _"""
     return compare_results(hash, o)
 
@@ -132,7 +153,7 @@ def check_hex(o: int) -> ResultComparison:
 
 def check_int(o: Union[str, int, float]) -> ResultComparison:
     """post: _"""
-    return compare_results(int, o)
+    return compare_returns(int, o)
 
 
 def check_int_with_base(o: str, b: int) -> ResultComparison:
@@ -157,7 +178,7 @@ def check_iter(obj: Union[str, List[int], Dict[int, int]]) -> ResultComparison:
 
 
 def check_len(
-    s: Union[Dict[int, int], Tuple[int, ...], str, List[int], Set[int]]
+    s: Union[Dict[int, int], Tuple[int, ...], str, List[int], Set[int]],
 ) -> ResultComparison:
     """post: _"""
     return compare_results(len, s)
@@ -209,11 +230,20 @@ def check_print(o: object) -> ResultComparison:
     return compare_results(print, o)
 
 
-def check_pow(
+def check_pow_function(
     b: Union[int, float], e: Union[int, float], m: Optional[int]
 ) -> ResultComparison:
     """post: _"""
-    return compare_results(pow, b, e, m)
+    # crosshair: max_uninteresting_iterations=150
+    # (running this a little longer for various float representations)
+    return compare_returns(pow, b, e, m)
+
+
+def check_pow_operator(b: Union[int, float], e: Union[int, float]) -> ResultComparison:
+    """post: _"""
+    # crosshair: max_uninteresting_iterations=150
+    # (running this a little longer for various float representations)
+    return compare_returns(operator.pow, b, e)
 
 
 # NOTE: not testing quit()
@@ -243,7 +273,7 @@ def check_repr(o: object) -> ResultComparison:
 
 def check_round_float(o: float, d: Optional[int]) -> ResultComparison:
     """post: _"""
-    return compare_results(round, o, d)
+    return compare_returns(round, o, d)
 
 
 def check_round_int(o: int, d: Optional[int]) -> ResultComparison:
@@ -265,7 +295,7 @@ def check_sum(
     # i: Union[None, int, float]
 ) -> ResultComparison:
     """post: _"""
-    return compare_results(sum, s)
+    return compare_returns(sum, s)
 
 
 # NOTE: not testing vars()
@@ -320,6 +350,13 @@ def check_list_setitem_slice(container: List[int], key: slice, replacement: List
 # Check dict methods
 
 
+def check_dict___init__(
+    pos_args: List[Tuple[int, int]], kw_args: Dict[str, int]
+) -> ResultComparison:
+    """post: _"""
+    return compare_results(lambda a, kw: dict(*a, **kw), pos_args, kw_args)
+
+
 def check_dict_get(dictionary: Dict[int, int], key: int) -> ResultComparison:
     """post: _"""
     return compare_results(lambda d, k: d.get(k), dictionary, key)
@@ -454,7 +491,13 @@ def check_set_intersection(
 def check_set_compare(
     left: Union[Set[int], FrozenSet[int]], right: Union[Set[int], FrozenSet[int]]
 ) -> ResultComparison:
-    """post: _"""
+    """
+    pre: len(left) + len(right) <= 4
+    post: _
+    """
+    # crosshair: max_uninteresting_iterations=75
+    # (running this a little longer - it's been able to detect deepcopy memo
+    # keepalive issues in the past)
     return compare_results(lambda lt, r: lt <= r, left, right)
 
 
@@ -463,6 +506,11 @@ def check_set_bool(setobj: Union[Set[int], FrozenSet[int]]) -> ResultComparison:
     return compare_results(lambda s: s, bool(setobj))
 
 
+def check_seq_concat_and_slice(seq1: List[int], seq2: List[int], slc: slice):
+    """post: _"""
+    return compare_results(lambda s1, s2, c: (s1 + s2)[c], seq1, seq2, slc)
+
+
 # Check int methods
 
 
@@ -558,9 +606,14 @@ def check_str_endswith(
     string: str, suffix: str, start: Optional[int], end: Optional[int]
 ) -> ResultComparison:
     """post: _"""
+    # crosshair: max_uninteresting_iterations=100
+
+    for i in (len(string), len(suffix), start, end):
+        if i is not None and abs(i) >= 1:
+            pass
+
     return compare_results(
-        lambda s, *a: s.endswith(*a),
-        string,
+        lambda s, *a, **kw: s.endswith(*a, **kw), string, suffix, start, end
     )
 
 
@@ -777,6 +830,11 @@ def check_str_startswith(
     end: Optional[int],
 ) -> ResultComparison:
     """post: _"""
+    # crosshair: max_uninteresting_iterations=100
+
+    for i in (len(string), len(prefix), start, end):
+        if i is not None and abs(i) >= 1:
+            pass
     return compare_results(
         lambda s, *a, **kw: s.startswith(*a, **kw), string, prefix, start, end
     )
@@ -917,17 +975,32 @@ def check_buffer_add_return_type(container: Union[bytearray, memoryview]):
     return compare_results(lambda c: type(c + b"abc"), container)
 
 
-def check_buffer_constructions(
-    constructor_name: str, source: Union[int, List[int], bytes, bytearray, memoryview]
+def check_bytes___init__(source: Union[int, List[int], bytes, bytearray, memoryview]):
+    """
+    post: _
+    raises: KeyError
+    """
+    return compare_results(lambda c, s: c(s), bytes, source)
+
+
+def check_bytearray___init__(
+    source: Union[int, List[int], bytes, bytearray, memoryview],
 ):
     """
     post: _
     raises: KeyError
     """
-    constructor = {"bytes": bytes, "bytearray": bytearray, "memoryview": memoryview}[
-        constructor_name
-    ]
-    return compare_results(lambda c, s: c(s), constructor, source)
+    return compare_results(lambda c, s: c(s), bytearray, source)
+
+
+def check_memoryview___init__(
+    source: Union[int, List[int], bytes, bytearray, memoryview],
+):
+    """
+    post: _
+    raises: KeyError
+    """
+    return compare_results(lambda c, s: c(s), memoryview, source)
 
 
 def check_buffer_iter(container: Union[bytes, bytearray, memoryview]):
@@ -1005,9 +1078,14 @@ def check_and(left: int):
     return compare_results(lambda lt: (lt & 3, 4 & lt), left)
 
 
+def check_xor(left: Union[int, bool], right: Union[int, bool]):
+    """post: _"""
+    return compare_results(operator.xor, left, right)
+
+
 def check_truediv(left: Union[int, float], right: Union[int, float]):
     """post: _"""
-    return compare_results(operator.truediv, left, right)
+    return compare_returns(operator.truediv, left, right)
 
 
 def check_lt_strings(left: str, right: str):
@@ -1019,7 +1097,7 @@ def check_ge_numeric(
     left: Union[int, bool, float, complex], right: Union[int, bool, float, complex]
 ):
     """post: _"""
-    return compare_results(operator.ge, left, right)
+    return compare_returns(operator.ge, left, right)
 
 
 def check_mod(
@@ -1028,14 +1106,14 @@ def check_mod(
     """post: _"""
     if left == 0 or right == 0:
         pass
-    return compare_results(operator.mod, left, right)
+    return compare_returns(operator.mod, left, right)
 
 
 def check_floordiv(x: Union[int, float], y: Union[int, float]) -> ResultComparison:
     """post: _"""
     if y == 0 or x == 0:
         pass
-    return compare_results(operator.floordiv, x, y)
+    return compare_returns(operator.floordiv, x, y)
 
 
 def check_getitem(
@@ -1092,14 +1170,14 @@ def check_eq_atomic(
     left: Union[bool, int, float, str], right: Union[bool, int, float, str]
 ):
     """post: _"""
-    return compare_results(lambda a, b: a == b, left, right)
+    return compare_returns(lambda a, b: a == b, left, right)
 
 
 def check_trunc(num: Union[bool, int, float]):
     """post: _"""
     if num >= 0:
         pass
-    return compare_results(lambda n: n.__trunc__(), num)
+    return compare_returns(lambda n: n.__trunc__(), num)
 
 
 # This is the only real test definition.