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

crosshair/dynamic_typing_test.py

@@ -1,4 +1,6 @@
 import collections
+import sys
+from inspect import Parameter, Signature, signature
 from typing import (
     Callable,
     Dict,
@@ -6,15 +8,25 @@ from typing import (
     Iterable,
     List,
     Mapping,
+    Optional,
     Sequence,
     Tuple,
     TypeVar,
     Union,
 )
 
+import pytest
 from typing_extensions import TypedDict
 
-from crosshair.dynamic_typing import get_bindings_from_type_arguments, realize, unify
+from crosshair.dynamic_typing import (
+    get_bindings_from_type_arguments,
+    intersect_signatures,
+    realize,
+    unify,
+)
+from crosshair.options import AnalysisOptionSet
+from crosshair.statespace import CANNOT_CONFIRM
+from crosshair.test_util import check_states
 
 _T = TypeVar("_T")
 _U = TypeVar("_U")
@@ -49,7 +61,12 @@ def test_typedicts():
 def test_typevars():
     bindings = collections.ChainMap()
     assert unify(Tuple[int, str, List[int]], Tuple[int, _T, _U], bindings)
-    assert realize(Mapping[_U, _T], bindings) == Mapping[List[int], str]
+
+    ret = realize(Mapping[_U, _T], bindings)
+    if sys.version_info >= (3, 9):
+        assert ret == collections.abc.Mapping[List[int], str]
+    else:
+        assert ret == Mapping[List[int], str]
 
 
 def test_bound_vtypears():
@@ -68,7 +85,13 @@ def test_callable():
 
     assert not unify(Callable[[List], bool], Callable[[Iterable], bool], bindings)
     assert unify(Callable[[int, _T], List[int]], Callable[[int, str], _U], bindings)
-    assert realize(Callable[[_U], _T], bindings) == Callable[[List[int]], str]
+    if sys.version_info >= (3, 9):
+        assert (
+            realize(Callable[[_U], _T], bindings)
+            == collections.abc.Callable[[List[int]], str]
+        )
+    else:
+        assert realize(Callable[[_U], _T], bindings) == Callable[[List[int]], str]
 
 
 def test_plain_callable():
@@ -120,4 +143,68 @@ class Pair(Generic[_U, _T]):
 def test_bindings_from_type_arguments():
     var_mapping = get_bindings_from_type_arguments(Pair[int, str])
     assert var_mapping == {_U: int, _T: str}
-    assert realize(List[_U], var_mapping) == List[int]
+    if sys.version_info >= (3, 9):
+        assert realize(List[_U], var_mapping) == list[int]
+    else:
+        assert realize(List[_U], var_mapping) == List[int]
+
+
+def test_intersect_signatures_basic():
+    def f1(x: int, y: str, **kw) -> List[bool]:
+        return []
+
+    def f2(x: bool, *extra: str, **kw) -> List[int]:
+        return []
+
+    intersection = intersect_signatures(signature(f1), signature(f2))
+    assert intersection is not None
+    assert intersection.parameters == {
+        "x": Parameter("x", kind=Parameter.KEYWORD_ONLY, annotation=bool),
+        "y": Parameter("y", kind=Parameter.KEYWORD_ONLY, annotation=str),
+        "kw": Parameter("kw", kind=Parameter.VAR_KEYWORD),
+    }
+    assert intersection.return_annotation == List[bool]
+
+
+def test_intersect_signatures_typevars():
+    _T = TypeVar("_T")
+
+    def f1(cc, *args, **kwds):
+        pass
+
+    def f2(dd, left: Optional[_T], right: Optional[_T]):
+        pass
+
+    intersection = intersect_signatures(signature(f1), signature(f2))
+    assert intersection is not None
+    expected = {
+        "dd": Parameter("dd", kind=Parameter.KEYWORD_ONLY),
+        "left": Parameter("left", kind=Parameter.KEYWORD_ONLY, annotation=Optional[_T]),
+        "right": Parameter(
+            "right", kind=Parameter.KEYWORD_ONLY, annotation=Optional[_T]
+        ),
+    }
+    assert intersection.parameters == expected
+
+
+@pytest.mark.skip(
+    reason="The inspect module doesn't expose runtime type information yet"
+)
+def test_intersect_signature_with_crosshair():
+    def check_intersect_signatures(
+        sig1: Signature, sig2: Signature, pos_args: List, kw_args: Mapping[str, object]
+    ) -> None:
+        """post: True"""
+
+        def _sig_bindable(sig: Signature) -> bool:
+            try:
+                sig.bind(*pos_args, **kw_args)
+                return True
+            except TypeError:
+                return False
+
+        if _sig_bindable(sig1) or _sig_bindable(sig2):
+            intersection = intersect_signatures(sig1, sig2)
+            assert _sig_bindable(intersection)
+
+    check_states(check_intersect_signatures, CANNOT_CONFIRM)

crosshair/enforce.py

@@ -36,6 +36,7 @@ def WithEnforcement(fn: Callable) -> Callable:
     Enforcement is normally disabled when calling from some internal files, for
     performance reasons. Use WithEnforcement to ensure it is enabled anywhere.
     """
+
     # This local function has a special name that we look for while tracing
     # (see the wants_codeobj method below):
     def _crosshair_with_enforcement(*a, **kw):
@@ -191,12 +192,6 @@ class EnforcedConditions(TracingModule):
         self.fns_enforcing: Optional[Set[Callable]] = None
         self.codeobj_cache: Dict[object, bool] = {}
 
-    def __enter__(self):  # TODO: no longer used as a context manager; remove
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        return False
-
     @contextlib.contextmanager
     def currently_enforcing(self, fn: Callable):
         if self.fns_enforcing is None:

crosshair/enforce_test.py

@@ -1,6 +1,5 @@
 import abc
 import sys
-import unittest
 from contextlib import ExitStack
 
 import pytest
@@ -53,26 +52,25 @@ class Enforcement(ExitStack):
         super().__enter__()
         enforced_conditions = EnforcedConditions(Pep316Parser())
         self.enter_context(COMPOSITE_TRACER)
-        self.enter_context(enforced_conditions)
         self.enter_context(enforced_conditions.enabled_enforcement())
         COMPOSITE_TRACER.trace_caller()
 
 
-class CoreTest(unittest.TestCase):
+class TestCore:
     def test_enforce_conditions(self) -> None:
-        self.assertEqual(foo(-1), -2)  # unchecked
+        assert foo(-1) == -2  # unchecked
         with Enforcement():
-            self.assertEqual(foo(50), 100)
-            with self.assertRaises(PreconditionFailed):
+            assert foo(50) == 100
+            with pytest.raises(PreconditionFailed):
                 foo(-1)
-            with self.assertRaises(PostconditionFailed):
+            with pytest.raises(PostconditionFailed):
                 foo(0)
 
     def test_class_enforce(self) -> None:
         Pokeable().pokeby(-1)  # no exception (yet!)
         with Enforcement():
             Pokeable().poke()
-            with self.assertRaises(PreconditionFailed):
+            with pytest.raises(PreconditionFailed):
                 Pokeable().pokeby(-1)
 
     def test_enforce_on_uncopyable_value(self) -> None:
@@ -82,7 +80,7 @@ class CoreTest(unittest.TestCase):
 
         not_copyable = NotCopyable()
         with Enforcement():
-            with self.assertRaises(AttributeError):
+            with pytest.raises(AttributeError):
                 same_thing(not_copyable)
 
 
@@ -115,19 +113,19 @@ class DerivedFooable(BaseFooable):
         """pre: x > 0"""
 
 
-class TrickyCasesTest(unittest.TestCase):
+class TestTrickyCases:
     def test_attrs_restored_properly(self) -> None:
         orig_class_dict = DerivedFooable.__dict__.copy()
         with Enforcement():
             pass
         for k, v in orig_class_dict.items():
-            self.assertIs(
-                DerivedFooable.__dict__[k], v, f'member "{k}" changed afer encforcement'
-            )
+            assert (
+                DerivedFooable.__dict__[k] is v
+            ), f'member "{k}" changed afer encforcement'
 
     def test_enforcement_of_class_methods(self) -> None:
         with Enforcement():
-            with self.assertRaises(PreconditionFailed):
+            with pytest.raises(PreconditionFailed):
                 BaseFooable.class_foo(50)
         with Enforcement():
             DerivedFooable.class_foo(50)
@@ -135,14 +133,14 @@ class TrickyCasesTest(unittest.TestCase):
     def test_enforcement_of_static_methods(self) -> None:
         with Enforcement():
             DerivedFooable.static_foo(50)
-            with self.assertRaises(PreconditionFailed):
+            with pytest.raises(PreconditionFailed):
                 BaseFooable.static_foo(50)
 
     def test_super_method_enforced(self) -> None:
         with Enforcement():
-            with self.assertRaises(PreconditionFailed):
+            with pytest.raises(PreconditionFailed):
                 DerivedFooable().foo_only_in_super(50)
-            with self.assertRaises(PreconditionFailed):
+            with pytest.raises(PreconditionFailed):
                 DerivedFooable().foo(-1)
             # Derived class has a weaker precondition, so this is OK:
             DerivedFooable().foo(50)
@@ -182,9 +180,3 @@ def test_enforcement_init_on_abcmeta() -> None:
         with pytest.raises(PostconditionFailed):
             WithMetaclass(55)
         WithMetaclass(99)
-
-
-if __name__ == "__main__":
-    if ("-v" in sys.argv) or ("--verbose" in sys.argv):
-        set_debug(True)
-    unittest.main()

crosshair/examples/check_examples_test.py

@@ -1,4 +1,5 @@
 """Run functional tests of the tool on all the examples."""
+
 import argparse
 import os
 import pathlib
@@ -24,7 +25,7 @@ def extract_linenums(text: str) -> List[int]:
 
 def find_examples() -> Iterable[Path]:
     examples_dir = pathlib.Path(os.path.realpath(__file__)).parent
-    for path in sorted(examples_dir.glob("**/*.py")):
+    for path in sorted(examples_dir.glob("*/**/*.py")):
         if path.stem != "__init__":
             yield path
 

crosshair/fnutil.py

@@ -41,8 +41,7 @@ if sys.version_info >= (3, 8):
     from typing import Protocol
 
     class Descriptor(Protocol):
-        def __get__(self, instance: object, cls: type) -> Any:
-            ...
+        def __get__(self, instance: object, cls: type) -> Any: ...
 
 else:
     Descriptor = Any
@@ -344,7 +343,7 @@ def walk_paths(paths: Iterable[Path], ignore_missing=False) -> Iterable[Path]:
             else:
                 raise FileNotFoundError(str(path))
         if path.is_dir():
-            for (dirpath, _dirs, files) in os.walk(str(path)):
+            for dirpath, _dirs, files in os.walk(str(path)):
                 for curfile in files:
                     if analyzable_filename(curfile):
                         yield Path(dirpath) / curfile

crosshair/fnutil_test.py

@@ -1,7 +1,6 @@
 import builtins
 import inspect
 import sys
-import unittest
 from dataclasses import dataclass
 from typing import Generic
 
@@ -74,9 +73,3 @@ def test_load_function_at_line():
 
 def test_FunctionInfo_get_callable_on_generic():
     assert FunctionInfo.from_class(Generic, "__class_getitem__").get_callable() is None
-
-
-if __name__ == "__main__":
-    if ("-v" in sys.argv) or ("--verbose" in sys.argv):
-        set_debug(True)
-    unittest.main()

crosshair/fuzz_core_test.py

@@ -38,15 +38,16 @@ from crosshair.fnutil import resolve_signature
 from crosshair.libimpl.builtinslib import origin_of
 from crosshair.statespace import (
     CallAnalysis,
-    CrosshairInternal,
+    CrossHairInternal,
     IgnoreAttempt,
     RootNode,
     StateSpace,
     StateSpaceContext,
 )
 from crosshair.stubs_parser import signature_from_stubs
+from crosshair.test_util import flexible_equal
 from crosshair.tracers import COMPOSITE_TRACER, NoTracing, ResumedTracing
-from crosshair.util import CrosshairUnsupported, debug, type_args_of
+from crosshair.util import CrosshairUnsupported, debug, is_iterable, type_args_of
 
 FUZZ_SEED = 1348
 
@@ -176,8 +177,8 @@ class TrialStatus(enum.Enum):
 class FuzzTester:
     r: random.Random
 
-    def __init__(self, seed=None):
-        self.r = random.Random(FUZZ_SEED if seed is None else seed)
+    def __init__(self, seed):
+        self.r = random.Random(seed)
 
     def symbolic_run(
         self,
@@ -220,15 +221,10 @@ class FuzzTester:
                     return (
                         None,
                         symbolic_args,
-                        CrosshairInternal(f"exhausted after {itr} iterations"),
+                        CrossHairInternal(f"exhausted after {itr} iterations"),
                         space,
                     )
-        return (
-            None,
-            None,
-            CrosshairInternal("Unable to find a successful symbolic execution"),
-            space,
-        )
+        raise CrossHairInternal("Unable to find a successful symbolic execution")
 
     def runexpr(self, expr, bindings):
         try:
@@ -271,86 +267,77 @@ class FuzzTester:
         ) -> object:
             for name in typed_args.keys():
                 literal, symbolic = literal_args[name], symbolic_args[name]
-                if isinstance(literal, (set, frozenset, dict)):
-                    assert isinstance(symbolic, Sized)
-                    # We need not only equality, but equal ordering, because some operations
-                    # like pop() are order-dependent:
-                    if len(literal) != len(symbolic):
-                        raise IgnoreAttempt(
-                            f'symbolic "{name}" not equal to literal "{name}"'
-                        )
-                    if isinstance(literal, Mapping):
-                        assert isinstance(symbolic, Mapping)
-                        literal, symbolic = list(literal.items()), list(
-                            symbolic.items()
-                        )
-                    else:
-                        assert isinstance(symbolic, Iterable)
-                        literal, symbolic = list(literal), list(symbolic)
+                with NoTracing():
+                    # TODO: transition into general purpose SMT expr extractor
+                    # for equality with constant
+                    if hasattr(symbolic, "_smt_promote_literal"):
+                        symbolic.var = symbolic._smt_promote_literal(literal)  # type: ignore
+                    elif is_iterable(literal) and is_iterable(symbolic):
+                        with ResumedTracing():
+                            space.add(len(literal) == len(symbolic))  # type: ignore
                 if literal != symbolic:
                     raise IgnoreAttempt(
                         f'symbolic "{name}" not equal to literal "{name}"'
                     )
+                if repr(literal) != repr(symbolic):
+                    # dict/set ordering, -0.0 vs 0.0, etc
+                    raise IgnoreAttempt(
+                        f'symbolic "{name}" not repr-equal to literal "{name}"'
+                    )
             return eval(expr, symbolic_args.copy())
 
-        try:
-            debug(f"  =====  {expr} with {literal_args}  =====  ")
-            compile(expr, "<string>", "eval")
-            postexec_literal_args = copy.deepcopy(literal_args)
-            literal_ret, literal_exc = self.runexpr(expr, postexec_literal_args)
-            (
-                symbolic_ret,
-                postexec_symbolic_args,
-                symbolic_exc,
-                space,
-            ) = self.symbolic_run(symbolic_checker, typed_args)
-            if isinstance(symbolic_exc, CrosshairUnsupported):
-                return TrialStatus.UNSUPPORTED
-            with Patched(), StateSpaceContext(space), COMPOSITE_TRACER, NoTracing():
-                # compare iterators as the values they produce:
-                with ResumedTracing():
-                    if isinstance(literal_ret, Iterable) and isinstance(
-                        symbolic_ret, Iterable
-                    ):
-                        literal_ret = list(literal_ret)
-                        symbolic_ret = list(symbolic_ret)
-                postexec_symbolic_args = deep_realize(postexec_symbolic_args)
-                symbolic_ret = deep_realize(symbolic_ret)
-                symbolic_exc = deep_realize(symbolic_exc)
-                rets_differ = realize(bool(literal_ret != symbolic_ret))
-                postexec_args_differ = realize(
-                    bool(postexec_literal_args != postexec_symbolic_args)
-                )
-                if (
-                    rets_differ
-                    or postexec_args_differ
-                    or type(literal_exc) != type(symbolic_exc)
+        debug(f"  =====  {expr} with {literal_args}  =====  ")
+        compile(expr, "<string>", "eval")
+        postexec_literal_args = copy.deepcopy(literal_args)
+        literal_ret, literal_exc = self.runexpr(expr, postexec_literal_args)
+        (
+            symbolic_ret,
+            postexec_symbolic_args,
+            symbolic_exc,
+            space,
+        ) = self.symbolic_run(symbolic_checker, typed_args)
+        if isinstance(symbolic_exc, CrosshairUnsupported):
+            return TrialStatus.UNSUPPORTED
+        with Patched(), StateSpaceContext(space), COMPOSITE_TRACER, NoTracing():
+            # compare iterators as the values they produce:
+            with ResumedTracing():
+                if isinstance(literal_ret, Iterable) and isinstance(
+                    symbolic_ret, Iterable
                 ):
-                    debug(
-                        f"  *****  BEGIN FAILURE FOR {expr} WITH {literal_args}  *****  "
-                    )
-                    debug(
-                        f"  *****  Expected return: {literal_ret} (exc: {type(literal_exc)} {literal_exc})"
-                    )
-                    debug(f"  *****    {postexec_literal_args}")
-                    debug(
-                        f"  *****  Symbolic return: {symbolic_ret} (exc: {type(symbolic_exc)} {symbolic_exc})"
-                    )
-                    debug(f"  *****    {postexec_symbolic_args}")
-                    debug(f"  *****  END FAILURE FOR {expr}  *****  ")
-                    assert (literal_ret, literal_exc) == (symbolic_ret, symbolic_exc)
-                debug(" OK ret= ", literal_ret, "vs", symbolic_ret)
+                    literal_ret = list(literal_ret)
+                    symbolic_ret = list(symbolic_ret)
+            postexec_symbolic_args = deep_realize(postexec_symbolic_args)
+            symbolic_ret = deep_realize(symbolic_ret)
+            symbolic_exc = deep_realize(symbolic_exc)
+            rets_differ = not realize(flexible_equal(literal_ret, symbolic_ret))
+            postexec_args_differ = realize(
+                bool(postexec_literal_args != postexec_symbolic_args)
+            )
+            if (
+                rets_differ
+                or postexec_args_differ
+                or type(literal_exc) != type(symbolic_exc)
+            ):
+                debug(f"  *****  BEGIN FAILURE FOR {expr} WITH {literal_args}  *****  ")
                 debug(
-                    " OK exc= ",
-                    type(literal_exc),
-                    literal_exc,
-                    "vs",
-                    type(symbolic_exc),
-                    symbolic_exc,
+                    f"  *****  Expected return: {literal_ret} (exc: {type(literal_exc)} {literal_exc})"
                 )
-        except AssertionError as e:
-            raise AssertionError(
-                f"Mismatch while evaluating {expr} with {literal_args}: {e}"
+                debug(f"  *****    postexec args: {postexec_literal_args}")
+                debug(
+                    f"  *****  Symbolic return: {symbolic_ret} (exc: {type(symbolic_exc)} {symbolic_exc})"
+                )
+                debug(f"  *****    postexec args: {postexec_symbolic_args}")
+                debug(f"  *****  END FAILURE FOR {expr}  *****  ")
+                assert literal_ret == symbolic_ret
+                assert False, f"Mismatch while evaluating {expr} with {literal_args}"
+            debug(" OK ret= ", literal_ret, "vs", symbolic_ret)
+            debug(
+                " OK exc= ",
+                type(literal_exc),
+                literal_exc,
+                "vs",
+                type(symbolic_exc),
+                symbolic_exc,
             )
         return TrialStatus.NORMAL
 
@@ -406,7 +393,7 @@ def test_unary_ops(expr_str, seed) -> None:
     tester.run_trial(expr_str, arg_type_roots)
 
 
-@pytest.mark.parametrize("seed", range(25))
+@pytest.mark.parametrize("seed", set(range(25)) - {17})
 @pytest.mark.parametrize(
     "expr_str",
     [

crosshair/libimpl/arraylib.py

@@ -1,14 +1,16 @@
+import sys
 from array import array
-from typing import BinaryIO, ByteString, Dict, Iterable, List, Sequence, Tuple
+from typing import BinaryIO, Dict, Iterable, List, Sequence, Tuple
 
 import z3  # type: ignore
 
 from crosshair import SymbolicFactory, realize, register_patch
-from crosshair.core import CrossHairValue, register_type
+from crosshair.core import register_type
 from crosshair.libimpl.builtinslib import SymbolicArrayBasedUniformTuple
 from crosshair.simplestructs import ShellMutableSequence
 from crosshair.statespace import StateSpace
 from crosshair.tracers import NoTracing
+from crosshair.util import CrossHairValue
 
 INT_TYPE_BOUNDS: Dict[str, Tuple[int, int]] = {
     # (min, max) ranges - inclusive on min, exclusive on max.
@@ -28,13 +30,9 @@ INT_TYPE_BOUNDS: Dict[str, Tuple[int, int]] = {
 INT_TYPE_SIZE = {c: array(c).itemsize for c in INT_TYPE_BOUNDS.keys()}
 
 
-def is_bytes_like(obj: object) -> bool:
-    return isinstance(obj, (ByteString, array))
-
-
 def pick_code(space: StateSpace) -> Tuple[str, int, int]:
     last_idx = len(INT_TYPE_BOUNDS) - 1
-    for (idx, (code, rng)) in enumerate(INT_TYPE_BOUNDS.items()):
+    for idx, (code, rng) in enumerate(INT_TYPE_BOUNDS.items()):
         if idx < last_idx:
             if space.smt_fork(desc=f"not_{code}_array"):
                 continue
@@ -100,6 +98,11 @@ class SymbolicArray(
     def __ch_pytype__(self):
         return array
 
+    def __eq__(self, other):
+        if not isinstance(other, array):
+            return False
+        return ShellMutableSequence.__eq__(self, other)
+
     def _spawn(self, items: Sequence) -> ShellMutableSequence:
         return SymbolicArray(self.typecode, items)
 

crosshair/libimpl/binascii_ch_test.py

@@ -0,0 +1,30 @@
+import binascii
+import sys
+
+import pytest
+
+from crosshair.core import analyze_function, run_checkables
+from crosshair.statespace import MessageType
+from crosshair.test_util import compare_results
+
+
+def check_b2a_base64(byts: bytes, newline: bool):
+    """post: _"""
+    return compare_results(binascii.b2a_base64, byts, newline=newline)
+
+
+def check_a2b_base64(byts: bytes, strict_mode: bool):
+    """post: _"""
+    kw = {"strict_mode": strict_mode} if sys.version_info >= (3, 11) else {}
+    return compare_results(binascii.a2b_base64, byts, **kw)
+
+
+# This is the only real test definition.
+# It runs crosshair on each of the "check" functions defined above.
+@pytest.mark.parametrize("fn_name", [fn for fn in dir() if fn.startswith("check_")])
+def test_builtin(fn_name: str) -> None:
+    this_module = sys.modules[__name__]
+    fn = getattr(this_module, fn_name)
+    messages = run_checkables(analyze_function(fn))
+    errors = [m for m in messages if m.state > MessageType.PRE_UNSAT]
+    assert errors == []

crosshair/libimpl/binascii_test.py

@@ -0,0 +1,67 @@
+import binascii
+import sys
+from array import array
+
+import pytest
+
+from crosshair.test_util import summarize_execution
+from crosshair.tracers import ResumedTracing
+
+
+@pytest.mark.parametrize(
+    "input_bytes",
+    [
+        b"",  # empty
+        b"//==",  # padding 2
+        b"AAA=",  # padding 1
+        b"9999",  # no padding
+        b"3=4=",  # discontinuous padding
+        b"34=&=",  # unexpected chars in padding
+        b"34=",  # wrong padding
+        b"333====",  # over-padding
+        b"This/12+yearOld/Fox=",  # valid, long
+        "",  # empty string
+        "9009",  # nonempty string
+        "\u2165",  # unicode string
+    ],
+)
+@pytest.mark.parametrize("strict_mode", [True, False])
+def test_base64_decode(space, input_bytes, strict_mode):
+    kw = {"strict_mode": strict_mode} if sys.version_info >= (3, 11) else {}
+    concrete_result = summarize_execution(
+        binascii.a2b_base64, (input_bytes,), kw, detach_path=False
+    )
+    with ResumedTracing():
+        symbolic_result = summarize_execution(
+            binascii.a2b_base64, (input_bytes,), kw, detach_path=False
+        )
+    assert concrete_result == symbolic_result
+
+
+@pytest.mark.parametrize("newline", [True, False])
+@pytest.mark.parametrize(
+    "input_bytes",
+    [
+        b"",  # empty
+        b"H",
+        b"Ha",
+        b"Hai",
+        b"Hair",
+        "",  # empty string
+        "Hair",  # nonempty string
+        "\u2165",  # unicode string
+        bytearray(b"Hair"),  # bytearray
+        memoryview(b"Hair"),  # memoryview
+        array("B", b"Hair"),  # array
+    ],
+)
+def test_base64_encode(space, input_bytes, newline):
+    kw = {"newline": newline}
+    concrete_result = summarize_execution(
+        binascii.b2a_base64, (input_bytes,), kw, detach_path=False
+    )
+    with ResumedTracing():
+        symbolic_result = summarize_execution(
+            binascii.b2a_base64, (input_bytes,), kw, detach_path=False
+        )
+    assert concrete_result == symbolic_result