Import test_exceptions_builtin, test_functions, test_range_extra, test_conditional

jgarzik · claude · jgarzik · commit 593933ce6059 · 2026-03-18T16:08:30.000Z
New tests:
- test_exceptions_builtin.py: 16 tests — exception hierarchy, args, catching,
  error-raising builtins (TypeError, ValueError, IndexError, etc.)
- test_functions.py: 18 tests — defaults, varargs, kwargs, keyword-only,
  recursion (factorial, fibonacci, mutual), higher-order functions
- test_range_extra.py: 13 tests — range constructor, step, negative, len,
  contains, reversed, enumerate, sum
- test_conditional.py: 15 tests — ternary expressions, short-circuit and/or,
  not, chained booleans, is/is not identity

Total CPython test suites: 64

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/Makefile b/Makefile
@@ -163,6 +163,10 @@ gen-cpython-tests:
 	@$(PYTHON) -m py_compile tests/cpython/test_walrus.py
 	@$(PYTHON) -m py_compile tests/cpython/test_match.py
 	@$(PYTHON) -m py_compile tests/cpython/test_datastructures.py
+	@$(PYTHON) -m py_compile tests/cpython/test_exceptions_builtin.py
+	@$(PYTHON) -m py_compile tests/cpython/test_functions.py
+	@$(PYTHON) -m py_compile tests/cpython/test_range_extra.py
+	@$(PYTHON) -m py_compile tests/cpython/test_conditional.py
 	@echo "Done."
 
 check-cpython: $(TARGET) gen-cpython-tests
@@ -286,3 +290,11 @@ check-cpython: $(TARGET) gen-cpython-tests
 	@./apython tests/cpython/__pycache__/test_match.cpython-312.pyc
 	@echo "Running CPython test_datastructures.py..."
 	@./apython tests/cpython/__pycache__/test_datastructures.cpython-312.pyc
