Import test_controlflow, test_math_basic, test_global_nonlocal, test_unpacking, test_inheritance

New tests:
- test_controlflow.py: 23 tests — if/elif/else, while, for, break/continue,
  while/for-else, ternary, pass, nested loops
- test_math_basic.py: 25 tests — int/float/bool arithmetic, bitwise ops,
  abs, divmod, large ints, mixed-type arithmetic
- test_global_nonlocal.py: 12 tests — global/nonlocal statements, enclosing
  scope, class scope, comprehension scope isolation
- test_unpacking.py: 14 tests, 3 skips — tuple/list unpacking, star unpacking,
  nested unpacking, swap, for-loop star unpacking
- test_inheritance.py: 13 tests — single inheritance, super(), method
  resolution, isinstance/issubclass chains, exception inheritance

Total CPython test suites: 47

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jgarzik

Makefile

@@ -140,6 +140,16 @@ gen-cpython-tests:
 	@$(PYTHON) -m py_compile tests/cpython/test_set_extra.py
 	@echo "Compiling tests/cpython/test_list_extra.py..."
 	@$(PYTHON) -m py_compile tests/cpython/test_list_extra.py
+	@echo "Compiling tests/cpython/test_controlflow.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_controlflow.py
+	@echo "Compiling tests/cpython/test_math_basic.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_math_basic.py
+	@echo "Compiling tests/cpython/test_global_nonlocal.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_global_nonlocal.py
+	@echo "Compiling tests/cpython/test_unpacking.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_unpacking.py
+	@echo "Compiling tests/cpython/test_inheritance.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_inheritance.py
 	@echo "Done."
 
 check-cpython: $(TARGET) gen-cpython-tests
@@ -227,3 +237,13 @@ check-cpython: $(TARGET) gen-cpython-tests
 	@./apython tests/cpython/__pycache__/test_set_extra.cpython-312.pyc
 	@echo "Running CPython test_list_extra.py..."
 	@./apython tests/cpython/__pycache__/test_list_extra.cpython-312.pyc
+	@echo "Running CPython test_controlflow.py..."
+	@./apython tests/cpython/__pycache__/test_controlflow.cpython-312.pyc
+	@echo "Running CPython test_math_basic.py..."
+	@./apython tests/cpython/__pycache__/test_math_basic.cpython-312.pyc
+	@echo "Running CPython test_global_nonlocal.py..."
+	@./apython tests/cpython/__pycache__/test_global_nonlocal.cpython-312.pyc
+	@echo "Running CPython test_unpacking.py..."
+	@./apython tests/cpython/__pycache__/test_unpacking.cpython-312.pyc
+	@echo "Running CPython test_inheritance.py..."
+	@./apython tests/cpython/__pycache__/test_inheritance.cpython-312.pyc

tests/cpython/test_controlflow.py

@@ -0,0 +1,201 @@
+"""Tests for control flow — if/elif/else, while, for, break, continue, pass"""
+
+import unittest
+
+
+class IfTest(unittest.TestCase):
+
+    def test_basic_if(self):
+        x = 10
+        if x > 5:
+            result = "big"
+        else:
+            result = "small"
+        self.assertEqual(result, "big")
+
+    def test_elif(self):
+        def classify(x):
+            if x < 0:
+                return "negative"
+            elif x == 0:
+                return "zero"
+            elif x < 10:
+                return "small"
+            else:
+                return "big"
+        self.assertEqual(classify(-5), "negative")
+        self.assertEqual(classify(0), "zero")
+        self.assertEqual(classify(5), "small")
+        self.assertEqual(classify(100), "big")
+
+    def test_nested_if(self):
+        def f(x, y):
+            if x > 0:
+                if y > 0:
+                    return "both positive"
+                else:
+                    return "x positive"
+            else:
+                return "x not positive"
+        self.assertEqual(f(1, 1), "both positive")
+        self.assertEqual(f(1, -1), "x positive")
+        self.assertEqual(f(-1, 1), "x not positive")
+
+    def test_ternary(self):
+        self.assertEqual("yes" if True else "no", "yes")
+        self.assertEqual("yes" if False else "no", "no")
+        x = 10
+        self.assertEqual("big" if x > 5 else "small", "big")
+
+
+class WhileTest(unittest.TestCase):
+
+    def test_basic_while(self):
+        n = 0
+        while n < 10:
+            n += 1
+        self.assertEqual(n, 10)
+
+    def test_while_break(self):
+        n = 0
+        while True:
+            n += 1
+            if n == 5:
+                break
+        self.assertEqual(n, 5)
+
+    def test_while_continue(self):
+        result = []
+        n = 0
+        while n < 10:
+            n += 1
+            if n % 2 == 0:
+                continue
+            result.append(n)
+        self.assertEqual(result, [1, 3, 5, 7, 9])
+
+    def test_while_else(self):
+        hit_else = False
+        n = 0
+        while n < 3:
+            n += 1
+        else:
+            hit_else = True
+        self.assertTrue(hit_else)
+
+    def test_while_else_break(self):
+        hit_else = False
+        n = 0
+        while n < 10:
+            n += 1
+            if n == 5:
+                break
+        else:
+            hit_else = True
+        self.assertFalse(hit_else)
+
+
+class ForTest(unittest.TestCase):
+
+    def test_for_range(self):
+        total = 0
+        for i in range(10):
+            total += i
+        self.assertEqual(total, 45)
+
+    def test_for_list(self):
+        result = []
+        for x in [1, 2, 3]:
+            result.append(x * 2)
+        self.assertEqual(result, [2, 4, 6])
+
+    def test_for_string(self):
+        chars = []
+        for c in "hello":
+            chars.append(c)
+        self.assertEqual(chars, ['h', 'e', 'l', 'l', 'o'])
+
+    def test_for_dict(self):
+        d = {'a': 1, 'b': 2}
+        keys = []
+        for k in d:
+            keys.append(k)
+        self.assertEqual(sorted(keys), ['a', 'b'])
+
+    def test_for_tuple_unpack(self):
+        pairs = [(1, 'a'), (2, 'b'), (3, 'c')]
+        nums = []
+        chars = []
+        for n, c in pairs:
+            nums.append(n)
+            chars.append(c)
+        self.assertEqual(nums, [1, 2, 3])
+        self.assertEqual(chars, ['a', 'b', 'c'])
+
+    def test_nested_for(self):
+        result = []
+        for i in range(3):
+            for j in range(3):
+                if i == j:
+                    result.append(i)
+        self.assertEqual(result, [0, 1, 2])
+
+    def test_for_break(self):
+        found = -1
+        for i in range(100):
+            if i * i > 50:
+                found = i
+                break
+        self.assertEqual(found, 8)
+
+    def test_for_continue(self):
+        evens = []
+        for i in range(10):
+            if i % 2 != 0:
+                continue
+            evens.append(i)
+        self.assertEqual(evens, [0, 2, 4, 6, 8])
+
+    def test_for_else(self):
+        hit = False
+        for i in range(5):
+            pass
+        else:
+            hit = True
+        self.assertTrue(hit)
+
+    def test_for_else_break(self):
+        hit = False
+        for i in range(5):
+            if i == 3:
+                break
+        else:
+            hit = True
+        self.assertFalse(hit)
+
+
+class PassTest(unittest.TestCase):
+
+    def test_pass_in_if(self):
+        if True:
+            pass
+        self.assertTrue(True)
+
+    def test_pass_in_class(self):
+        class Empty:
+            pass
+        self.assertIsNotNone(Empty)
+
+    def test_pass_in_function(self):
+        def f():
+            pass
+        self.assertIsNone(f())
+
+    def test_pass_in_loop(self):
+        for i in range(5):
+            pass
+        self.assertEqual(i, 4)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/cpython/test_global_nonlocal.py

