Import test_decorators_extra, test_walrus, test_match, test_datastructures

New tests:
- test_decorators_extra.py: 8 tests — function/class/method decorators,
  stacked, with args, staticmethod, classmethod, property
- test_walrus.py: 5 tests — assignment expressions in if/while/listcomp
- test_match.py: 8 tests — match/case with literals, strings, capture,
  or-pattern, guard, tuple pattern, None/True/False patterns
- test_datastructures.py: 14 tests — nested structures, frequency count,
  groupby, sorting with key/reverse, stable sort

Total CPython test suites: 60

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

Author: jgarzik

Makefile

@@ -159,6 +159,10 @@ gen-cpython-tests:
 	@$(PYTHON) -m py_compile tests/cpython/test_slice_ops.py
 	@$(PYTHON) -m py_compile tests/cpython/test_numeric.py
 	@$(PYTHON) -m py_compile tests/cpython/test_comprehensions.py
+	@$(PYTHON) -m py_compile tests/cpython/test_decorators_extra.py
+	@$(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
 	@echo "Done."
 
 check-cpython: $(TARGET) gen-cpython-tests
@@ -274,3 +278,11 @@ check-cpython: $(TARGET) gen-cpython-tests
 	@./apython tests/cpython/__pycache__/test_numeric.cpython-312.pyc
 	@echo "Running CPython test_comprehensions.py..."
 	@./apython tests/cpython/__pycache__/test_comprehensions.cpython-312.pyc
+	@echo "Running CPython test_decorators_extra.py..."
+	@./apython tests/cpython/__pycache__/test_decorators_extra.cpython-312.pyc
+	@echo "Running CPython test_walrus.py..."
+	@./apython tests/cpython/__pycache__/test_walrus.cpython-312.pyc
+	@echo "Running CPython test_match.py..."
+	@./apython tests/cpython/__pycache__/test_match.cpython-312.pyc
+	@echo "Running CPython test_datastructures.py..."
+	@./apython tests/cpython/__pycache__/test_datastructures.cpython-312.pyc

tests/cpython/test_datastructures.py

@@ -0,0 +1,103 @@
+"""Tests for data structure operations — mixed-type scenarios"""
+
+import unittest
+
+
+class NestedStructTest(unittest.TestCase):
+
+    def test_list_of_dicts(self):
+        data = [{"name": "a", "val": 1}, {"name": "b", "val": 2}]
+        self.assertEqual(data[0]["name"], "a")
+        self.assertEqual(data[1]["val"], 2)
+
+    def test_dict_of_lists(self):
+        d = {"evens": [0, 2, 4], "odds": [1, 3, 5]}
+        self.assertEqual(d["evens"][1], 2)
+        self.assertEqual(d["odds"][2], 5)
+
+    def test_nested_list(self):
+        matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+        flat = [x for row in matrix for x in row]
+        self.assertEqual(flat, [1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+    def test_list_of_tuples(self):
+        pairs = [(1, 'a'), (2, 'b'), (3, 'c')]
+        keys = [k for k, v in pairs]
+        vals = [v for k, v in pairs]
+        self.assertEqual(keys, [1, 2, 3])
+        self.assertEqual(vals, ['a', 'b', 'c'])
+
+    def test_dict_from_zip(self):
+        keys = ['a', 'b', 'c']
+        vals = [1, 2, 3]
+        d = {}
+        for k, v in zip(keys, vals):
+            d[k] = v
+        self.assertEqual(d['b'], 2)
+
+    def test_set_from_list(self):
+        data = [1, 2, 2, 3, 3, 3]
+        unique = sorted(list(set(data)))
+        self.assertEqual(unique, [1, 2, 3])
+
+    def test_stack(self):
+        stack = []
+        stack.append(1)
+        stack.append(2)
+        stack.append(3)
+        self.assertEqual(stack.pop(), 3)
+        self.assertEqual(stack.pop(), 2)
+        self.assertEqual(len(stack), 1)
+
+    def test_queue_via_list(self):
+        q = []
+        q.append("first")
+        q.append("second")
+        q.append("third")
+        self.assertEqual(q.pop(0), "first")
+        self.assertEqual(q.pop(0), "second")
+
+    def test_frequency_count(self):
+        text = "abracadabra"
+        freq = {}
+        for ch in text:
+            freq[ch] = freq.get(ch, 0) + 1
+        self.assertEqual(freq['a'], 5)
+        self.assertEqual(freq['b'], 2)
+
+    def test_groupby_manual(self):
+        data = [("a", 1), ("b", 2), ("a", 3), ("b", 4)]
+        groups = {}
+        for key, val in data:
+            if key not in groups:
+                groups[key] = []
+            groups[key].append(val)
+        self.assertEqual(groups["a"], [1, 3])
+        self.assertEqual(groups["b"], [2, 4])
+
+
+class SortingTest(unittest.TestCase):
+
+    def test_sort_key(self):
+        data = ["banana", "apple", "cherry"]
+        data.sort(key=len)
+        self.assertEqual(data, ["apple", "banana", "cherry"])
+
+    def test_sorted_key(self):
+        data = [(3, "c"), (1, "a"), (2, "b")]
+        result = sorted(data, key=lambda x: x[0])
+        self.assertEqual(result, [(1, "a"), (2, "b"), (3, "c")])
+
+    def test_reverse_sort(self):
+        data = [3, 1, 4, 1, 5]
+        self.assertEqual(sorted(data, reverse=True), [5, 4, 3, 1, 1])
+
+    def test_stable_sort(self):
+        data = [(1, 'b'), (2, 'a'), (1, 'a'), (2, 'b')]
+        result = sorted(data, key=lambda x: x[0])
+        self.assertEqual(result[0], (1, 'b'))
+        self.assertEqual(result[1], (1, 'a'))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/cpython/test_decorators_extra.py

@@ -0,0 +1,104 @@
+"""Extra decorator tests"""
+
+import unittest
+
+
+class DecoratorTest(unittest.TestCase):
+
+    def test_function_decorator(self):
+        def double(f):
+            def wrapper(*args):
+                return f(*args) * 2
+            return wrapper
+        @double
+        def add(a, b):
+            return a + b
+        self.assertEqual(add(3, 4), 14)
+
+    def test_stacked_decorators(self):
+        def add_one(f):
+            def w(*a):
+                return f(*a) + 1
+            return w
+        def times_two(f):
+            def w(*a):
+                return f(*a) * 2
+            return w
+        @add_one
+        @times_two
+        def val():
+            return 5
+        # times_two applied first: 5*2=10, then add_one: 10+1=11
+        self.assertEqual(val(), 11)
+
+    def test_decorator_with_args(self):
+        def repeat(n):
+            def decorator(f):
+                def wrapper(*args):
+                    return [f(*args) for _ in range(n)]
+                return wrapper
+            return decorator
+        @repeat(3)
+        def greet():
+            return "hi"
+        self.assertEqual(greet(), ["hi", "hi", "hi"])
+
+    def test_class_decorator(self):
+        def add_method(cls):
+            cls.extra = lambda self: 42
+            return cls
+        @add_method
+        class C:
+            pass
+        self.assertEqual(C().extra(), 42)
+
+    def test_method_decorator(self):
+        def log(f):
+            def wrapper(self, *args):
+                self.calls.append(f.__name__)
+                return f(self, *args)
+            return wrapper
+        class C:
+            def __init__(self):
+                self.calls = []
+            @log
+            def do_thing(self):
+                return "done"
+        obj = C()
+        obj.do_thing()
+        self.assertEqual(obj.calls, ["do_thing"])
+
+    def test_staticmethod(self):
+        class C:
+            @staticmethod
+            def f(x):
+                return x + 1
+        self.assertEqual(C.f(5), 6)
+        self.assertEqual(C().f(5), 6)
+
+    def test_classmethod(self):
+        class C:
+            val = 10
+            @classmethod
+            def get_val(cls):
+                return cls.val
+        self.assertEqual(C.get_val(), 10)
+
+    def test_property_decorator(self):
+        class C:
+            def __init__(self, x):
+                self._x = x
+            @property
+            def x(self):
+                return self._x
+            @x.setter
+            def x(self, val):
+                self._x = val
+        obj = C(10)
+        self.assertEqual(obj.x, 10)
+        obj.x = 20
+        self.assertEqual(obj.x, 20)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/cpython/test_match.py

@@ -0,0 +1,107 @@
+"""Tests for match statement (PEP 634)"""
+
+import unittest
+
+
+class MatchBasicTest(unittest.TestCase):
+
+    def test_literal(self):
+        def f(x):
+            match x:
+                case 1:
+                    return "one"
+                case 2:
+                    return "two"
+                case _:
+                    return "other"
+        self.assertEqual(f(1), "one")
+        self.assertEqual(f(2), "two")
+        self.assertEqual(f(99), "other")
+
+    def test_string_literal(self):
+        def f(cmd):
+            match cmd:
+                case "start":
+                    return 1
+                case "stop":
+                    return 0
+                case _:
+                    return -1
+        self.assertEqual(f("start"), 1)
+        self.assertEqual(f("stop"), 0)
+        self.assertEqual(f("other"), -1)
+
+    def test_capture(self):
+        def f(x):
+            match x:
+                case [a, b]:
+                    return a + b
+                case _:
+                    return -1
+        self.assertEqual(f([10, 20]), 30)
+
+    def test_or_pattern(self):
+        def f(x):
+            match x:
+                case 1 | 2 | 3:
+                    return "small"
+                case _:
+                    return "big"
+        self.assertEqual(f(1), "small")
+        self.assertEqual(f(2), "small")
+        self.assertEqual(f(5), "big")
+
+    def test_guard(self):
+        def f(x):
+            match x:
+                case n if n > 0:
+                    return "positive"
+                case n if n < 0:
+                    return "negative"
+                case _:
+                    return "zero"
+        self.assertEqual(f(5), "positive")
+        self.assertEqual(f(-3), "negative")
+        self.assertEqual(f(0), "zero")
+
+    def test_tuple_pattern(self):
+        def f(point):
+            match point:
+                case (0, 0):
+                    return "origin"
+                case (x, 0):
+                    return "x-axis"
+                case (0, y):
+                    return "y-axis"
+                case (x, y):
+                    return "other"
+        self.assertEqual(f((0, 0)), "origin")
+        self.assertEqual(f((5, 0)), "x-axis")
+        self.assertEqual(f((0, 3)), "y-axis")
+        self.assertEqual(f((1, 2)), "other")
+
+    def test_none_pattern(self):
+        def f(x):
+            match x:
+                case None:
+                    return "none"
+                case _:
+                    return "something"
+        self.assertEqual(f(None), "none")
+        self.assertEqual(f(42), "something")
+
+    def test_bool_pattern(self):
+        def f(x):
+            match x:
+                case True:
+                    return "true"
+                case False:
+                    return "false"
+                case _:
+                    return "other"
+        self.assertEqual(f(True), "true")
+        self.assertEqual(f(False), "false")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/cpython/test_walrus.py

@@ -0,0 +1,39 @@
+"""Tests for walrus operator (:=) — assignment expressions"""
+
+import unittest
+
+
+class WalrusTest(unittest.TestCase):
+
+    def test_basic(self):
+        if (n := 10) > 5:
+            result = n
+        self.assertEqual(result, 10)
+
+    def test_in_while(self):
+        data = [1, 2, 3, 0, 4, 5]
+        idx = 0
+        result = []
+        while (val := data[idx]) != 0:
+            result.append(val)
+            idx += 1
+        self.assertEqual(result, [1, 2, 3])
+
+    def test_in_list_comp(self):
+        results = [y for x in range(5) if (y := x * x) > 5]
+        self.assertEqual(results, [9, 16])
+
+    def test_in_expression(self):
+        x = [y := 42]
+        self.assertEqual(x, [42])
+        self.assertEqual(y, 42)
+
+    def test_nested(self):
+        a = (b := (c := 5) + 1) + 2
+        self.assertEqual(c, 5)
+        self.assertEqual(b, 6)
+        self.assertEqual(a, 8)
+
+
+if __name__ == "__main__":
+    unittest.main()