rapydscript-ns 0.9.2 → 0.9.4

package/test/bisect.pyj

@@ -0,0 +1,178 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# bisect.pyj
+# Tests for the bisect standard library module.
+
+from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+# ── 1. bisect_left — basic ────────────────────────────────────────────────────
+
+_a = [1, 3, 5, 7, 9]
+
+ae(bisect_left(_a, 0), 0)   # before all
+ae(bisect_left(_a, 1), 0)   # at first element (left of existing)
+ae(bisect_left(_a, 2), 1)   # between 1 and 3
+ae(bisect_left(_a, 3), 1)   # at existing element (left)
+ae(bisect_left(_a, 5), 2)
+ae(bisect_left(_a, 6), 3)   # between 5 and 7
+ae(bisect_left(_a, 9), 4)   # at last element (left)
+ae(bisect_left(_a, 10), 5)  # after all
+
+# ── 2. bisect_right — basic ───────────────────────────────────────────────────
+
+ae(bisect_right(_a, 0), 0)   # before all
+ae(bisect_right(_a, 1), 1)   # at first element (right of existing)
+ae(bisect_right(_a, 2), 1)   # between 1 and 3
+ae(bisect_right(_a, 3), 2)   # at existing element (right)
+ae(bisect_right(_a, 5), 3)
+ae(bisect_right(_a, 6), 3)   # between 5 and 7
+ae(bisect_right(_a, 9), 5)   # at last element (right)
+ae(bisect_right(_a, 10), 5)  # after all
+
+# ── 3. bisect alias ───────────────────────────────────────────────────────────
+
+ae(bisect(_a, 3), bisect_right(_a, 3))
+ae(bisect(_a, 5), bisect_right(_a, 5))
+
+# ── 4. Empty list ─────────────────────────────────────────────────────────────
+
+ae(bisect_left([], 5), 0)
+ae(bisect_right([], 5), 0)
+
+# ── 5. All elements equal ─────────────────────────────────────────────────────
+
+_eq = [3, 3, 3, 3, 3]
+ae(bisect_left(_eq, 3), 0)
+ae(bisect_right(_eq, 3), 5)
+ae(bisect_left(_eq, 2), 0)
+ae(bisect_right(_eq, 2), 0)
+ae(bisect_left(_eq, 4), 5)
+ae(bisect_right(_eq, 4), 5)
+
+# ── 6. Single-element list ────────────────────────────────────────────────────
+
+_one = [5]
+ae(bisect_left(_one, 5), 0)
+ae(bisect_right(_one, 5), 1)
+ae(bisect_left(_one, 4), 0)
+ae(bisect_right(_one, 6), 1)
+
+# ── 7. lo and hi bounds ───────────────────────────────────────────────────────
+
+_b = [1, 3, 5, 7, 9]
+# search only in [3, 5, 7] (indices 1..3)
+ae(bisect_left(_b, 3, 1, 4), 1)
+ae(bisect_right(_b, 3, 1, 4), 2)
+ae(bisect_left(_b, 6, 1, 4), 3)
+
+# lo == hi: insertion point is lo regardless of x
+ae(bisect_left(_b, 5, 2, 2), 2)
+ae(bisect_right(_b, 5, 2, 2), 2)
+
+# ── 8. ValueError for negative lo ────────────────────────────────────────────
+
+_neg_lo_raised = False
+try:
+    bisect_left([1, 2], 1, -1)
+except ValueError:
+    _neg_lo_raised = True
+ok(_neg_lo_raised, 'bisect_left with negative lo should raise ValueError')
+
+_neg_lo_raised2 = False
+try:
+    bisect_right([1, 2], 1, -1)
+except ValueError:
+    _neg_lo_raised2 = True
+ok(_neg_lo_raised2, 'bisect_right with negative lo should raise ValueError')
+
+# ── 9. insort_left — basic ────────────────────────────────────────────────────
+
+_il = [1, 3, 5, 7]
+insort_left(_il, 4)
+ade(_il, [1, 3, 4, 5, 7])
+
+insort_left(_il, 3)    # insert at left of equal elements
+ae(_il[1], 3)
+ae(_il[2], 3)
+ae(_il.length, 6)
+
+# ── 10. insort_right — basic ──────────────────────────────────────────────────
+
+_ir = [1, 3, 5, 7]
+insort_right(_ir, 4)
+ade(_ir, [1, 3, 4, 5, 7])
+
+insort_right(_ir, 3)   # insert at right of equal elements — new 3 goes at index 2
+ade(_ir, [1, 3, 3, 4, 5, 7])
+ae(_ir.length, 6)
+
+# ── 11. insort alias ──────────────────────────────────────────────────────────
+
+_ins = [2, 4, 6]
+insort(_ins, 5)
+ade(_ins, [2, 4, 5, 6])
+
+# ── 12. insort builds a sorted list from scratch ──────────────────────────────
+
+_scratch = []
+for _v in [5, 1, 3, 2, 4]:
+    insort(_scratch, _v)
+ade(_scratch, [1, 2, 3, 4, 5])
+
+# ── 13. Strings (lexicographic) ───────────────────────────────────────────────
+
+_s = ['bar', 'baz', 'foo', 'qux']
+ae(bisect_left(_s, 'baz'), 1)
+ae(bisect_right(_s, 'baz'), 2)
+ae(bisect_left(_s, 'car'), 2)    # 'car' > 'baz' and < 'foo'
+ae(bisect_right(_s, 'car'), 2)
+
+# ── 14. key function — bisect_left / bisect_right ────────────────────────────
+
+# list of pairs sorted by first element; search by first element
+_pairs = [[1, 'a'], [3, 'b'], [5, 'c'], [7, 'd']]
+_kfn = def(item): return item[0];
+
+ae(bisect_left(_pairs, 3, 0, None, _kfn), 1)
+ae(bisect_right(_pairs, 3, 0, None, _kfn), 2)
+ae(bisect_left(_pairs, 4, 0, None, _kfn), 2)
+ae(bisect_right(_pairs, 4, 0, None, _kfn), 2)
+ae(bisect_left(_pairs, 0, 0, None, _kfn), 0)
+ae(bisect_right(_pairs, 8, 0, None, _kfn), 4)
+
+# ── 15. insort with lo/hi bounds ─────────────────────────────────────────────
+# Only the sub-slice [10, 20, 30] (indices 3..5) is searched;
+# 15 is inserted at index 4, between 10 and 20.
+
+_bounded = [1, 2, 3, 10, 20, 30]
+insort_right(_bounded, 15, 3, 6)
+ade(_bounded, [1, 2, 3, 10, 15, 20, 30])
+
+_bounded2 = [1, 2, 3, 10, 20, 30]
+insort_left(_bounded2, 20, 3, 6)   # left of existing 20
+ae(_bounded2[4], 20)
+ae(_bounded2[5], 20)
+ae(_bounded2.length, 7)
+
+# ── 16. Duplicate-value stability ────────────────────────────────────────────
+
+_dup = [1, 2, 2, 2, 3]
+ae(bisect_left(_dup, 2), 1)
+ae(bisect_right(_dup, 2), 4)
+
+_dl = [1, 2, 2, 3]
+insort_left(_dl, 2)
+# new 2 inserted at index 1 (leftmost)
+ae(_dl[1], 2)
+ae(_dl.length, 5)
+
+_dr = [1, 2, 2, 3]
+insort_right(_dr, 2)
+# new 2 inserted at index 3 (rightmost)
+ae(_dr[3], 2)
+ae(_dr.length, 5)