@@ -0,0 +1,123 @@
+"""Tests for global and nonlocal statements"""
+
+import unittest
+
+
+class GlobalTest(unittest.TestCase):
+
+    def test_global_read(self):
+        x = 42
+        def f():
+            return x
+        self.assertEqual(f(), 42)
+
+    def test_global_write(self):
+        def f():
+            global _test_global_var
+            _test_global_var = 99
+        f()
+        self.assertEqual(_test_global_var, 99)
+
+    def test_global_in_nested(self):
+        result = []
+        def outer():
+            def inner():
+                global _test_nested_global
+                _test_nested_global = 42
+            inner()
+        outer()
+        self.assertEqual(_test_nested_global, 42)
+
+
+class NonlocalTest(unittest.TestCase):
+
+    def test_nonlocal_read(self):
+        def outer():
+            x = 10
+            def inner():
+                return x
+            return inner()
+        self.assertEqual(outer(), 10)
+
+    def test_nonlocal_write(self):
+        def outer():
+            x = 10
+            def inner():
+                nonlocal x
+                x = 20
+            inner()
+            return x
+        self.assertEqual(outer(), 20)
+
+    def test_nonlocal_counter(self):
+        def make_counter():
+            count = 0
+            def increment():
+                nonlocal count
+                count += 1
+                return count
+            return increment
+        c = make_counter()
+        self.assertEqual(c(), 1)
+        self.assertEqual(c(), 2)
+        self.assertEqual(c(), 3)
+
+    def test_nonlocal_multi_level(self):
+        def outer():
+            x = 0
+            def middle():
+                nonlocal x
+                x += 1
+                def inner():
+                    nonlocal x
+                    x += 10
+                inner()
+            middle()
+            return x
+        self.assertEqual(outer(), 11)
+
+    def test_nonlocal_multiple_vars(self):
+        def outer():
+            a = 1
+            b = 2
+            def inner():
+                nonlocal a, b
+                a, b = b, a
+            inner()
+            return a, b
+        self.assertEqual(outer(), (2, 1))
+
+
+class ScopeTest(unittest.TestCase):
+
+    def test_local_shadows_global(self):
+        x = 100
+        def f():
+            x = 200
+            return x
+        self.assertEqual(f(), 200)
+        self.assertEqual(x, 100)
+
+    def test_enclosing_scope(self):
+        def outer(x):
+            def inner(y):
+                return x + y
+            return inner
+        add5 = outer(5)
+        self.assertEqual(add5(3), 8)
+
+    def test_class_scope(self):
+        class C:
+            x = 42
+            def get_x(self):
+                return self.x
+        self.assertEqual(C().get_x(), 42)
+
+    def test_comprehension_scope(self):
+        x = 99
+        _ = [x for x in range(5)]
+        self.assertEqual(x, 99)  # comprehension doesn't leak
+
+
+if __name__ == "__main__":
+    unittest.main()