+	@echo "Running CPython test_exceptions_builtin.py..."
+	@./apython tests/cpython/__pycache__/test_exceptions_builtin.cpython-312.pyc
+	@echo "Running CPython test_functions.py..."
+	@./apython tests/cpython/__pycache__/test_functions.cpython-312.pyc
+	@echo "Running CPython test_range_extra.py..."
+	@./apython tests/cpython/__pycache__/test_range_extra.cpython-312.pyc
+	@echo "Running CPython test_conditional.py..."
+	@./apython tests/cpython/__pycache__/test_conditional.cpython-312.pyc
diff --git a/tests/cpython/test_conditional.py b/tests/cpython/test_conditional.py
@@ -0,0 +1,102 @@
+"""Tests for conditional expressions and boolean logic"""
+
+import unittest
+
+
+class TernaryTest(unittest.TestCase):
+
+    def test_true(self):
+        self.assertEqual("yes" if True else "no", "yes")
+
+    def test_false(self):
+        self.assertEqual("yes" if False else "no", "no")
+
+    def test_expression(self):
+        x = 10
+        self.assertEqual("big" if x > 5 else "small", "big")
+        self.assertEqual("big" if x < 5 else "small", "small")
+
+    def test_nested(self):
+        def classify(x):
+            return "pos" if x > 0 else "zero" if x == 0 else "neg"
+        self.assertEqual(classify(5), "pos")
+        self.assertEqual(classify(0), "zero")
+        self.assertEqual(classify(-5), "neg")
+
+    def test_in_list(self):
+        result = [x if x > 0 else 0 for x in [-2, -1, 0, 1, 2]]
+        self.assertEqual(result, [0, 0, 0, 1, 2])
+
+
+class BooleanLogicTest(unittest.TestCase):
+
+    def test_and_short_circuit(self):
+        self.assertEqual(0 and 42, 0)
+        self.assertEqual(1 and 42, 42)
+        self.assertEqual("" and "hello", "")
+        self.assertEqual("x" and "hello", "hello")
+
+    def test_or_short_circuit(self):
+        self.assertEqual(0 or 42, 42)
+        self.assertEqual(1 or 42, 1)
+        self.assertEqual("" or "hello", "hello")
+        self.assertEqual("x" or "hello", "x")
+
+    def test_not(self):
+        self.assertEqual(not True, False)
+        self.assertEqual(not False, True)
+        self.assertEqual(not 0, True)
+        self.assertEqual(not 1, False)
+        self.assertEqual(not "", True)
+        self.assertEqual(not "x", False)
+        self.assertEqual(not None, True)
+
+    def test_chained_and_or(self):
+        self.assertEqual(1 and 2 and 3, 3)
+        self.assertEqual(1 and 0 and 3, 0)
+        self.assertEqual(0 or 0 or 3, 3)
+        self.assertEqual(0 or 2 or 3, 2)
+
+    def test_complex_boolean(self):
+        x, y = 5, 10
+        self.assertTrue(x > 0 and y > 0)
+        self.assertFalse(x > 0 and y < 0)
+        self.assertTrue(x > 0 or y < 0)
+        self.assertFalse(x < 0 or y < 0)
+
+    def test_default_pattern(self):
+        def f(x=None):
+            return x or "default"
+        self.assertEqual(f(), "default")
+        self.assertEqual(f("value"), "value")
+        self.assertEqual(f(0), "default")  # 0 is falsy
+
+
+class IdentityTest(unittest.TestCase):
+
+    def test_is(self):
+        a = [1, 2]
+        b = a
+        c = [1, 2]
+        self.assertTrue(a is b)
+        self.assertFalse(a is c)
+
+    def test_is_not(self):
+        a = [1, 2]
+        c = [1, 2]
+        self.assertTrue(a is not c)
+        self.assertFalse(a is not a)
+
+    def test_none_identity(self):
+        self.assertTrue(None is None)
+        self.assertFalse(None is not None)
+        self.assertFalse(0 is None)
+
+    def test_bool_identity(self):
+        self.assertTrue(True is True)
+        self.assertTrue(False is False)
+        self.assertFalse(True is False)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/cpython/test_exceptions_builtin.py b/tests/cpython/test_exceptions_builtin.py
@@ -0,0 +1,109 @@
+"""Tests for builtin exception types and their relationships"""
+
+import unittest
+
+
+class ExceptionTypeTest(unittest.TestCase):
+
+    def test_base_hierarchy(self):
+        self.assertTrue(issubclass(Exception, BaseException))
+        self.assertTrue(issubclass(TypeError, Exception))
+        self.assertTrue(issubclass(ValueError, Exception))
+        self.assertTrue(issubclass(KeyError, LookupError))
+        self.assertTrue(issubclass(IndexError, LookupError))
+        self.assertTrue(issubclass(LookupError, Exception))
+        self.assertTrue(issubclass(NotImplementedError, RuntimeError))
+        self.assertTrue(issubclass(ZeroDivisionError, ArithmeticError))
+        self.assertTrue(issubclass(OverflowError, ArithmeticError))
+
+    def test_keyboard_interrupt(self):
+        self.assertTrue(issubclass(KeyboardInterrupt, BaseException))
+        self.assertFalse(issubclass(KeyboardInterrupt, Exception))
+
+    def test_exception_args_single(self):
+        e = ValueError("msg")
+        self.assertEqual(e.args, ("msg",))
+        self.assertEqual(str(e), "msg")
+
+    def test_exception_args_multi(self):
+        e = ValueError(1, 2, 3)
+        self.assertEqual(e.args, (1, 2, 3))
+        self.assertEqual(len(e.args), 3)
+
+    def test_exception_args_empty(self):
+        e = ValueError()
+        self.assertEqual(e.args, ())
+
+    def test_catch_parent(self):
+        for ExcType in [TypeError, ValueError, KeyError, IndexError]:
+            try:
+                raise ExcType("test")
+            except Exception:
+                pass  # should catch all
+            else:
+                self.fail("%s not caught by Exception" % ExcType.__name__)
+
+    def test_catch_specific(self):
+        caught = None
+        try:
+            raise KeyError("k")
+        except ValueError:
+            caught = "ValueError"
+        except KeyError:
+            caught = "KeyError"
+        except TypeError:
+            caught = "TypeError"
+        self.assertEqual(caught, "KeyError")
+
+    def test_catch_tuple(self):
+        for ExcType in [ValueError, TypeError, KeyError]:
+            try:
+                raise ExcType()
+            except (ValueError, TypeError, KeyError):
+                pass
+            else:
+                self.fail("%s not caught by tuple" % ExcType.__name__)
+
+
+class ErrorRaisingTest(unittest.TestCase):
+
+    def test_type_error(self):
+        with self.assertRaises(TypeError):
+            len(42)
+
+    def test_value_error(self):
+        with self.assertRaises(ValueError):
+            int("not_a_number")
+
+    def test_index_error(self):
+        with self.assertRaises(IndexError):
+            [1, 2, 3][10]
+
+    def test_key_error(self):
+        with self.assertRaises(KeyError):
+            {}["missing"]
+
+    def test_attribute_error(self):
+        with self.assertRaises(AttributeError):
+            (42).nonexistent
+
+    def test_zero_division(self):
+        with self.assertRaises(ZeroDivisionError):
+            1 / 0
+        with self.assertRaises(ZeroDivisionError):
+            1 // 0
+
+    def test_name_error(self):
+        def f():
+            return undefined_name
+        with self.assertRaises(NameError):
+            f()
+
+    def test_stop_iteration(self):
+        it = iter([])
+        with self.assertRaises(StopIteration):
+            next(it)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/cpython/test_functions.py b/tests/cpython/test_functions.py
@@ -0,0 +1,127 @@
+"""Tests for function features — defaults, varargs, kwargs, closures, recursion"""
+
+import unittest
+
+
+class FunctionBasicTest(unittest.TestCase):
+
+    def test_no_args(self):
+        def f():
+            return 42
+        self.assertEqual(f(), 42)
+
+    def test_positional(self):
+        def f(a, b, c):
+            return a + b + c
+        self.assertEqual(f(1, 2, 3), 6)
+
+    def test_default_args(self):
+        def f(a, b=10, c=20):
+            return a + b + c
+        self.assertEqual(f(1), 31)
+        self.assertEqual(f(1, 2), 23)
+        self.assertEqual(f(1, 2, 3), 6)
+
+    def test_keyword_args(self):
+        def f(a, b=0, c=0):
+            return (a, b, c)
+        self.assertEqual(f(1, c=3), (1, 0, 3))
+        self.assertEqual(f(1, b=2, c=3), (1, 2, 3))
+
+    def test_keyword_only(self):
+        def f(a, *, b, c=10):
+            return a + b + c
+        self.assertEqual(f(1, b=2), 13)
+        self.assertEqual(f(1, b=2, c=3), 6)
+
+    def test_varargs(self):
+        def f(*args):
+            return args
+        self.assertEqual(f(), ())
+        self.assertEqual(f(1, 2, 3), (1, 2, 3))
+
+    def test_kwargs(self):
+        def f(**kw):
+            return sorted(kw.items())
+        self.assertEqual(f(a=1, b=2), [('a', 1), ('b', 2)])
+
+    def test_mixed(self):
+        def f(a, b, *args, **kw):
+            return (a, b, args, sorted(kw.items()))
+        result = f(1, 2, 3, 4, x=5)
+        self.assertEqual(result, (1, 2, (3, 4), [('x', 5)]))
+
+    def test_return_none(self):
+        def f():
+            pass
+        self.assertIsNone(f())
+
+    def test_multiple_return(self):
+        def f():
+            return 1, 2, 3
+        a, b, c = f()
+        self.assertEqual((a, b, c), (1, 2, 3))
+
+
+class RecursionTest(unittest.TestCase):
+
+    def test_factorial(self):
+        def fact(n):
+            if n <= 1:
+                return 1
+            return n * fact(n - 1)
+        self.assertEqual(fact(10), 3628800)
+
+    def test_fibonacci(self):
+        def fib(n):
+            if n < 2:
+                return n
+            return fib(n - 1) + fib(n - 2)
+        self.assertEqual(fib(10), 55)
+
+    def test_mutual_recursion(self):
+        def is_even(n):
+            if n == 0:
+                return True
+            return is_odd(n - 1)
+        def is_odd(n):
+            if n == 0:
+                return False
+            return is_even(n - 1)
+        self.assertTrue(is_even(10))
+        self.assertFalse(is_even(11))
+        self.assertTrue(is_odd(7))
+
+
+class HigherOrderTest(unittest.TestCase):
+
+    def test_function_as_arg(self):
+        def apply(f, x):
+            return f(x)
+        self.assertEqual(apply(str, 42), "42")
+        self.assertEqual(apply(len, [1, 2, 3]), 3)
+
+    def test_function_as_return(self):
+        def make_adder(n):
+            def adder(x):
+                return x + n
+            return adder
+        add10 = make_adder(10)
+        self.assertEqual(add10(5), 15)
+
+    def test_map(self):
+        result = list(map(lambda x: x * 2, [1, 2, 3]))
+        self.assertEqual(result, [2, 4, 6])
+
+    def test_filter(self):
+        result = list(filter(lambda x: x > 2, [1, 2, 3, 4, 5]))
+        self.assertEqual(result, [3, 4, 5])
+
+    def test_sorted_key(self):
+        data = ["banana", "apple", "cherry"]
+        result = sorted(data, key=len)
+        self.assertEqual(result, ["apple", "banana", "cherry"])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/cpython/test_range_extra.py b/tests/cpython/test_range_extra.py
