tests: Add ordered dict tests and benchmarks.

Signed-off-by: Andrew Leech <andrew.leech@planetinnovation.com.au>

Author: pi-anl

tests/basics/dict_compact_add.py

@@ -0,0 +1,87 @@
+# Check if dicts preserve insertion order (MICROPY_PY_MAP_ORDERED).
+if list({2: 0, 1: 0, 3: 0}.keys()) != [2, 1, 3]:
+    print("SKIP")
+    raise SystemExit
+
+
+# Test that in-place compact triggered by add (dense array full with tombstones)
+# correctly preserves all entries and allows the new add to succeed.
+
+# Fill a dict, delete entries to create tombstones, then add enough new entries
+# to trigger compact-on-add (wrap-around in hash probe). Verify all entries.
+d = {}
+for i in range(10):
+    d[i] = i * 10
+
+# Delete half the entries (creates tombstones in dense array).
+for i in range(0, 10, 2):
+    del d[i]
+
+# Add new entries. Eventually the dense array fills with tombstones + live entries,
+# triggering in-place compact on wrap-around instead of rehash.
+for i in range(100, 120):
+    d[i] = i * 10
+
+# Verify all expected keys are present with correct values.
+for i in range(1, 10, 2):
+    assert d[i] == i * 10, "original key {} has wrong value".format(i)
+for i in range(100, 120):
+    assert d[i] == i * 10, "new key {} has wrong value".format(i)
+
+# Verify deleted keys are gone.
+for i in range(0, 10, 2):
+    assert i not in d, "deleted key {} still present".format(i)
+
+print("compact-on-add: OK")
+print("len:", len(d))
+
+# Test insertion order is preserved after compact-on-add.
+keys = list(d.keys())
+expected = [1, 3, 5, 7, 9] + list(range(100, 120))
+assert keys == expected, "order wrong: {}".format(keys)
+print("order: OK")
+
+
+# Test with non-qstr keys (tuples have __hash__ via mp_unary_op).
+d2 = {}
+for i in range(8):
+    d2[(i, "x")] = i
+
+for i in range(0, 8, 2):
+    del d2[(i, "x")]
+
+for i in range(100, 110):
+    d2[(i, "x")] = i
+
+# Verify all entries.
+for i in range(1, 8, 2):
+    assert d2[(i, "x")] == i
+for i in range(100, 110):
+    assert d2[(i, "x")] == i
+
+print("non-qstr keys: OK")
+
+
+# Test hash index rebuild correctness after compact.
+# After compact, all probe chains in the hash index are rebuilt from scratch.
+# Use enough entries that the hash index is stressed across multiple probe steps.
+d3 = {}
+for i in range(12):
+    d3[i] = i
+
+for i in [0, 1, 2, 3]:
+    del d3[i]
+
+# Adding 10 more entries forces the dense array to fill and triggers compact.
+# The rebuilt hash index must correctly resolve all existing keys.
+for i in range(20, 30):
+    d3[i] = i
+
+for i in range(4, 12):
+    assert d3[i] == i, "key {} not found after hash rebuild".format(i)
+for i in range(20, 30):
+    assert d3[i] == i, "new key {} not found after hash rebuild".format(i)
+for i in range(0, 4):
+    assert i not in d3
+
+print("hash index rebuild: OK")

tests/basics/dict_popitem_ordered.py

@@ -0,0 +1,55 @@
+# Check if dicts preserve insertion order (MICROPY_PY_MAP_ORDERED).
+if list({2: 0, 1: 0, 3: 0}.keys()) != [2, 1, 3]:
+    print("SKIP")
+    raise SystemExit
+
+
+# Test dict.popitem() returns items in LIFO order and leaves the dict consistent.
+
+# Pop entire dict, verify all entries are returned in LIFO order.
+d = {}
+for i in range(5):
+    d[i] = i * 10
+items = []
+while d:
+    items.append(d.popitem())
+print("all items:", items)
+
+# Interleaved popitem and add: verify remaining dict is consistent.
+d = {1: 10, 2: 20, 3: 30}
+print(d.popitem())
+d[4] = 40
+d[5] = 50
+print(d.popitem())
+print(d.popitem())
+print("remaining:", sorted(d.items()))
+
+# popitem after del (mixed operations).
+d = {}
+for i in range(8):
+    d[i] = i
+del d[3]
+del d[5]
+# Remaining: 0,1,2,4,6,7 -- popitem should pop from end.
+p1 = d.popitem()
+p2 = d.popitem()
+print("after del pops:", p1, p2)
+# Verify remaining keys are accessible.
+for k in list(d.keys()):
+    assert d[k] == k, "key {} has wrong value after mixed ops".format(k)
+print("remaining keys:", sorted(d.keys()))
+
+# Pop everything after deletes.
+d = {1: 10, 2: 20, 3: 30, 4: 40, 5: 50}
+del d[2]
+del d[4]
+items = []
+while d:
+    items.append(d.popitem())
+print("pop-all after del:", items)
+
+# Verify popitem on empty dict raises KeyError.
+try:
+    {}.popitem()
+except KeyError:
+    print("empty popitem: KeyError")

tests/basics/slice_optimise.py

@@ -16,12 +16,17 @@
 except KeyError as e:
     print("KeyError", e.args)
 