package/test/chainmap.pyj

@@ -0,0 +1,185 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# chainmap.pyj
+# Tests for collections.ChainMap.
+
+from __python__ import overload_getitem
+from collections import ChainMap
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+# ── 1. construction and lookup — first map wins ───────────────────────────────
+
+defaults = {'color': 'red', 'user': 'guest', 'depth': 1}
+overrides = {'user': 'admin'}
+cm = ChainMap(overrides, defaults)
+
+ae(cm['user'], 'admin')      # found in first map
+ae(cm['color'], 'red')       # falls through to second map
+ae(cm['depth'], 1)
+ae(len(cm), 3)               # unique keys across all maps
+
+# ── 2. empty construction uses a single empty dict ────────────────────────────
+
+empty = ChainMap()
+ae(len(empty), 0)
+ae(empty.maps.length, 1)
+
+# ── 3. missing key raises KeyError ────────────────────────────────────────────
+
+_err = False
+try:
+    cm['missing']
+except KeyError:
+    _err = True
+ok(_err, 'missing key raises KeyError')
+
+# ── 4. writes, deletes and updates affect only the first map ──────────────────
+
+cm['depth'] = 99
+ae(cm['depth'], 99)          # shadows the value in defaults
+ae(defaults['depth'], 1)     # underlying map untouched
+ae(overrides['depth'], 99)   # written to the first map
+
+cm['user'] = 'root'
+ae(cm['user'], 'root')
+
+del cm['user']
+ae(cm['user'], 'guest')      # first-map entry removed; falls through again
+
+_del_err = False
+try:
+    del cm['color']          # 'color' lives in the second map, not the first
+except KeyError:
+    _del_err = True
+ok(_del_err, 'deleting a key absent from the first map raises KeyError')
+
+# ── 5. membership, get, and iteration ─────────────────────────────────────────
+
+ok('color' in cm)
+ok('user' in cm)
+ok('nope' not in cm)
+ae(cm.get('color'), 'red')
+ae(cm.get('nope'), None)
+ae(cm.get('nope', 'fallback'), 'fallback')
+
+m1 = {'a': 1, 'b': 2}
+m2 = {'c': 3}
+ordered = ChainMap(m1, m2)
+ade(list(ordered), ['c', 'a', 'b'])     # Python order: later maps first
+ade(ordered.keys(), ['c', 'a', 'b'])
+ade(ordered.values(), [3, 1, 2])
+ade(ordered.items(), [['c', 3], ['a', 1], ['b', 2]])
+
+_seen = []
+for k in ordered:
+    _seen.push(k)
+ade(_seen, ['c', 'a', 'b'])
+
+# ── 6. maps attribute, new_child and parents ──────────────────────────────────
+
+base = ChainMap({'x': 1})
+child = base.new_child({'x': 2, 'y': 3})
+ae(child['x'], 2)            # child's own map shadows the parent
+ae(child['y'], 3)
+ae(base['x'], 1)             # parent unchanged
+ae(child.maps.length, 2)
+
+# new_child() with no argument adds a fresh empty map
+fresh = base.new_child()
+ae(fresh.maps.length, 2)
+ae(len(fresh), 1)
+fresh['z'] = 7
+ae(fresh['z'], 7)
+ok('z' not in base)
+
+# parents drops the first map
+parents = child.parents
+ae(parents['x'], 1)
+ae(parents.maps.length, 1)
+
+# ── 7. copy is shallow — first map cloned, rest shared ────────────────────────
+
+src = ChainMap({'a': 1}, {'b': 2})
+dup = src.copy()
+dup['a'] = 100
+ae(src['a'], 1)              # first map was cloned
+dup['c'] = 9                 # writes to the cloned first map
+ok('c' not in src)
+ae(dup['b'], 2)              # tail maps are shared
+
+# ── 8. pop, popitem, clear, setdefault, update ────────────────────────────────
+
+p = ChainMap({'a': 1, 'b': 2}, {'c': 3})
+ae(p.pop('a'), 1)
+ok('a' not in p.maps[0])
+ae(p.pop('missing', 'dflt'), 'dflt')
+
+_pop_err = False
+try:
+    p.pop('c')               # 'c' is not in the first map
+except KeyError:
+    _pop_err = True
+ok(_pop_err, 'pop of a key absent from the first map raises KeyError')
+
+pi = ChainMap({'only': 42})
+ade(pi.popitem(), ['only', 42])
+ae(len(pi.maps[0]), 0)
+
+sd = ChainMap({'a': 1}, {'b': 2})
+ae(sd.setdefault('a', 999), 1)       # existing key — unchanged
+ae(sd.setdefault('new', 5), 5)       # missing key — inserted into first map
+ae(sd['new'], 5)
+ae(sd.setdefault('b', 0), 2)         # found in tail map — not copied forward
+ok('b' not in sd.maps[0])
+
+up = ChainMap({'a': 1}, {'b': 2})
+up.update({'a': 10, 'd': 4})
+ae(up['a'], 10)
+ae(up['d'], 4)
+up.update(e=5)
+ae(up['e'], 5)
+up.update([['f', 6]])
+ae(up['f'], 6)
+
+cl = ChainMap({'a': 1, 'b': 2}, {'c': 3})
+cl.clear()
+ae(len(cl.maps[0]), 0)
+ae(cl['c'], 3)               # tail map survives clear()
+
+# ── 9. nested ChainMap as a member map ────────────────────────────────────────
+
+inner = ChainMap({'a': 1}, {'b': 2})
+outer = ChainMap({'c': 3}, inner)
+ae(outer['a'], 1)
+ae(outer['b'], 2)
+ae(outer['c'], 3)
+ok('a' in outer)
+ae(len(outer), 3)
+
+# ── 10. equality ──────────────────────────────────────────────────────────────
+
+ok(ChainMap({'a': 1}, {'b': 2}) == ChainMap({'a': 1}, {'b': 2}))
+ok(ChainMap({'a': 1}) == {'a': 1})
+ok(not (ChainMap({'a': 1}) == ChainMap({'a': 2})))
+ok(not (ChainMap({'a': 1}) == {'a': 1, 'b': 2}))
+
+# ── 11. repr ──────────────────────────────────────────────────────────────────
+
+# RapydScript's repr() quotes strings with double quotes (as Counter/OrderedDict do)
+ae(ChainMap({'a': 1}, {'b': 2}).__repr__(), 'ChainMap({"a": 1}, {"b": 2})')
+
+# ── 12. dynamic — changes to underlying maps are visible ──────────────────────
+
+live = {'k': 'v1'}
+dyn = ChainMap({}, live)
+ae(dyn['k'], 'v1')
+live['k'] = 'v2'
+ae(dyn['k'], 'v2')           # ChainMap reflects the mutation
+live['extra'] = 'x'
+ok('extra' in dyn)
+
+print('chainmap tests passed')