Add 2-arg next(); import test_extcall, test_iter, test_lambda, test_property, test_string

Infrastructure:
- builtin next(iterator, default): return default on StopIteration
  instead of raising (2-arg form)

New tests:
- test_extcall.py: 12 tests — star args, kwargs, mixed calls, defaults
- test_iter.py: 25 tests — iter protocol, for loops, enumerate, zip,
  map, filter, reversed, sorted, sum, min/max, any/all, custom iterators
- test_lambda.py: 12 tests — closures, defaults, varargs, callbacks
- test_property.py: 10 tests, 1 skip — property, staticmethod, classmethod
- test_string.py: 21 tests — f-strings, % format, methods, slicing

Total CPython test suites: 34

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

Author: jgarzik

Makefile

@@ -114,6 +114,16 @@ gen-cpython-tests:
 	@$(PYTHON) -m py_compile tests/cpython/test_opcodes.py
 	@echo "Compiling tests/cpython/test_baseexception.py..."
 	@$(PYTHON) -m py_compile tests/cpython/test_baseexception.py
+	@echo "Compiling tests/cpython/test_extcall.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_extcall.py
+	@echo "Compiling tests/cpython/test_iter.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_iter.py
+	@echo "Compiling tests/cpython/test_lambda.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_lambda.py
+	@echo "Compiling tests/cpython/test_property.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_property.py
+	@echo "Compiling tests/cpython/test_string.py..."
+	@$(PYTHON) -m py_compile tests/cpython/test_string.py
 	@echo "Done."
 
 check-cpython: $(TARGET) gen-cpython-tests
@@ -175,3 +185,13 @@ check-cpython: $(TARGET) gen-cpython-tests
 	@./apython tests/cpython/__pycache__/test_opcodes.cpython-312.pyc
 	@echo "Running CPython test_baseexception.py..."
 	@./apython tests/cpython/__pycache__/test_baseexception.cpython-312.pyc
+	@echo "Running CPython test_extcall.py..."
+	@./apython tests/cpython/__pycache__/test_extcall.cpython-312.pyc
+	@echo "Running CPython test_iter.py..."
+	@./apython tests/cpython/__pycache__/test_iter.cpython-312.pyc
+	@echo "Running CPython test_lambda.py..."
+	@./apython tests/cpython/__pycache__/test_lambda.cpython-312.pyc
+	@echo "Running CPython test_property.py..."
+	@./apython tests/cpython/__pycache__/test_property.cpython-312.pyc
+	@echo "Running CPython test_string.py..."
+	@./apython tests/cpython/__pycache__/test_string.cpython-312.pyc

src/builtins_extra.asm

@@ -1692,7 +1692,54 @@ DEF_FUNC builtin_next_fn
     push rbx
 
     cmp rsi, 1
-    jne .next_error
+    je .next_one_arg
+    cmp rsi, 2
+    je .next_two_args
+    jmp .next_error
+
+.next_two_args:
+    ; next(iterator, default) — return default on StopIteration
+    push qword [rdi + 24]          ; save default tag
+    push qword [rdi + 16]          ; save default payload
+    ; Fall through to same iterator logic, but with default on stack
+    cmp qword [rdi + 8], TAG_PTR
+    jne .next_two_type_error
+    mov rdi, [rdi]                 ; args[0] = iterator
+    mov rax, [rdi + PyObject.ob_type]
+    mov rax, [rax + PyTypeObject.tp_iternext]
+    test rax, rax
+    jz .next_two_type_error
+    call rax
+    test edx, edx
+    jz .next_two_default           ; exhausted → return default
+    ; Got value — discard saved default
+    add rsp, 16
+    pop rbx
+    leave
+    ret
+.next_two_default:
+    ; Clear any StopIteration exception
+    extern current_exception
+    mov rax, [rel current_exception]
+    test rax, rax
+    jz .next_two_ret_default
+    push rdi
+    mov rdi, rax
+    mov qword [rel current_exception], 0
+    call obj_decref
+    pop rdi
+.next_two_ret_default:
+    pop rax                        ; default payload
+    pop rdx                        ; default tag
+    INCREF_VAL rax, rdx
+    pop rbx
+    leave
+    ret
+.next_two_type_error:
+    add rsp, 16                    ; discard saved default
+    jmp .next_type_error
+
+.next_one_arg:
 
     cmp qword [rdi + 8], TAG_SMALLINT  ; check args[0] tag
     je .next_type_error

tests/cpython/test_extcall.py

