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

@@ -8,8 +8,8 @@ import math
 import operator
 import re
 import sys
-import unittest
 from abc import ABC, abstractmethod
+from array import array
 from numbers import Integral
 from typing import (
     Callable,
@@ -32,14 +32,15 @@ from typing import (
     Type,
     TypeVar,
     Union,
+    get_type_hints,
 )
+from unittest.mock import patch
 
 import pytest
 import z3  # type: ignore
 
 from crosshair import type_repo
 from crosshair.core import (
-    CrossHairValue,
     analyze_function,
     deep_realize,
     proxy_for_type,
@@ -47,13 +48,16 @@ from crosshair.core import (
     standalone_statespace,
 )
 from crosshair.core_and_libs import run_checkables
+from crosshair.dynamic_typing import origin_of
 from crosshair.libimpl.builtinslib import (
     LazyIntSymbolicStr,
+    ModelingDirector,
+    PreciseIeeeSymbolicFloat,
+    RealBasedSymbolicFloat,
     SymbolicArrayBasedUniformTuple,
     SymbolicBool,
     SymbolicByteArray,
     SymbolicBytes,
-    SymbolicFloat,
     SymbolicInt,
     SymbolicList,
     SymbolicObject,
@@ -66,9 +70,9 @@ from crosshair.statespace import (
     CANNOT_CONFIRM,
     CONFIRMED,
     EXEC_ERR,
-    POST_ERR,
     POST_FAIL,
     MessageType,
+    StateSpace,
 )
 from crosshair.test_util import (
     check_exec_err,
@@ -77,7 +81,12 @@ from crosshair.test_util import (
     summarize_execution,
 )
 from crosshair.tracers import NoTracing, ResumedTracing
-from crosshair.util import CrosshairInternal, IgnoreAttempt, set_debug
+from crosshair.util import (
+    CrossHairInternal,
+    CrossHairValue,
+    IgnoreAttempt,
+    UnknownSatisfiability,
+)
 
 
 class Cat:
@@ -140,14 +149,14 @@ NAN = float("nan")
 
 
 def test_crosshair_types_for_python_type() -> None:
-    assert crosshair_types_for_python_type(int) == (SymbolicInt,)
+    assert crosshair_types_for_python_type(int) == ((SymbolicInt, 1.0),)
     assert crosshair_types_for_python_type(SmokeDetector) == ()
 
 
 def test_isinstance():
     with standalone_statespace:
         with NoTracing():
-            f = SymbolicFloat("f")
+            f = RealBasedSymbolicFloat("f")
         assert isinstance(f, float)
         assert not isinstance(f, int)
 
@@ -155,7 +164,7 @@ def test_isinstance():
 def test_smtfloat_like_a_float():
     with standalone_statespace:
         with NoTracing():
-            f1 = SymbolicFloat("f")
+            f1 = RealBasedSymbolicFloat("f")
         f2 = type(f1)(12)
         with NoTracing():
             assert isinstance(f2, float)
@@ -228,7 +237,7 @@ def test_number_simple_compare_ok() -> None:
     check_states(f, CONFIRMED)
 
 
-def test_number_promotion_compare_unknown() -> None:
+def test_number_promotion_compare_ok() -> None:
     def f(i: int, f: float) -> bool:
         """
         pre: i == 7
@@ -237,7 +246,7 @@ def test_number_promotion_compare_unknown() -> None:
         """
         return i == f and f >= i and i >= f
 
-    check_states(f, CANNOT_CONFIRM)
+    check_states(f, CONFIRMED)
 
 
 def test_numeric_promotions() -> None:
@@ -258,7 +267,7 @@ def test_float_as_bool() -> None:
         """
         return x or y
 
-    check_states(f, CANNOT_CONFIRM)
+    check_states(f, CONFIRMED)
 
 
 def test_int_reverse_operators() -> None:
@@ -272,6 +281,35 @@ def test_int_reverse_operators() -> None:
     check_states(f, POST_FAIL)
 
 
+def test_int_constant_bounds_tracking(space: StateSpace) -> None:
+    x = proxy_for_type(int, "x")
+    with patch(
+        "crosshair.statespace.StateSpace.choose_possible", return_value=False
+    ) as mock_solver:
+        with ResumedTracing():
+            assert mock_solver.call_count == 0
+            if x < 5:
+                assert False, "Should be unreachable"
+            assert mock_solver.call_count == 1
+            if x < 4:
+                assert False, "Should be unreachable"
+            assert mock_solver.call_count == 1
+            if x > 20:
+                assert False, "Should be unreachable"
+            assert mock_solver.call_count == 2
+            neg_x = -x
+            if neg_x < -30:
+                assert False, "Should be unreachable"
+            assert mock_solver.call_count == 2
+            abs_neg_x = abs(neg_x)
+    with ResumedTracing():
+        assert space.is_possible(neg_x == -5)
+        assert not space.is_possible(neg_x == -4)
+        assert space.is_possible(abs_neg_x == 5)
+        assert not space.is_possible(abs_neg_x == 21)
+        assert not space.is_possible(abs_neg_x != x)
+
+
 @pytest.mark.demo
 def test_int___add___method():
     def f(a: int, b: int) -> int:
@@ -335,6 +373,29 @@ def test_int___pow___method():
     check_states(f, POST_FAIL)
 
 
+def test_int___pow___to_ieee_float():
+    with standalone_statespace as space:
+        with NoTracing():
+            space.extra(ModelingDirector).global_representations[
+                float
+            ] = PreciseIeeeSymbolicFloat
+            a = SymbolicInt("a")
+        with pytest.raises(UnknownSatisfiability):
+            sqrt_a = a**0.5
+
+
+def test_int___pow___to_real_based_float():
+    with standalone_statespace as space:
+        with NoTracing():
+            space.extra(ModelingDirector).global_representations[
+                float
+            ] = RealBasedSymbolicFloat
+            a = SymbolicInt("a")
+        sqrt_a = a**0.5
+        with pytest.raises(UnknownSatisfiability):
+            realize(sqrt_a == 3)
+
+
 @pytest.mark.demo
 def test_int___sub___method():
     def f(a: int) -> int:
@@ -424,6 +485,7 @@ def test_int___truediv___method() -> None:
 def test_trunc_fail() -> None:
     def f(n: float) -> int:
         """
+        pre: math.isfinite(n)
         pre: n > 100
         post: _ < n
         """
@@ -459,11 +521,11 @@ def test_round_fail() -> None:
 def test_round_unknown() -> None:
     def f(num: float, ndigits: Optional[int]) -> float:
         """
+        pre: math.isfinite(num)
         post: isinstance(_, int) == (ndigits is None)
         """
         return round(num, ndigits)
 
-    # TODO: this is unknown (rounding reals is hard)
     check_states(f, CANNOT_CONFIRM)
 
 
@@ -472,7 +534,7 @@ def test_float_isinstance() -> None:
         """post: isinstance(_, float)"""
         return x
 
-    check_states(f, CANNOT_CONFIRM)
+    check_states(f, CONFIRMED)
 
 
 def test_mismatched_types() -> None:
@@ -509,15 +571,20 @@ def test_float_from_hex() -> None:
     check_states(f, CONFIRMED)
 
 
-def test_int_from_bytes() -> None:
-    def f(byt: bytes) -> int:
-        """
-        pre: len(byt) == 2
-        post: _ != 5
-        """
-        return int.from_bytes(byt, byteorder="little")
+def test_int_from_byte_iterator(space) -> None:
+    byts = proxy_for_type(bytes, "byts")
+    with ResumedTracing():
+        space.add(len(byts) == 2)
+        number = int.from_bytes(iter(byts), byteorder="little")
+        assert space.is_possible(number == 5)
 
-    check_states(f, POST_FAIL)
+
+def test_int_from_bytes(space) -> None:
+    byts = proxy_for_type(bytes, "byts")
+    with ResumedTracing():
+        space.add(len(byts) == 2)
+        number = int.from_bytes(byts, byteorder="little")
+        assert space.is_possible(number == 5)
 
 
 def test_int_nonlinear() -> None:
@@ -566,19 +633,22 @@ def test_bool_ops(b, op):
     with standalone_statespace as space:
         with NoTracing():
             a = SymbolicBool("a")
-            space.add(a.var)
+        space.add(a)
         symbolic_ret = summarize_execution(lambda: op(a, b))
         concrete_ret = summarize_execution(lambda: op(realize(a), b), detach_path=False)
         assert symbolic_ret == concrete_ret
 
 
 @pytest.mark.parametrize("b", (False, 1, -2.0, NAN, INF, -INF))
-@pytest.mark.parametrize("op", (operator.lt, operator.eq, operator.add, operator.mul))
+@pytest.mark.parametrize(
+    "op",
+    (operator.lt, operator.eq, operator.add, operator.mul, operator.eq, operator.ne),
+)
 def test_float_ops(b, op):
     with standalone_statespace as space:
         with NoTracing():
-            a = SymbolicFloat("a")
-            space.add(a.var < 0)
+            a = space.extra(ModelingDirector).choose(float)("a")
+        space.add(a < 0)
         symbolic_ret = summarize_execution(lambda: op(a, b))
         concrete_ret = summarize_execution(lambda: op(realize(a), b), detach_path=False)
         assert symbolic_ret == concrete_ret
@@ -595,6 +665,26 @@ def test_int_from_str():
     check_states(f, POST_FAIL)
 
 
+def test_int_from_str_with_bases(space):
+    i = proxy_for_type(int, "i")
+    s_11 = proxy_for_type(str, "s_11")
+    s_a = proxy_for_type(str, "s_a")
+    with ResumedTracing():
+        space.add(len(s_11) == 2)
+        space.add(s_11 == "11")
+        space.add(len(s_a) == 1)
+        space.add(s_a == "a")
+        assert int(s_11, 4) == 5
+        assert int(s_11, 16) == 17
+        assert int(s_11, 36) == 37
+        assert int(s_11, 0) == 11
+        assert int(s_a, 16) == 10
+        with pytest.raises(TypeError):
+            assert int(s_a, base=2.5)
+        with pytest.raises(TypeError):
+            int(i, base="foo")
+
+
 def test_easy_float_from_str():
     def f(a: str) -> float:
         """
@@ -618,15 +708,31 @@ def test_float_from_three_digit_str():
                 proxy_for_type(int, "xat1"),
                 proxy_for_type(int, "xat2"),
             ]
-            for point in codepoints:
-                space.add(point.var >= ord("0"))
-                space.add(point.var <= ord("9"))
             x = LazyIntSymbolicStr(codepoints)
+        for point in codepoints:
+            space.add(point >= ord("0"))
+            space.add(point <= ord("9"))
         asfloat = float(x)
-        assert space.is_possible(asfloat.var <= 999)
-        assert not space.is_possible(asfloat.var > 999)
-        assert space.is_possible(asfloat.var == 0)  # (because "000" is a valid float)
-        assert not space.is_possible(asfloat.var == 500.5)
+        assert space.is_possible(asfloat <= 999)
+        assert not space.is_possible(asfloat > 999)
+        assert space.is_possible(asfloat == 0)  # (because "000" is a valid float)
+        assert not space.is_possible(asfloat == 500.5)
+
+
+@pytest.mark.demo("yellow")
+def test_float___pow___operator():
+    def f(a: float) -> float:
+        """
+        Can the given float, cubed, equal 0.125?
+
+        NOTE: Although this example works, nonlinear arithmetic is quite difficult
+        to reason about in most cases.
+
+        post: _ != 0.125
+        """
+        return a**3
+
+    check_states(f, POST_FAIL)
 
 
 def test_int_bitwise_find_negative_input():
@@ -644,7 +750,7 @@ def test_int_bitwise_find_negative_input():
 def test_int_bit_length(val):
     with standalone_statespace as space:
         x = proxy_for_type(int, "x")
-        space.add(x.var == val)
+        space.add(x == val)
         assert realize(x.bit_length()) == val.bit_length()
 
 
@@ -654,7 +760,7 @@ def test_int_bit_length(val):
 def test_int_to_bytes(val):
     with standalone_statespace as space:
         x = proxy_for_type(int, "x")
-        space.add(x.var == val)
+        space.add(x == val)
         assert realize(x.to_bytes(2, "big", signed=True)) == val.to_bytes(
             2, "big", signed=True
         )
@@ -664,7 +770,7 @@ def test_int_format():
     with standalone_statespace as space:
         with NoTracing():
             x = SymbolicInt("x")
-            space.add(x.var == 42)
+        space.add(x == 42)
         assert x.__format__("") == "42"
         # TODO this fails:
         # assert x.__format__("f") == "42.000000"
@@ -863,6 +969,31 @@ def test_str_replace_method() -> None:
     check_states(f, POST_FAIL)
 
 
+def test_str_startswith(space) -> None:
+    symbolic_char = proxy_for_type(str, "x")
+    symbolic_empty = proxy_for_type(str, "y")
+    with ResumedTracing():
+        space.add(len(symbolic_char) == 1)
+        space.add(len(symbolic_empty) == 0)
+        assert symbolic_char.startswith(symbolic_empty)
+        assert symbolic_char.startswith(symbolic_char)
+        assert symbolic_char.startswith(("foo", symbolic_empty))
+        assert not symbolic_char.startswith(("foo", "bar"))
+        assert symbolic_char.startswith(("", "bar"))
+        assert symbolic_char.startswith("")
+        assert symbolic_char.startswith(symbolic_empty, 1)
+        assert symbolic_char.startswith(symbolic_empty, 1, 1)
+        assert str.startswith(symbolic_char, symbolic_empty)
+        assert "foo".startswith(symbolic_empty)
+        assert not "".startswith(symbolic_char)
+
+        # Yes, the empty string is findable off the left side but not the right
+        assert "x".startswith("", -10, -9)
+        assert symbolic_char.startswith(symbolic_empty, -10, -9)
+        assert not "x".startswith("", 9, 10)
+        assert not symbolic_char.startswith(symbolic_empty, 9, 10)
+
+
 @pytest.mark.demo
 def test_str_index_method() -> None:
     def f(a: str) -> int:
@@ -1164,18 +1295,17 @@ def test_str_center():
     with standalone_statespace as space:
         with NoTracing():
             string = LazyIntSymbolicStr("string")
-            space.add(string.__len__().var == 3)
             fillch = LazyIntSymbolicStr("fillch")
-            space.add(fillch.__len__().var == 1)
             sz = SymbolicInt("sz")
-            space.add(sz.var > 5)
             sz6 = SymbolicInt("sz6")
-            space.add(sz6.var == 6)
+        space.add(string.__len__() == 3)
+        space.add(fillch.__len__() == 1)
+        space.add(sz > 5)
+        space.add(sz6 == 6)
         assert "boo".center(sz6) == " boo  "
         symbolic_centered = "boo".center(sz, fillch)
         starts_with_nonfill = ord(symbolic_centered[0]) != ord(fillch)
-        with NoTracing():
-            assert not space.is_possible(starts_with_nonfill.var)
+        assert not space.is_possible(starts_with_nonfill)
 
 
 def test_str_map_chars() -> None:
@@ -1201,12 +1331,12 @@ def test_str___add___method() -> None:
 def test_str_bool():
     with standalone_statespace as space, NoTracing():
         a = LazyIntSymbolicStr("a")
-        space.add(a.__len__().var > 0)
         with ResumedTracing():
+            space.add(a.__len__() > 0)
             assert bool(a)
-        # Can we retain our symbolic state after forcing a positive truthiness?:
-        assert space.is_possible((a == "this").var)
-        assert space.is_possible((a == "that").var)
+            # Can we retain our symbolic state after forcing a positive truthiness?:
+            assert space.is_possible(a == "this")
+            assert space.is_possible(a == "that")
 
 
 def test_str_eq():
@@ -1234,9 +1364,9 @@ def test_str_filter_with_none():
         string = LazyIntSymbolicStr([ord("a")])
         truthyint = proxy_for_type(int, "truthyint")
         falseyint = proxy_for_type(int, "falseyint")
-        space.add(truthyint.var == 10)
-        space.add(falseyint.var == 0)
         with ResumedTracing():
+            space.add(truthyint == 10)
+            space.add(falseyint == 0)
             ret = deep_realize(list(filter(None, [falseyint, 42, 0, truthyint])))
         assert ret == [42, 10]
 
@@ -1268,20 +1398,18 @@ def test_str_format_basic():
     with standalone_statespace as space:
         with NoTracing():
             s = LazyIntSymbolicStr("s")
-            space.add(s.__len__().var == 1)
-        assert space.is_possible((s == "z").var)
-        assert space.is_possible((ord("a{0}c".format(s)[1]) == ord("b")).var)
+        space.add(s.__len__() == 1)
+        assert space.is_possible(s == "z")
+        assert space.is_possible(ord("a{0}c".format(s)[1]) == ord("b"))
 
 
 def test_str_format_map():
     with standalone_statespace as space:
         with NoTracing():
             s = LazyIntSymbolicStr("s")
-            space.add(s.__len__().var == 1)
-        assert space.is_possible((s == "z").var)
-        assert space.is_possible(
-            (ord("a{foo}c".format_map({"foo": s})[1]) == ord("b")).var
-        )
+        space.add(s.__len__() == 1)
+        assert space.is_possible(s == "z")
+        assert space.is_possible(ord("a{foo}c".format_map({"foo": s})[1]) == ord("b"))
 
 
 def test_str_rfind() -> None:
@@ -1352,7 +1480,7 @@ def test_str_lower():
 
 
 def test_str_title():
-    chr_lj = "\u01C9"  # "lj"
+    chr_lj = "\u01c9"  # "lj"
     chr_Lj = "\u01c8"  # "Lj" (different from "LJ", "\u01c7")
     with standalone_statespace:
         with NoTracing():
@@ -1427,11 +1555,20 @@ def test_tuple___len___method():
 def test_tuple___repr__symbolic_in_concrete(space) -> None:
     x = proxy_for_type(int, "x")
     with ResumedTracing():
-        space.add(x.var == 4)  # type: ignore
+        space.add(x == 4)  # type: ignore
         container = (x, x)
         assert repr(container) == "(4, 4)"
 
 
+def test_tuple___repr__symbolic_in_concrete_namedtuple(space) -> None:
+    NamedTupleClass = collections.namedtuple("NamedTupleClass", ["target"])
+    x = proxy_for_type(int, "x")
+    with ResumedTracing():
+        space.add(x == 4)  # type: ignore
+        container = NamedTupleClass(target=x)
+        assert repr(container) == "NamedTupleClass(target=4)"
+
+
 def test_tuple_range_intersection_fail() -> None:
     def f(a: Tuple[int, int], b: Tuple[int, int]) -> Optional[Tuple[int, int]]:
         """
@@ -1486,6 +1623,13 @@ def test_tuple_runtime_type() -> None:
     check_states(f, POST_FAIL)
 
 
+def test_empty_tuple(space) -> None:
+    t = proxy_for_type(Tuple[()], "t")
+    with ResumedTracing():
+        assert type(t) is tuple
+        assert t == ()
+
+
 def test_tuple_isinstance_check() -> None:
     def f(uniform_tuple: Tuple[List, ...], basic_tuple: tuple) -> Tuple[bool, bool]:
         """post: _ == (True, True)"""
@@ -1523,11 +1667,11 @@ def test_range_slicing(space) -> None:
     # Repeat this with a symbolic range:
     rng = proxy_for_type(range, "rng")
     newstart = proxy_for_type(int, "newstart")
-    space.add(rng.start.var == 3)  # type: ignore
-    space.add(rng.stop.var == 40)  # type: ignore
-    space.add(rng.step.var == 2)  # type: ignore
-    space.add(newstart.var == 5)  # type: ignore
     with ResumedTracing():
+        space.add(rng.start == 3)  # type: ignore
+        space.add(rng.stop == 40)  # type: ignore
+        space.add(rng.step == 2)  # type: ignore
+        space.add(newstart == 5)  # type: ignore
         assert list(rng[newstart::-1]) == [13, 11, 9, 7, 5, 3]
 
 
@@ -1583,7 +1727,7 @@ def test_list___add___method() -> None:
 def test_list___repr___symbolic_in_concrete(space) -> None:
     x = proxy_for_type(int, "x")
     with ResumedTracing():
-        space.add(x.var == 4)  # type: ignore
+        space.add(x == 4)  # type: ignore
         continer = [x]
         assert f"{continer=}" == "continer=[4]"
 
@@ -1971,8 +2115,8 @@ def test_list_shallow_realization():
     with standalone_statespace as space:
         nums = proxy_for_type(List[int], "nums")
         numslen = len(nums)
+        space.add(numslen == 1)
         with NoTracing():
-            space.add(numslen.var == 1)
             realized = realize(nums)
             assert type(realized) is list
             assert len(realized) == 1
@@ -1981,15 +2125,16 @@ def test_list_shallow_realization():
 
 def test_list_concrete_with_symbolic_slice(space):
     idx = proxy_for_type(int, "i")
-    space.add(1 <= idx.var)
-    space.add(idx.var <= 3)
     with ResumedTracing():
+        space.add(1 <= idx)
+        space.add(idx <= 3)
         prefix = [0, 1, 2, 3][:idx]
         prefixlen = len(prefix)
     assert isinstance(prefix, CrossHairValue)
     assert isinstance(prefixlen, CrossHairValue)
-    assert space.is_possible(prefixlen.var == 1)
-    assert space.is_possible(prefixlen.var == 3)
+    with ResumedTracing():
+        assert space.is_possible(prefixlen == 1)
+        assert space.is_possible(prefixlen == 3)
 
 
 def test_list_copy(space):
@@ -2006,6 +2151,7 @@ def test_list_copy_compare_without_forking(space):
     lst = proxy_for_type(List[int], "lst")
     with ResumedTracing():
         lst2 = copy.deepcopy(lst)
+    assert lst.inner is not lst2.inner
     assert type(lst2) is SymbolicList
     assert lst.inner.var is lst2.inner.var
     with ResumedTracing():
@@ -2025,7 +2171,7 @@ def test_dict___bool___ok() -> None:
     check_states(f, CONFIRMED)
 
 
-def test_dict___iter__() -> None:
+def test_dict___iter___fail() -> None:
     def f(a: Dict[int, str]) -> List[int]:
         """
         post[a]: 5 in _
@@ -2051,7 +2197,7 @@ def test_dict___iter___ok() -> None:
 def test_dict___or___method():
     with standalone_statespace as space:
         d = proxy_for_type(Dict[int, int], "d")
-        space.add(len(d).var == 0)
+        space.add(len(d) == 0)
         with pytest.raises(TypeError):
             d | set()
         if sys.version_info >= (3, 9):
@@ -2148,10 +2294,17 @@ def test_dict___getitem___implicit_conversion_for_keys_fail() -> None:
     check_states(f, POST_FAIL)
 
 
+def test_dict__items__works_with_symbolic_self(space) -> None:
+    x = proxy_for_type(Dict[int, int], "x")
+    with ResumedTracing():
+        x[42] = 42
+        assert (42, 42) in list(dict.items(x))
+
+
 def test_dict___repr___symbolic_in_concrete(space) -> None:
     x = proxy_for_type(int, "x")
     with ResumedTracing():
-        space.add(x.var == 4)  # type: ignore
+        space.add(x == 4)  # type: ignore
         container = {x: x}
         assert repr(container) == "{4: 4}"
 
@@ -2276,6 +2429,14 @@ def test_dict_construction_from_generator(space):
         assert d == {1: 2, 3: 4}
 
 
+def test_dict_construction_copies_dict(space):
+    with ResumedTracing():
+        source = {1: 2, 3: 4}
+        copy = dict(source)
+        source[5] = 6
+        assert copy == {1: 2, 3: 4}
+
+
 def test_dict_construction_with_duplicate_keys(space):
     with ResumedTracing():
         d = dict([(1, 2), (3, 4), (1, 10), (5, 6), (3, 10)])
@@ -2485,6 +2646,7 @@ def test_dict_alternate_mapping_types() -> None:
 def test_dict_untyped_access():
     def f(d: dict, k: int) -> dict:
         """
+        pre: len(d) == 2  # (just to bound the search space a little)
         pre: 42 in d
         post: 42 in __return__
         raises: KeyError
@@ -2492,11 +2654,7 @@ def test_dict_untyped_access():
         del d[k]
         return d
 
-    # TODO: profile / optimize
-    check_states(
-        f,
-        MessageType.POST_FAIL,
-    )
+    check_states(f, MessageType.POST_FAIL)
 
 
 # NOTE: TypedDict appeared earlier than 3.9, but was not runtime-detectable until then
@@ -2521,6 +2679,7 @@ if sys.version_info >= (3, 9):
 def test_set_basic_fail() -> None:
     def f(a: Set[int], k: int) -> None:
         """
+        pre: len(a) <= 2
         post[a]: k+1 in a
         """
         a.add(k)
@@ -2621,6 +2780,16 @@ def test_set_isinstance_check() -> None:
     check_states(f, CONFIRMED)
 
 
+def test_frozenset___eq__(space):
+    fs = proxy_for_type(Set[FrozenSet[int]], "fs")
+    with ResumedTracing():
+        space.add(len(fs) == 1)
+        space.add(len(next(iter(fs))) == 0)
+        linearset = set([frozenset()])
+        iseq = realize(fs == linearset)
+    assert iseq is True
+
+
 def test_set___eq__() -> None:
     def f(a: Set[FrozenSet[int]]) -> object:
         """
@@ -2639,7 +2808,7 @@ def test_set___eq__() -> None:
 def test_frozenset___repr__symbolic_in_concrete(space) -> None:
     x = proxy_for_type(int, "x")
     with ResumedTracing():
-        space.add(x.var == 4)  # type: ignore
+        space.add(x == 4)  # type: ignore
         container = frozenset([x])
         assert repr(container) == "frozenset({4})"
 
@@ -2647,11 +2816,20 @@ def test_frozenset___repr__symbolic_in_concrete(space) -> None:
 def test_set___repr__symbolic_in_concrete(space) -> None:
     x = proxy_for_type(int, "x")
     with ResumedTracing():
-        space.add(x.var == 4)  # type: ignore
+        space.add(x == 4)  # type: ignore
         container = {x}
         assert repr(container) == "{4}"
 
 
+def test_set_copy(space):
+    x = proxy_for_type(Set[int], "x")
+    with ResumedTracing():
+        space.add(len(x) == 1)
+        (y, z) = copy.deepcopy((x, x))
+        assert not space.is_possible(len(y) != 1)
+        assert not space.is_possible(list(x)[0] != list(y)[0])
+
+
 def test_set_no_duplicates() -> None:
     def f(s: Set[int]) -> int:
         """
@@ -2690,9 +2868,9 @@ def test_frozenset_realize():
 
 def test_frozenset_covariance():
     with standalone_statespace as space:
+        frozen_set = proxy_for_type(FrozenSet[AbstractBase], "x")
+        space.add(frozen_set.__len__() == 1)
         with NoTracing():
-            frozen_set = proxy_for_type(FrozenSet[AbstractBase], "x")
-            space.add(frozen_set.__len__().var == 1)
             assert isinstance(next(iter(frozen_set)), ConcreteSubclass)
 
 
@@ -2702,9 +2880,9 @@ def test_set_invariance():
     # assigned to a superclass container.
     # Therefore, CrossHair should happily create set contents using subclasses:
     with standalone_statespace as space:
+        mutable_set = proxy_for_type(Set[AbstractBase], "x")
+        space.add(mutable_set.__len__() == 1)
         with NoTracing():
-            mutable_set = proxy_for_type(Set[AbstractBase], "x")
-            space.add(mutable_set.__len__().var == 1)
             assert isinstance(next(iter(mutable_set)), ConcreteSubclass)
 
 
@@ -2722,14 +2900,43 @@ def test_set_iter_partial():
     with standalone_statespace as space:
         with NoTracing():
             x = proxy_for_type(Set[int], "x")
-            space.add(x.__len__().var == 2)
+        space.add(x.__len__() == 2)
         itr = iter(x)
         first = next(itr)
         # leave the iterator incomplete; looking for generator + context mgr problems
-    return
 
 
-class ProtocolsTest(unittest.TestCase):
+def test_set_containment_check_without_iteration():
+    with standalone_statespace as space:
+        x = proxy_for_type(FrozenSet[int], "x")
+        with ResumedTracing():
+            space.add(len(x) == 1)
+            assert space.is_possible(x._is_consistent())
+            space.add(x.__contains__(42))
+            assert space.is_possible(x._is_consistent())
+            space.add(x.__contains__(10))
+            assert not space.is_possible(x._is_consistent())
+
+
+def test_set_independence(space):
+    with ResumedTracing():
+        s = set()
+        copy = set(s)
+        s |= s
+        s != copy
+
+
+def test_frozenset___or__(space):
+    x = proxy_for_type(int, "x")
+    y = proxy_for_type(int, "y")
+    with ResumedTracing():
+        space.add(x != y)
+        s1 = frozenset([x])
+        s2 = frozenset([y])
+        assert len(s1 | s2) == 2
+
+
+class TestProtocols:
     # TODO: move most of this into a collectionslib_test.py file
     def test_hashable_values_fail(self) -> None:
         def f(b: bool, i: int, t: Tuple[str, ...]) -> int:
@@ -2761,7 +2968,10 @@ class ProtocolsTest(unittest.TestCase):
             # c: SupportsComplex,  # TODO: symbolic complex not yet really working
             b: SupportsBytes,
         ) -> float:
-            """post: _.real <= 0"""
+            """
+            pre: math.isfinite(f) and math.isfinite(r)
+            post: _.real <= 0
+            """
             return abs(a) + float(f) + int(i) + round(r) + len(bytes(b))
             # + complex(c)
 
@@ -2885,6 +3095,12 @@ def test_object___eq__() -> None:
     check_states(f, POST_FAIL)
 
 
+def test_object_get_type_hints(space: StateSpace) -> None:
+    typ = proxy_for_type(type, "typ")
+    with ResumedTracing():
+        get_type_hints(typ)
+
+
 def test_issubclass_abc():
     with standalone_statespace as space:
         with NoTracing():
@@ -2974,6 +3190,17 @@ def test_callable_as_bool() -> None:
     check_states(f, CONFIRMED)
 
 
+def test_callable_can_return_different_values(space) -> None:
+    fn = proxy_for_type(Callable[[], int], "fn")
+    with ResumedTracing():
+        first_return = fn()
+        second_return = fn()
+        returns_are_equal = first_return == second_return
+        returns_are_not_equal = first_return != second_return
+    assert space.is_possible(returns_are_equal)
+    assert space.is_possible(returns_are_not_equal)
+
+
 @pytest.mark.smoke
 def test_callable_repr() -> None:
     def f(f1: Callable[[int], int]) -> int:
@@ -3030,9 +3257,9 @@ def test_all():
 
     with standalone_statespace as space:
         true_bool = proxy_for_type(bool, "true_bool")
-        space.add(true_bool.var)
+        space.add(true_bool)
         nonempty_list = proxy_for_type(List[object], "nonempty_list")
-        space.add(len(nonempty_list).var == 1)
+        space.add(len(nonempty_list) == 1)
         arbitrary_bool = proxy_for_type(bool, "arbitrary_bool")
         boom = ExplodingBool()
 
@@ -3041,8 +3268,8 @@ def test_all():
         sym_false = all([True, true_bool, nonempty_list, arbitrary_bool])
         with NoTracing():
             assert isinstance(sym_false, SymbolicBool)
-            assert space.is_possible(sym_false.var)
             assert space.is_possible(z3.Not(sym_false.var))
+        assert space.is_possible(sym_false)
 
         with pytest.raises(ExplodingBool):
             all([true_bool, True, nonempty_list, boom])
@@ -3059,7 +3286,7 @@ def test_any():
         false_bool = proxy_for_type(bool, "false_bool")
         space.add(z3.Not(false_bool.var))
         empty_list = proxy_for_type(List[object], "empty_list")
-        space.add(len(empty_list).var == 0)
+        space.add(len(empty_list) == 0)
         arbitrary_bool = proxy_for_type(bool, "arbitrary_bool")
         # arbitrary_list = proxy_for_type(List[object], "arbitrary_list")
         # TODO: in theory, we should be able to keep `bool(arbitrary_list)`
@@ -3072,8 +3299,8 @@ def test_any():
         sym_false = any([False, false_bool, empty_list, arbitrary_bool])
         with NoTracing():
             assert isinstance(sym_false, SymbolicBool)
-            assert space.is_possible(sym_false.var)
             assert space.is_possible(z3.Not(sym_false.var))
+        assert space.is_possible(sym_false)
 
         with pytest.raises(ExplodingBool):
             any([false_bool, False, empty_list, boom])
@@ -3221,6 +3448,10 @@ def test_bytes_roundtrip_array_as_symbolic():
             assert new_bytes.inner is orig_bytes.inner
 
 
+@pytest.mark.skipif(
+    sys.version_info >= (3, 13),
+    reason="Need to intercept UnicodeDecodeError.str in 3.13+",
+)
 @pytest.mark.demo
 def test_bytes_decode_method():
     def f(b: bytes) -> str:
@@ -3277,13 +3508,13 @@ def test_extend_concrete_bytearray():
         xyz = proxy_for_type(bytearray, "xyz")
         b.extend(xyz)
         assert not space.is_possible(b[0] != ord("a"))
-        assert space.is_possible(len(b).var > 3)
+        assert space.is_possible(len(b) > 3)
 
 
 def test_bytearray_slice():
     with standalone_statespace as space:
         xyz = proxy_for_type(bytearray, "xyz")
-        space.add(xyz.__len__().var == 3)
+        space.add(xyz.__len__() == 3)
         assert type(xyz[1:]) is bytearray
 
 
@@ -3292,9 +3523,8 @@ def test_memoryview_compare():
         mv1 = proxy_for_type(memoryview, "mv1")
         mv2 = proxy_for_type(memoryview, "mv2")
         len1, len2 = len(mv1), len(mv2)
-        with NoTracing():
-            space.add(len1.var == 0)
-            space.add(len2.var == 0)
+        space.add(len1 == 0)
+        space.add(len2 == 0)
         views_equal = mv1 == mv2
         with NoTracing():
             assert views_equal is True
@@ -3304,7 +3534,7 @@ def test_memoryview_cast():
     """post: _"""
     with standalone_statespace as space:
         val = proxy_for_type(int, "val")
-        space.add(val.var == 254)
+        space.add(val == 254)
         mv = memoryview(bytearray([val]))
         assert mv.cast("b")[0] == -2
 
@@ -3313,7 +3543,7 @@ def test_memoryview_toreadonly():
     """post: _"""
     with standalone_statespace as space:
         mv = proxy_for_type(memoryview, "mv")
-        space.add(mv.__len__().var == 1)
+        space.add(mv.__len__() == 1)
         mv2 = mv.toreadonly()
         mv[0] = 12
         assert mv2[0] == 12
@@ -3325,7 +3555,7 @@ def test_memoryview_properties():
     """post: _"""
     with standalone_statespace as space:
         symbolic_mv = proxy_for_type(memoryview, "symbolic_mv")
-        space.add(symbolic_mv.__len__().var == 1)
+        space.add(symbolic_mv.__len__() == 1)
         concrete_mv = memoryview(bytearray(b"a"))
         assert symbolic_mv.contiguous == concrete_mv.contiguous
         assert symbolic_mv.c_contiguous == concrete_mv.c_contiguous
@@ -3340,46 +3570,47 @@ def test_memoryview_properties():
         assert symbolic_mv.suboffsets == concrete_mv.suboffsets
 
 
-def test_chr():
-    with standalone_statespace as space:
-        i = proxy_for_type(int, "i")
-        space.add(z3.And(10 <= i.var, i.var < 256))
+def test_chr(space):
+    i = proxy_for_type(int, "i")
+    with ResumedTracing():
+        space.add(10 <= i)
+        space.add(i < 256)
         c = chr(i)
-        assert space.is_possible(c._codepoints[0].var == ord("a"))
-        assert not space.is_possible(c._codepoints[0].var == 0)
+        assert space.is_possible(c._codepoints[0] == ord("a"))
+        assert not space.is_possible(c._codepoints[0] == 0)
 
 
-def test_ord():
-    with standalone_statespace as space:
-        s = proxy_for_type(str, "s")
-        space.add(len(s).var == 1)
+def test_ord(space):
+    s = proxy_for_type(str, "s")
+    with ResumedTracing():
+        space.add(len(s) == 1)
         i = ord(s)
-        assert space.is_possible(i.var == 42)
-        assert not space.is_possible(i.var > sys.maxunicode)
+        assert space.is_possible(i == 42)
+        assert not space.is_possible(i > sys.maxunicode)
 
 
-def test_unicode_support():
-    with standalone_statespace as space:
-        s = proxy_for_type(str, "s")
-        space.add(len(s).var == 1)
-        assert space.is_possible((s == "a").var)
-        assert space.is_possible((s == "\u1234").var)
+def test_unicode_support(space):
+    s = proxy_for_type(str, "s")
+    with ResumedTracing():
+        space.add(len(s) == 1)
+        assert space.is_possible(s == "a")
+        assert space.is_possible(s == "\u1234")
 
 
 @pytest.mark.parametrize("concrete_x", (25, 15, 6, -4, -15, -25))
-def test_int_round(concrete_x):
-    with standalone_statespace as space:
-        concrete_ret = round(concrete_x, -1)
-        x = proxy_for_type(int, "x")
-        d = proxy_for_type(int, "d")
-        space.add(x.var == concrete_x)
-        space.add(d.var == -1)
-        assert not space.is_possible((round(x, d) != concrete_ret).var)
+def test_int_round(concrete_x, space):
+    concrete_ret = round(concrete_x, -1)
+    x = proxy_for_type(int, "x")
+    d = proxy_for_type(int, "d")
+    with ResumedTracing():
+        space.add(x == concrete_x)
+        space.add(d == -1)
+        assert not space.is_possible((round(x, d) != concrete_ret))
 
 
 class ExplodingValue:
     def __getattribute__(self, name):
-        raise CrosshairInternal
+        raise CrossHairInternal
 
 
 @dataclasses.dataclass
@@ -3401,18 +3632,81 @@ def test_class_with_special_member_names():
     check_states(f, CONFIRMED)
 
 
-def TODO_test_float_precision_issues(a, b):
-    # Does not yet work: floating point is modeled with infinite precision at the moment
-    def f(a: int, b: int):
-        """
-        pre: b !=0
-        post: a == b * _
+@pytest.mark.parametrize("type2", (list, set, frozenset, tuple))
+@pytest.mark.parametrize(
+    "type1",
+    (
+        list,
+        set,
+        frozenset,
+        tuple,
+        array,
+    ),
+)
+def test_container_crosstype_equality(space, type1, type2):
+    sym_obj1 = proxy_for_type(type1, "obj1")
+    obj2 = type2()
+    with ResumedTracing():
+        space.add(len(sym_obj1) == 0)
+        obj1 = deep_realize(sym_obj1)
+        sym_eq_on_left = realize(sym_obj1 == obj2)
+        sym_eq_on_right = realize(obj2 == sym_obj1)
+    actually_equal = obj1 == obj2
+    assert actually_equal == sym_eq_on_left
+    assert actually_equal == sym_eq_on_right
+
+
+@pytest.mark.parametrize("type2", (str, bytes, tuple))
+@pytest.mark.parametrize("type1", (str, bytes, tuple, memoryview))
+def test_stringlike_crosstype_equality(space, type1, type2):
+    sym_obj1 = proxy_for_type(type1, "obj1")
+    obj2 = type2()
+    with ResumedTracing():
+        space.add(len(sym_obj1) == 0)
+        obj1 = deep_realize(sym_obj1)
+        sym_eq_on_left = realize(sym_obj1 == obj2)
+        sym_eq_on_right = realize(obj2 == sym_obj1)
+    actually_equal = obj1 == obj2
+    assert actually_equal == sym_eq_on_left
+    assert actually_equal == sym_eq_on_right
+
+
+@pytest.mark.parametrize("typ", (List[int],))
+def test_deep_realization(space, typ):
+    symbolic = proxy_for_type(typ, "symbolic")
+    with ResumedTracing():
+        space.add(len(symbolic) == 3)
+    origin = origin_of(typ)
+    assert type(symbolic) != origin
+    concrete = deep_realize(symbolic)
+    assert type(concrete) == origin
+    with ResumedTracing():
+        assert concrete == symbolic
 
-        Postcondition holds in a math-sense, but not when floating point precision
-        comes into play (e.g. it's false for 13 / 99)
-        """
 
-    return a / b
+def test_float_round_to_zero(space):
+    space.extra(ModelingDirector).global_representations[
+        float
+    ] = PreciseIeeeSymbolicFloat
+    n = proxy_for_type(float, "n")
+    d = proxy_for_type(float, "d")
+    with ResumedTracing():
+        space.add(d != 0.0)
+        # This is possible for floats, but not reals:
+        assert space.is_possible(n / d != 0.0)
+        assert space.is_possible(n / d == 0.0)
+
+
+def test_float_neg_zero_is_falsey(space):
+    space.extra(ModelingDirector).global_representations[
+        float
+    ] = PreciseIeeeSymbolicFloat
+    x = proxy_for_type(float, "x")
+    with ResumedTracing():
+        space.add(x == -10.0)
+        negzero = x / math.inf
+        assert not space.is_possible(negzero != 0.0)
+        assert bool(negzero) is False
 
 
 def TODO_test_int_mod_float():
@@ -3422,8 +3716,8 @@ def TODO_test_int_mod_float():
         y = proxy_for_type(float, "y")
         modval = x % y
         with NoTracing():
-            assert type(modval) == SymbolicFloat
-            assert space.is_possible(modval.var == 12.12)
+            assert type(modval) == RealBasedSymbolicFloat
+        assert space.is_possible(modval == 12.12)
 
 
 def TODO_test_can_generate_integral():
@@ -3439,9 +3733,3 @@ def TODO_test_deepcopy_independence():
         with NoTracing():
             assert ls[0] is not lscopy[0]
         # Next try mutation on one and test the other...
-
-
-if __name__ == "__main__":
-    if ("-v" in sys.argv) or ("--verbose" in sys.argv):
-        set_debug(True)
-    unittest.main()