diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 7ccf9a5..0fac246 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -6,13 +6,13 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest]
-        python-version: [3.6, 3.7, 3.8]
+        os: [ubuntu-22.04]
+        python-version: ['3.8', '3.10', '3.11', '3.14.6']
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
       - name: Test
diff --git a/README.md b/README.md
index 1df2030..9d8b2d5 100644
--- a/README.md
+++ b/README.md
@@ -20,6 +20,51 @@ def example_tests():
         test.assert_equals(add(1, 1), 2, 'Optional Message on Failure')
 ```
 
+### Assertion control flow and timeouts
+
+Assertions report a failure and continue by default. With `allow_raise=True`,
+the assertion stops the current decorated block and reports its failure once.
+The enclosing `it` or `describe` still closes normally, and its `after` hook
+runs. At top level, the framework's assertion exception still propagates.
+
+`@test.timeout(seconds)` executes immediately in a child process. On the
+Codewars Linux runtime it uses a local `fork` context so existing nested test
+functions work on Python 3.14 without changing the process-wide start method.
+Normal completion retains the existing additional passing assertion. An expired
+timeout, abnormal exit or exit before the wrapper completes reports a failure;
+timed-out children are terminated and joined, including children that ignore
+`SIGTERM`. Previously printed assertions remain visible.
+
+The fork context preserves the existing Linux execution model. Tests that start
+threads or import libraries with background threads still require validation in
+the full runner image. This compatibility change does not make fork safe for
+arbitrary multithreaded programs.
+
+### Development tests
+
+Failed comparisons retain the author's message and emit escaped `Expected`,
+`Actual` and `Location` details. Values are limited to 2,000 characters per
+field, with `[truncated]` marking omitted text. A failing bare `assert` gets a
+nonempty message and user-code location; passing bare assertions and empty
+groups do not add implicit successful assertions.
+
+An `after` hook runs even when `before` fails, and runs before the group closes.
+A failed `before` skips the body. Hook errors remain visible alongside any
+original body failure, and later sibling tests can still run. Cleanup hooks
+should therefore tolerate partially initialized state.
+
+Run the output fixtures and compatibility tests with the interpreter under test:
+
+```bash
+python -m unittest discover -v
+```
+
+The timeout regression tests run on Linux and check success/failure counts,
+nested functions, unchanged global start-method selection, early exits, signals,
+startup errors, child cleanup and `allow_raise` behavior. Other platforms skip
+these Linux-specific checks. Set `CW10_RESULTS` to a writable JSON file path to
+capture their raw outputs for integration checks with the Exo result parser.
+
 <!--
 
 ### Using Other Assertions
diff --git a/codewars_test/test_framework.py b/codewars_test/test_framework.py
index 7b6fc6a..46acfb6 100644
--- a/codewars_test/test_framework.py
+++ b/codewars_test/test_framework.py
@@ -1,5 +1,52 @@
 from __future__ import print_function
 
+import sys
+import traceback
+
+
+_VALUE_LIMIT = 2000
+
+
+def _bounded(value):
+    if len(value) > _VALUE_LIMIT:
+        return value[:_VALUE_LIMIT] + ' ... [truncated]'
+    return value
+
+
+def _safe_repr(value):
+    try:
+        return _bounded(repr(value))
+    except Exception:
+        return '<{}: repr unavailable>'.format(type(value).__name__)
+
+
+def _value_details(value, representation):
+    # Multiline strings are easier to compare as text. display() transports
+    # newlines inside a single escaped log event, including protocol-like text.
+    return _bounded(value) if type(value) is str else representation
+
+
+def _location(tb=None):
+    if tb is not None:
+        frames = traceback.extract_tb(tb)
+    else:
+        frames = traceback.extract_stack()[:-1]
+    for frame in reversed(frames):
+        if frame.filename != __file__:
+            return '{}:{} in {}'.format(frame.filename, frame.lineno, frame.name)
+    return ''
+
+
+def _failure(message, allow_raise=False, details=(), tb=None):
+    display('FAILED', message)
+    for label, value in details:
+        display('LOG', value, label=label, mode='ESC')
+    location = _location(tb)
+    if location:
+        display('LOG', location, label='Location', mode='ESC')
+    if allow_raise:
+        raise AssertException(message)
+
 
 class AssertException(Exception):
     pass
@@ -20,30 +67,36 @@ def expect(passed=None, message=None, allow_raise=False):
         display('PASSED', 'Test Passed')
     else:
         message = message or "Value is not what was expected"
-        display('FAILED', message)
-        if allow_raise:
-            raise AssertException(message)
+        _failure(message, allow_raise)
 
 
 def assert_equals(actual, expected, message=None, allow_raise=False):
-    equals_msg = "{0} should equal {1}".format(repr(actual), repr(expected))
+    r_actual, r_expected = _safe_repr(actual), _safe_repr(expected)
+    equals_msg = "{0} should equal {1}".format(r_actual, r_expected)
     if message is None:
         message = equals_msg
     else:
         message += ": " + equals_msg
 
-    expect(actual == expected, message, allow_raise)
+    if actual == expected:
+        pass_()
+    else:
+        _failure(message, allow_raise, (
+            ('Expected', _value_details(expected, r_expected)), ('Actual', _value_details(actual, r_actual))))
 
 
 def assert_not_equals(actual, expected, message=None, allow_raise=False):
-    r_actual, r_expected = repr(actual), repr(expected)
+    r_actual, r_expected = _safe_repr(actual), _safe_repr(expected)
     equals_msg = "{0} should not equal {1}".format(r_actual, r_expected)
     if message is None:
         message = equals_msg
     else:
         message += ": " + equals_msg
 
-    expect(not (actual == expected), message, allow_raise)
+    if not (actual == expected):
+        pass_()
+    else:
+        _failure(message, allow_raise, (('Unexpected value', _value_details(actual, r_actual)),))
 
 
 def expect_error(message, function, exception=Exception):
@@ -77,13 +130,18 @@ def fail(message): expect(False, message)
 def assert_approx_equals(
         actual, expected, margin=1e-9, message=None, allow_raise=False):
     msg = "{0} should be close to {1} with absolute or relative margin of {2}"
-    equals_msg = msg.format(repr(actual), repr(expected), repr(margin))
+    r_actual, r_expected = _safe_repr(actual), _safe_repr(expected)
+    equals_msg = msg.format(r_actual, r_expected, _safe_repr(margin))
     if message is None:
         message = equals_msg
     else:
         message += ": " + equals_msg
     div = max(abs(actual), abs(expected), 1)
-    expect(abs((actual - expected) / div) < margin, message, allow_raise)
+    if abs((actual - expected) / div) < margin:
+        pass_()
+    else:
+        _failure(message, allow_raise, (
+            ('Expected', _value_details(expected, r_expected)), ('Actual', _value_details(actual, r_actual))))
 
 
 '''
@@ -98,27 +156,46 @@ def it1():
 
 def _timed_block_factory(opening_text):
     from timeit import default_timer as timer
-    from traceback import format_exception
-    from sys import exc_info
+
+    def run_part(func, hook=None):
+        try:
+            func()
+        except AssertException:
+            # The assertion already emitted its failure and location.
+            pass
+        except AssertionError as error:
+            message = str(error) or 'Assertion failed'
+            if hook:
+                message = '{} hook: {}'.format(hook, message)
+            _failure(message, tb=sys.exc_info()[2])
+        except Exception:
+            if hook:
+                display('ERROR', '{} hook raised an exception'.format(hook))
+                display('LOG', ''.join(traceback.format_exception(*sys.exc_info())),
+                        label='Traceback', mode='ESC')
+            else:
+                fail('Unexpected exception raised')
+                display('ERROR', ''.join(traceback.format_exception(*sys.exc_info())))
+        else:
+            return True
+        return False
 
     def _timed_block_decorator(s, before=None, after=None):
         display(opening_text, s)
 
         def wrapper(func):
-            if callable(before):
-                before()
             time = timer()
             try:
-                func()
-            except AssertionError as e:
-                display('FAILED', str(e))
-            except Exception:
-                fail('Unexpected exception raised')
-                tb_str = ''.join(format_exception(*exc_info()))
-                display('ERROR', tb_str)
-            display('COMPLETEDIN', '{:.2f}'.format((timer() - time) * 1000))
-            if callable(after):
-                after()
+                if not callable(before) or run_part(before, 'before'):
+                    run_part(func)
+            finally:
+                try:
+                    if callable(after):
+                        run_part(after, 'after')
+                finally:
+                    # Cleanup belongs to the open group, including when setup
+                    # fails. Closing last prevents errors leaking into siblings.
+                    display('COMPLETEDIN', '{:.2f}'.format((timer() - time) * 1000))
         return wrapper
     return _timed_block_decorator
 
@@ -139,16 +216,71 @@ def some_tests():
 
 def timeout(sec):
     def wrapper(func):
-        from multiprocessing import Process
+        from multiprocessing import get_context
+        import os
+        import signal
+
         msg = 'Should not throw any exceptions inside timeout'
+        process = None
+        receiver = sender = None
 
         def wrapped():
-            expect_no_error(msg, func)
-        process = Process(target=wrapped)
-        process.start()
-        process.join(sec)
-        if process.is_alive():
-            fail('Exceeded time limit of {:.3f} seconds'.format(sec))
-            process.terminate()
-            process.join()
+            receiver.close()
+            try:
+                try:
+                    func()
+                except AssertException:
+                    # Preserve fail-fast behavior without reporting twice.
+                    pass
+                except BaseException as error:
+                    fail('{}: {}'.format(msg, repr(error)))
+                else:
+                    # Retain the existing extra pass for normal completion.
+                    pass_()
+                sender.send_bytes(b'completed')
+            finally:
+                sender.close()
+
+        try:
+            # Codewars runs on Linux. Existing kata use nested functions, which
+            # cannot be pickled by Python 3.14's default forkserver context.
+            # A local context leaves user code's start-method selection intact.
+            context = get_context('fork')
+            receiver, sender = context.Pipe(duplex=False)
+            process = context.Process(target=wrapped)
+            process.start()
+            sender.close()
+            process.join(sec)
+            if process.is_alive():
+                fail('Exceeded time limit of {:.3f} seconds'.format(sec))
+            elif process.exitcode != 0:
+                fail('Timeout process exited with code {}'.format(process.exitcode))
+            else:
+                completed = False
+                if receiver.poll():
+                    try:
+                        completed = receiver.recv_bytes() == b'completed'
+                    except EOFError:
+                        pass
+                if not completed:
+                    # os._exit(0) is not proof that the test body finished.
+                    fail('Timeout process exited before completing the test block')
+        except Exception as error:
+            fail('Unable to run timed tests: {}'.format(repr(error)))
+        finally:
+            if process is not None and process.pid is not None:
+                if process.is_alive():
+                    process.terminate()
+                    process.join(1)
+                    if process.is_alive():
+                        # A test can install or inherit a SIGTERM handler.
+                        try:
+                            os.kill(process.pid, signal.SIGKILL)
+                        except ProcessLookupError:
+                            pass
+                process.join()
+            if receiver is not None:
+                receiver.close()
+            if sender is not None:
+                sender.close()
     return wrapper
diff --git a/tests/fixtures/expect_error_sample.py b/tests/fixtures/expect_error_sample.py
index e76962f..6e58a43 100644
--- a/tests/fixtures/expect_error_sample.py
+++ b/tests/fixtures/expect_error_sample.py
@@ -13,7 +13,8 @@ def f1():
 
 # BaseException >> Exception >> ArithmeticError >> ZeroDivisionError
 def f2():
-    return 1 // 0
+    # Exercise the exception hierarchy with stable text across Python versions.
+    raise ZeroDivisionError("integer division or modulo by zero")
 
 
 # BaseException >> Exception >> LookupError >> KeyError
diff --git a/tests/test_compatibility.py b/tests/test_compatibility.py
new file mode 100644
index 0000000..e919316
--- /dev/null
+++ b/tests/test_compatibility.py
@@ -0,0 +1,261 @@
+"""Exercise the public decorators in isolated Python processes."""
+
+import collections
+import json
+import multiprocessing
+import os
+from pathlib import Path
+import platform
+import re
+import signal
+import subprocess
+import sys
+import textwrap
+import unittest
+
+
+@unittest.skipUnless(sys.platform == "linux", "Codewars timeout runtime is Linux")
+class TestCompatibility(unittest.TestCase):
+    records = []
+
+    def run_case(self, source, passed=0, failed=0, errors=0, exit_code=0):
+        root = str(Path(__file__).resolve().parent.parent)
+        env = dict(os.environ, PYTHONPATH=root, PYTHONDONTWRITEBYTECODE="1",
+                   PYTHON_COLORS="0", NO_COLOR="1")
+        process = subprocess.Popen(
+            [sys.executable, "-c", textwrap.dedent(source)],
+            env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            universal_newlines=True, start_new_session=True,
+        )
+        try:
+            stdout, stderr = process.communicate(timeout=10)
+        except subprocess.TimeoutExpired:
+            # Kill the entire test process group, including a stuck timeout
+            # child, so a timeout regression cannot hang the test harness.
+            os.killpg(process.pid, signal.SIGKILL)
+            stdout, stderr = process.communicate()
+            self.fail("Fixture exceeded 10 seconds:\n" + stdout + stderr)
+        self.records.append({"name": self.id().split(".")[-1],
+                             "stdout": stdout, "stderr": stderr,
+                             "exit_code": process.returncode})
+        self.assertEqual(process.returncode, exit_code, stdout + stderr)
+        markers = collections.Counter(re.findall(
+            r"^<(PASSED|FAILED|ERROR)::>", stdout, flags=re.MULTILINE))
+        self.assertEqual(dict(markers), {key: value for key, value in
+                         (("PASSED", passed), ("FAILED", failed), ("ERROR", errors))
+                         if value}, stdout + stderr)
+        return stdout
+
+    @classmethod
+    def tearDownClass(cls):
+        # Optional captured output can also be checked with the real Exo parser.
+        destination = os.environ.get("CW10_RESULTS")
+        if destination:
+            Path(destination).write_text(json.dumps({
+                "python": platform.python_version(), "machine": platform.machine(),
+                "multiprocessing_default": multiprocessing.get_start_method(),
+                "cases": cls.records,
+            }, indent=2) + "\n")
+
+    def test_timeout_preserves_closures_and_pass_count(self):
+        self.run_case('''
+            import codewars_test as test
+            def parent():
+                value = 42
+                @test.timeout(2)
+                def child():
+                    test.assert_equals(value, 42)
+            parent()
+        ''', passed=2)
+
+    def test_timeout_preserves_empty_success(self):
+        self.run_case('''
+            import codewars_test as test
+            @test.timeout(2)
+            def child():
+                pass
+        ''', passed=1)
+
+    def test_timeout_does_not_change_global_start_method(self):
+        self.run_case('''
+            import multiprocessing as mp
+            import codewars_test as test
+            before = mp.get_start_method(allow_none=True)
+            @test.timeout(2)
+            def child():
+                test.pass_()
+            assert mp.get_start_method(allow_none=True) == before
+            assert not mp.active_children()
+        ''', passed=2)
+
+    def test_timeout_works_with_explicit_forkserver(self):
+        self.run_case('''
+            import multiprocessing as mp
+            import codewars_test as test
+            mp.set_start_method("forkserver")
+            @test.timeout(2)
+            def child():
+                test.pass_()
+            assert mp.get_start_method() == "forkserver"
+        ''', passed=2)
+
+    def test_nested_timeouts(self):
+        self.run_case('''
+            import codewars_test as test
+            @test.timeout(3)
+            def outer():
+                @test.timeout(2)
+                def inner():
+                    test.pass_()
+        ''', passed=3)
+
+    def test_timeout_keeps_assertion_failure_and_continuation(self):
+        self.run_case('''
+            import codewars_test as test
+            @test.timeout(2)
+            def child():
+                test.assert_equals(1, 2)
+                test.pass_()
+        ''', passed=2, failed=1)
+
+    def test_timeout_expiry_reaps_child(self):
+        output = self.run_case('''
+            import time
+            import multiprocessing as mp
+            import codewars_test as test
+            @test.timeout(0.1)
+            def child():
+                time.sleep(5)
+            assert not mp.active_children()
+        ''', failed=1)
+        self.assertIn("Exceeded time limit of 0.100 seconds", output)
+
+    def test_timeout_kills_child_ignoring_termination(self):
+        output = self.run_case('''
+            import time
+            import signal
+            import multiprocessing as mp
+            import codewars_test as test
+            signal.signal(signal.SIGTERM, signal.SIG_IGN)
+            @test.timeout(0.1)
+            def child():
+                while True:
+                    time.sleep(1)
+            assert not mp.active_children()
+        ''', failed=1)
+        self.assertIn("Exceeded time limit", output)
+
+    def test_timeout_reports_nonzero_child_exit_after_pass(self):
+        output = self.run_case('''
+            import os
+            import multiprocessing as mp
+            import codewars_test as test
+            @test.timeout(2)
+            def child():
+                test.pass_()
+                os._exit(7)
+            assert not mp.active_children()
+        ''', passed=1, failed=1)
+        self.assertIn("exited with code 7", output)
+
+    def test_timeout_reports_early_zero_exit_after_pass(self):
+        output = self.run_case('''
+            import os
+            import codewars_test as test
+            @test.timeout(2)
+            def child():
+                test.pass_()
+                os._exit(0)
+        ''', passed=1, failed=1)
+        self.assertIn("exited before completing", output)
+
+    def test_timeout_reports_signal_exit(self):
+        output = self.run_case('''
+            import os
+            import signal
+            import codewars_test as test
+            @test.timeout(2)
+            def child():
+                os.kill(os.getpid(), signal.SIGKILL)
+        ''', failed=1)
+        self.assertIn("exited with code -9", output)
+
+    def test_timeout_reports_exception_once(self):
+        output = self.run_case('''
+            import codewars_test as test
+            @test.timeout(2)
+            def child():
+                raise ValueError("child error")
+        ''', failed=1)
+        self.assertIn("ValueError('child error')", output)
+
+    def test_timeout_preserves_system_exit_failure(self):
+        output = self.run_case('''
+            import codewars_test as test
+            @test.timeout(2)
+            def child():
+                raise SystemExit(0)
+        ''', failed=1)
+        self.assertIn("SystemExit(0)", output)
+
+    def test_timeout_start_failure_is_reported(self):
+        output = self.run_case('''
+            from unittest.mock import patch
+            from multiprocessing.process import BaseProcess
+            import codewars_test as test
+            with patch.object(BaseProcess, "start", side_effect=OSError("start denied")):
+                @test.timeout(2)
+                def child():
+                    test.pass_()
+        ''', failed=1)
+        self.assertIn("start denied", output)
+
+    def test_allow_raise_closes_group_once_and_runs_after_hook(self):
+        output = self.run_case('''
+            import codewars_test as test
+            @test.describe("outer")
+            def group():
+                @test.it("first", after=lambda: print("CLEANUP"))
+                def first():
+                    test.assert_equals(1, 2, "author context", allow_raise=True)
+                    print("UNREACHABLE")
+                @test.it("second")
+                def second():
+                    test.pass_()
+        ''', passed=1, failed=1)
+        self.assertIn("author context: 1 should equal 2", output)
+        self.assertIn("CLEANUP", output)
+        self.assertNotIn("UNREACHABLE", output)
+        self.assertEqual(output.count("<COMPLETEDIN::>"), 3)
+
+    def test_timeout_allow_raise_reports_once(self):
+        output = self.run_case('''
+            import codewars_test as test
+            @test.timeout(2)
+            def child():
+                test.assert_equals(1, 2, "author context", allow_raise=True)
+                print("UNREACHABLE")
+        ''', failed=1)
+        self.assertIn("author context: 1 should equal 2", output)
+        self.assertNotIn("UNREACHABLE", output)
+
+    def test_default_assertions_still_continue(self):
+        self.run_case('''
+            import codewars_test as test
+            @test.it("continuation")
+            def case():
+                test.assert_equals(1, 2)
+                test.pass_()
+        ''', passed=1, failed=1)
+
+    def test_top_level_allow_raise_still_propagates(self):
+        output = self.run_case('''
+            import codewars_test as test
+            test.assert_equals(1, 2, allow_raise=True)
+            print("UNREACHABLE")
+        ''', failed=1, exit_code=1)
+        self.assertNotIn("UNREACHABLE", output)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_outputs.py b/tests/test_outputs.py
index e35f8a2..fb7210c 100644
--- a/tests/test_outputs.py
+++ b/tests/test_outputs.py
@@ -2,6 +2,7 @@
 import subprocess
 import os
 import re
+import sys
 from pathlib import Path
 
 
@@ -13,11 +14,13 @@ def test_against_expected(test_file, expected_file, env):
     def test(self):
         # Using `stdout=PIPE, stderr=PIPE` for Python 3.6 compatibility instead of `capture_output=True`
         result = subprocess.run(
-            ["python", test_file],
+            [sys.executable, test_file],
             env=env,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            timeout=15,
         )
+        self.assertEqual(result.returncode, 0, result.stderr.decode("utf-8"))
         with open(expected_file, "r", encoding="utf-8") as r:
             # Allow duration to change
             expected = re.sub(r"([()])", r"\\\1", r.read())
@@ -25,7 +28,10 @@ def test(self):
                 r"(?<=<COMPLETEDIN::>)\d+(?:\.\d+)?", r"\\d+(?:\\.\\d+)?", expected
             )
 
-            self.assertRegex(result.stdout.decode("utf-8"), expected)
+            # Additional escaped diagnostic logs are tested separately; retain
+            # the exact legacy assertion text and event ordering contract here.
+            output = re.sub(r"\n<LOG:ESC:[^>]*>[^\n]*\n", "", result.stdout.decode("utf-8"))
+            self.assertRegex(output, expected)
 
     return test
 
@@ -38,11 +44,13 @@ def test_against_sample(test_file, sample_file, env):
     def test(self):
         # Using `stdout=PIPE, stderr=PIPE` for Python 3.6 compatibility instead of `capture_output=True`
         result = subprocess.run(
-            ["python", test_file],
+            [sys.executable, test_file],
             env=env,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            timeout=15,
         )
+        self.assertEqual(result.returncode, 0, result.stderr.decode("utf-8"))
         with open(sample_file, "r", encoding="utf-8") as r:
             # Ensure that it contains the same output structure
             self.assertEqual(
@@ -62,7 +70,7 @@ def define_tests():
             test_func = test_against_expected(
                 os.path.join(fixtures_dir, f),
                 expected_file,
-                {"PYTHONPATH": package_dir},
+                dict(os.environ, PYTHONPATH=str(package_dir)),
             )
         else:
             # Use `.sample.txt` when testing against outputs with more variables.
@@ -70,7 +78,7 @@ def define_tests():
             test_func = test_against_sample(
                 os.path.join(fixtures_dir, f),
                 os.path.join(fixtures_dir, f.replace(".py", ".sample.txt")),
-                {"PYTHONPATH": package_dir},
+                dict(os.environ, PYTHONPATH=str(package_dir)),
             )
         setattr(TestOutputs, "test_{0}".format(f.replace(".py", "")), test_func)
 
diff --git a/tests/test_reporting.py b/tests/test_reporting.py
new file mode 100644
index 0000000..e299e5b
--- /dev/null
+++ b/tests/test_reporting.py
@@ -0,0 +1,143 @@
+import unittest
+
+from . import test_compatibility
+
+
+class TestReporting(unittest.TestCase):
+    records = []
+    run_case = test_compatibility.TestCompatibility.run_case
+
+    def test_multiline_unicode_and_protocol_text_are_escaped(self):
+        output = self.run_case(r'''
+            import codewars_test as test
+            test.assert_equals('café\n<FAILED::>literal', 'café\nexpected', 'random seed 42')
+        ''', failed=1)
+        self.assertIn('random seed 42:', output)
+        self.assertIn('<LOG:ESC:Expected>café<:LF:>expected', output)
+        self.assertIn('<LOG:ESC:Actual>café<:LF:><FAILED::>literal', output)
+        self.assertIn('<LOG:ESC:Location><string>:3', output)
+
+    def test_large_values_have_bounded_output(self):
+        output = self.run_case('''
+            import codewars_test as test
+            test.assert_equals('a' * 100000, 'b' * 100000)
+        ''', failed=1)
+        self.assertIn('[truncated]', output)
+        self.assertLess(len(output), 8500)
+
+    def test_unprintable_value_still_reports_original_failure(self):
+        output = self.run_case('''
+            import codewars_test as test
+            class Unprintable:
+                def __repr__(self):
+                    raise ValueError('broken repr')
+            test.assert_equals(Unprintable(), 42)
+        ''', failed=1)
+        self.assertIn('Unprintable: repr unavailable', output)
+
+    def test_nested_containers_and_custom_message(self):
+        output = self.run_case('''
+            import codewars_test as test
+            test.assert_equals({'a': [1, {'b': 2}]}, {'a': [1, {'b': 3}]}, 'case 7')
+        ''', failed=1)
+        self.assertIn('case 7:', output)
+        self.assertIn("<LOG:ESC:Expected>{'a': [1, {'b': 3}]}", output)
+
+    def test_diagnostics_do_not_repeat_custom_repr_side_effects(self):
+        self.run_case('''
+            import codewars_test as test
+            class Counted:
+                calls = 0
+                def __repr__(self):
+                    self.calls += 1
+                    return 'custom value'
+            value = Counted()
+            test.assert_equals(value, 0)
+            assert value.calls == 1
+        ''', failed=1)
+
+    def test_bare_assertion_has_message_and_user_location(self):
+        output = self.run_case('''
+            import codewars_test as test
+            @test.it('bare assert')
+            def case():
+                assert False
+        ''', failed=1)
+        self.assertIn('<FAILED::>Assertion failed', output)
+        self.assertIn('<string>:5 in case', output)
+        self.assertEqual(output.count('<COMPLETEDIN::>'), 1)
+
+    def test_passing_bare_assertion_and_empty_group_add_no_success(self):
+        self.run_case('''
+            import codewars_test as test
+            @test.it('bare assert')
+            def case():
+                assert True
+            @test.it('empty')
+            def empty():
+                pass
+        ''')
+
+    def test_before_failure_skips_body_runs_cleanup_and_closes_group(self):
+        output = self.run_case('''
+            import codewars_test as test
+            def before():
+                raise ValueError('setup failed')
+            @test.it('first', before=before, after=lambda: print('CLEANUP'))
+            def first():
+                print('UNREACHABLE')
+            @test.it('next')
+            def next_case():
+                test.pass_()
+        ''', passed=1, errors=1)
+        self.assertIn('before hook', output)
+        self.assertIn('setup failed', output)
+        self.assertNotIn('UNREACHABLE', output)
+        self.assertEqual(output.count('<COMPLETEDIN::>'), 2)
+        self.assertLess(output.index('CLEANUP'), output.index('<COMPLETEDIN::>'))
+
+    def test_cleanup_failure_does_not_hide_body_failure(self):
+        output = self.run_case('''
+            import codewars_test as test
+            def after():
+                raise ValueError('cleanup failed')
+            @test.it('both', after=after)
+            def case():
+                test.assert_equals(1, 2, 'original failure', allow_raise=True)
+        ''', failed=1, errors=1)
+        self.assertIn('original failure', output)
+        self.assertIn('cleanup failed', output)
+        self.assertLess(output.index('after hook'), output.index('<COMPLETEDIN::>'))
+
+    def test_before_allow_raise_reports_once_and_runs_cleanup(self):
+        output = self.run_case('''
+            import codewars_test as test
+            def before():
+                test.assert_equals(1, 2, allow_raise=True)
+            @test.it('setup', before=before, after=lambda: print('CLEANUP'))
+            def case():
+                print('UNREACHABLE')
+        ''', failed=1)
+        self.assertIn('CLEANUP', output)
+        self.assertNotIn('UNREACHABLE', output)
+
+    def test_body_exception_and_cleanup_exception_are_both_visible(self):
+        output = self.run_case('''
+            import codewars_test as test
+            def after():
+                raise RuntimeError('cleanup error')
+            @test.it('errors', after=after)
+            def case():
+                raise ValueError('body error')
+        ''', failed=1, errors=2)
+        self.assertIn('body error', output)
+        self.assertIn('cleanup error', output)
+
+    def test_approximate_and_negative_assertions_keep_counts(self):
+        self.run_case('''
+            import codewars_test as test
+            test.assert_approx_equals(1, 1.0000000001)
+            test.assert_approx_equals(1, 2)
+            test.assert_not_equals(1, 2)
+            test.assert_not_equals(1, 1)
+        ''', passed=2, failed=2)