@@ -0,0 +1,84 @@
+"""Tests for extended function call syntax — adapted from CPython test_extcall.py"""
+
+import unittest
+
+
+class ExtCallTest(unittest.TestCase):
+
+    def test_basic_star_args(self):
+        def f(*args):
+            return args
+        self.assertEqual(f(*(1, 2, 3)), (1, 2, 3))
+        self.assertEqual(f(*[1, 2, 3]), (1, 2, 3))
+
+    def test_basic_kwargs(self):
+        def f(**kwargs):
+            return kwargs
+        self.assertEqual(f(**{'a': 1, 'b': 2}), {'a': 1, 'b': 2})
+        self.assertEqual(f(), {})
+
+    def test_mixed_args_kwargs(self):
+        def f(*args, **kwargs):
+            return args, kwargs
+        self.assertEqual(f(1, 2, a=3), ((1, 2), {'a': 3}))
+        self.assertEqual(f(*(1, 2), **{'a': 3}), ((1, 2), {'a': 3}))
+
+    def test_positional_and_star(self):
+        def f(a, b, c):
+            return a + b + c
+        self.assertEqual(f(1, *(2, 3)), 6)
+        self.assertEqual(f(*(1, 2, 3)), 6)
+
+    def test_keyword_args(self):
+        def f(a, b=10, c=20):
+            return (a, b, c)
+        self.assertEqual(f(1), (1, 10, 20))
+        self.assertEqual(f(1, b=2), (1, 2, 20))
+        self.assertEqual(f(1, c=3), (1, 10, 3))
+        self.assertEqual(f(1, b=2, c=3), (1, 2, 3))
+
+    def test_keyword_only_args(self):
+        def f(a, *, b, c=10):
+            return (a, b, c)
+        self.assertEqual(f(1, b=2), (1, 2, 10))
+        self.assertEqual(f(1, b=2, c=3), (1, 2, 3))
+
+    def test_star_in_call(self):
+        def f(a, b, c, d):
+            return a * 1000 + b * 100 + c * 10 + d
+        self.assertEqual(f(1, *(2, 3), **{'d': 4}), 1234)
+
+    def test_double_star_dict(self):
+        def f(**kw):
+            return sorted(kw.items())
+        d = {'a': 1, 'b': 2}
+        self.assertEqual(f(**d), [('a', 1), ('b', 2)])
+
+    def test_default_args(self):
+        def f(a, b=2, c=3):
+            return (a, b, c)
+        self.assertEqual(f(1), (1, 2, 3))
+        self.assertEqual(f(1, 5), (1, 5, 3))
+        self.assertEqual(f(1, 5, 7), (1, 5, 7))
+
+    def test_varargs_and_defaults(self):
+        def f(a, b=10, *args):
+            return (a, b, args)
+        self.assertEqual(f(1), (1, 10, ()))
+        self.assertEqual(f(1, 2), (1, 2, ()))
+        self.assertEqual(f(1, 2, 3, 4), (1, 2, (3, 4)))
+
+    def test_too_few_args(self):
+        def f(a, b):
+            pass
+        self.assertRaises(TypeError, f)
+        self.assertRaises(TypeError, f, 1)
+
+    def test_too_many_args(self):
+        def f(a):
+            pass
+        self.assertRaises(TypeError, f, 1, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/cpython/test_iter.py

@@ -0,0 +1,173 @@
+"""Tests for iterator protocol — adapted from CPython test_iter.py"""
+
+import unittest
+
+
+class BasicIterTest(unittest.TestCase):
+
+    def test_iter_list(self):
+        self.assertEqual(list(iter([1, 2, 3])), [1, 2, 3])
+
+    def test_iter_tuple(self):
+        self.assertEqual(list(iter((1, 2, 3))), [1, 2, 3])
+
+    def test_iter_string(self):
+        self.assertEqual(list(iter("abc")), ['a', 'b', 'c'])
+
+    def test_iter_range(self):
+        self.assertEqual(list(iter(range(5))), [0, 1, 2, 3, 4])
+
+    def test_iter_dict_keys(self):
+        d = {'a': 1, 'b': 2, 'c': 3}
+        keys = list(iter(d))
+        self.assertEqual(sorted(keys), ['a', 'b', 'c'])
+
+    def test_next_with_default(self):
+        it = iter([1])
+        self.assertEqual(next(it), 1)
+        self.assertEqual(next(it, 'default'), 'default')
+
+    def test_stopiteration(self):
+        it = iter([])
+        self.assertRaises(StopIteration, next, it)
+
+    def test_for_loop(self):
+        result = []
+        for x in [1, 2, 3]:
+            result.append(x)
+        self.assertEqual(result, [1, 2, 3])
+
+    def test_for_loop_break(self):
+        result = []
+        for x in range(10):
+            if x == 5:
+                break
+            result.append(x)
+        self.assertEqual(result, [0, 1, 2, 3, 4])
+
+    def test_for_loop_continue(self):
+        result = []
+        for x in range(10):
+            if x % 2 == 0:
+                continue
+            result.append(x)
+        self.assertEqual(result, [1, 3, 5, 7, 9])
+
+    def test_for_else(self):
+        hit_else = False
+        for x in range(3):
+            pass
+        else:
+            hit_else = True
+        self.assertTrue(hit_else)
+
+    def test_for_else_break(self):
+        hit_else = False
+        for x in range(3):
+            break
+        else:
+            hit_else = True
+        self.assertFalse(hit_else)
+
+    def test_nested_for(self):
+        result = []
+        for x in range(3):
+            for y in range(3):
+                result.append((x, y))
+        self.assertEqual(len(result), 9)
+        self.assertEqual(result[0], (0, 0))
+        self.assertEqual(result[-1], (2, 2))
+
+    def test_enumerate(self):
+        self.assertEqual(list(enumerate('abc')),
+                         [(0, 'a'), (1, 'b'), (2, 'c')])
+        self.assertEqual(list(enumerate('abc', 1)),
+                         [(1, 'a'), (2, 'b'), (3, 'c')])
+
+    def test_zip(self):
+        self.assertEqual(list(zip([1, 2], [3, 4])),
+                         [(1, 3), (2, 4)])
+        self.assertEqual(list(zip([1, 2, 3], [4, 5])),
+                         [(1, 4), (2, 5)])
+
+    def test_map(self):
+        def double(x):
+            return x * 2
+        self.assertEqual(list(map(double, [1, 2, 3])), [2, 4, 6])
+
+    def test_filter(self):
+        def is_even(x):
+            return x % 2 == 0
+        self.assertEqual(list(filter(is_even, range(10))),
+                         [0, 2, 4, 6, 8])
+
+    def test_reversed(self):
+        self.assertEqual(list(reversed([1, 2, 3])), [3, 2, 1])
+        self.assertEqual(list(reversed(range(5))), [4, 3, 2, 1, 0])
+
+    def test_sorted(self):
+        self.assertEqual(sorted([3, 1, 2]), [1, 2, 3])
+        self.assertEqual(sorted([3, 1, 2], reverse=True), [3, 2, 1])
+
+    def test_sum(self):
+        self.assertEqual(sum([1, 2, 3]), 6)
+        self.assertEqual(sum(range(10)), 45)
+        self.assertEqual(sum([], 10), 10)
+
+    def test_min_max(self):
+        self.assertEqual(min([3, 1, 2]), 1)
+        self.assertEqual(max([3, 1, 2]), 3)
+        self.assertEqual(min(3, 1, 2), 1)
+        self.assertEqual(max(3, 1, 2), 3)
+
+    def test_any_all(self):
+        self.assertTrue(any([0, 0, 1]))
+        self.assertFalse(any([0, 0, 0]))
+        self.assertTrue(all([1, 1, 1]))
+        self.assertFalse(all([1, 0, 1]))
+        self.assertTrue(any(x > 3 for x in range(5)))
+        self.assertTrue(all(x < 5 for x in range(5)))
+
+
+class CustomIterTest(unittest.TestCase):
+
+    def test_iter_protocol(self):
+        class MyIter:
+            def __init__(self, data):
+                self.data = data
+                self.idx = 0
+            def __iter__(self):
+                return self
+            def __next__(self):
+                if self.idx >= len(self.data):
+                    raise StopIteration
+                val = self.data[self.idx]
+                self.idx += 1
+                return val
+        self.assertEqual(list(MyIter([10, 20, 30])), [10, 20, 30])
+
+    def test_getitem_protocol(self):
+        class MySeq:
+            def __init__(self, data):
+                self.data = data
+            def __getitem__(self, idx):
+                return self.data[idx]
+        self.assertEqual(list(MySeq([1, 2, 3])), [1, 2, 3])
+
+    def test_iter_in_for(self):
+        class Counter:
+            def __init__(self, n):
+                self.n = n
+                self.i = 0
+            def __iter__(self):
+                return self
+            def __next__(self):
+                if self.i >= self.n:
+                    raise StopIteration
+                self.i += 1
+                return self.i
+        self.assertEqual(list(Counter(5)), [1, 2, 3, 4, 5])
+
+
+if __name__ == "__main__":
+    unittest.main()