-# Verify slice-as-key in OrderedDict works or raises TypeError depending
-# on whether the ordered hash table is enabled (slices are not hashable).
+# Slice-as-key in OrderedDict: when backed by the ordered hash table
+# (MICROPY_PY_MAP_ORDERED=1) slices are not hashable so TypeError is raised.
+# When backed by linear scan (MAP_ORDERED=0) slices work as keys.
 x = OrderedDict()
 try:
     x[:"a"] = 1
     x["b"] = 2
+    # Linear scan path: verify keys and values are correct.
+    assert list(x.keys()) == [slice(None, "a", None), "b"]
+    assert list(x.values()) == [1, 2]
+    print("slice key OK")
 except TypeError:
-    pass
-print("OrderedDict slice test OK")
+    # Hash table path: slices not hashable, this is expected.
+    print("slice key TypeError")

tests/basics/slice_optimise.py.exp

@@ -1,2 +1,2 @@
 KeyError (slice(None, None, None),)
-OrderedDict slice test OK
+slice key TypeError

tests/micropython/dict_compact_empty.py

@@ -0,0 +1,38 @@
+# Test that deleting the last element doesn't cause issues.
+# Compaction is skipped when dict becomes empty (filled == 0).
+
+# Test 1: Delete all entries one by one
+d = {1: "a", 2: "b", 3: "c"}
+del d[1]
+del d[2]
+del d[3]
+print(len(d))
+
+# Dict should work normally after being emptied
+d[10] = "x"
+print(d[10])
+print(len(d))
+
+# Test 2: Single element dict
+d2 = {42: "only"}
+del d2[42]
+print(len(d2))
+d2[100] = "new"
+print(d2[100])
+
+# Test 3: Empty via popitem
+d3 = {"a": 1, "b": 2}
+d3.popitem()
+d3.popitem()
+print(len(d3))
+d3["c"] = 3
+print(d3["c"])
+
+# Test 4: Repeated empty/fill cycles
+d4 = {}
+for cycle in range(5):
+    for i in range(10):
+        d4[i] = cycle
+    for i in range(10):
+        del d4[i]
+print("cycles OK, len:", len(d4))

tests/micropython/dict_compact_empty.py.exp

@@ -0,0 +1,8 @@
+0
+x
+1
+0
+new
+0
+3
+cycles OK, len: 0

tests/micropython/dict_compact_order.py

@@ -0,0 +1,44 @@
+# Check if dicts preserve insertion order (MICROPY_PY_MAP_ORDERED).
+if list({2: 0, 1: 0, 3: 0}.keys()) != [2, 1, 3]:
+    print("SKIP")
+    raise SystemExit
+
+
+# Test that dict ordering is preserved after compaction.
+# When tombstones exceed 50% of live entries, the dict compacts.
+# This must preserve insertion order.
+
+d = {}
+for i in range(100):
+    d[i] = i
+
+# Delete 67 entries: filled=33, tombstones=67
+# Threshold = 33/2 = 16, and 67 > 16, so compaction triggers
+for i in range(67):
+    del d[i]
+
+# Remaining keys must be in insertion order
+print(list(d.keys()))
+
+# Values should also be correct (spot check)
+print(d[67], d[80], d[99])
+
+# Dict should still be usable after compaction
+d[200] = 200
+d[201] = 201
+keys = list(d.keys())
+print(keys[-3], keys[-2], keys[-1])
+
+# Test with mixed key types (strings and ints)
+d2 = {}
+for i in range(20):
+    d2[i] = i
+    d2["key" + str(i)] = "val" + str(i)
+
+# Delete enough to trigger compaction
+for i in range(15):
+    del d2[i]
+    del d2["key" + str(i)]
+
+# Remaining should preserve insertion order
+print(list(d2.keys()))

tests/micropython/dict_compact_order.py.exp

@@ -0,0 +1,4 @@
+[67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
+67 80 99
+99 200 201
+[15, 'key15', 16, 'key16', 17, 'key17', 18, 'key18', 19, 'key19']

tests/micropython/dict_compact_stress.py

@@ -0,0 +1,56 @@
+# Stress test for dict compaction.
+# Without compaction, repeated add/delete cycles would cause unbounded
+# memory growth from tombstone accumulation.
+
+try:
+    import gc
+except ImportError:
+    print("SKIP")
+    raise SystemExit
+
+d = {}
+
+# Run many add/delete cycles
+# Without compaction, this would accumulate 50 * 100 = 5000 tombstones
+for cycle in range(50):
+    # Add entries
+    for i in range(100):
+        d[i] = i * cycle
+
+    # Delete all entries
+    for i in range(100):
+        del d[i]
+
+# If we got here without MemoryError, basic compaction is working
+print("pass1")
+
+# Test with popitem too
+d2 = {}
+for cycle in range(50):
+    for i in range(100):
+        d2[i] = i
+    for _ in range(100):
+        d2.popitem()
+
+print("pass2")
+
+# Test mixed operations
+d3 = {}
+for cycle in range(30):
+    # Add 200 entries
+    for i in range(200):
+        d3[i] = i
+
+    # Delete half via del
+    for i in range(100):
+        del d3[i]
+
+    # Delete rest via popitem
+    for _ in range(100):
+        d3.popitem()
+
+print("pass3")
+
+# Force GC and verify we haven't leaked too much memory
+gc.collect()
+print("pass4")

tests/micropython/dict_compact_stress.py.exp

@@ -0,0 +1,4 @@
+pass1
+pass2
+pass3
+pass4