rapydscript-ns 0.9.2 → 0.9.4

package/test/pprint.pyj

@@ -0,0 +1,232 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# pprint.pyj
+# Tests for the pprint standard library module.
+
+from pprint import (
+    pformat,
+    pprint,
+    pp,
+    saferepr,
+    isreadable,
+    isrecursive,
+    PrettyPrinter,
+)
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+# ── 1. Atoms — pformat returns repr() for primitives ────────────────────────
+
+ae(pformat(None), 'None')
+ae(pformat(True), 'True')
+ae(pformat(False), 'False')
+ae(pformat(42), '42')
+ae(pformat(3.14), '3.14')
+ae(pformat('hello'), '"hello"')
+ae(pformat(''), '""')
+
+# ── 2. Empty containers ─────────────────────────────────────────────────────
+
+ae(pformat([]), '[]')
+ae(pformat({}), '{}')
+ae(pformat(set()), 'set()')
+ae(pformat(frozenset()), 'frozenset()')
+
+# ── 3. Short containers fit on a single line ────────────────────────────────
+
+ae(pformat([1, 2, 3]), '[1, 2, 3]')
+ae(pformat({'a': 1, 'b': 2}), '{"a": 1, "b": 2}')
+ae(pformat({1, 2, 3}), '{1, 2, 3}')
+ae(pformat(frozenset([1, 2, 3])), 'frozenset({1, 2, 3})')
+
+# ── 4. Wide list breaks across lines ────────────────────────────────────────
+
+_wide = pformat([1, 2, 3, 4, 5], width=8)
+ae(_wide, '[1,\n 2,\n 3,\n 4,\n 5]')
+
+# ── 5. Wide dict breaks across lines, keys sorted by default ────────────────
+
+_wd = pformat({'name': 'Alice', 'age': 30}, width=15)
+ae(_wd, '{"age": 30,\n "name": "Alice"}')
+
+# ── 6. sort_dicts=False preserves insertion order ───────────────────────────
+
+# Use ρσ_dict-backed dict() to guarantee Map ordering
+_d = dict()
+_d.set('c', 1)
+_d.set('a', 2)
+_d.set('b', 3)
+ae(pformat(_d, sort_dicts=False), '{"c": 1, "a": 2, "b": 3}')
+ae(pformat(_d, sort_dicts=True),  '{"a": 2, "b": 3, "c": 1}')
+
+# ── 7. pp() defaults sort_dicts=False, has same parameters as pprint ────────
+
+# pp prints rather than returning; we just confirm it runs without throwing.
+pp({'c': 1, 'a': 2})
+
+# ── 8. depth parameter limits expansion ─────────────────────────────────────
+
+ae(pformat([1, [2, [3, [4]]]], depth=1), '[1, [...]]')
+ae(pformat([1, [2, [3, [4]]]], depth=2), '[1, [2, [...]]]')
+ae(pformat({'a': {'b': {'c': 1}}}, depth=1), '{"a": {...}}')
+
+# ── 9. Nested containers — multi-line indentation ───────────────────────────
+
+# After "[" at col 0, items align at col 1 (default indent=1).
+ae(pformat([[1, 2], [3, 4]], width=20),
+   '[[1, 2], [3, 4]]')
+
+# With smaller width, both inner lists must break to their own lines.
+_nested = pformat([[1, 2], [3, 4], [5, 6], [7, 8]], width=12)
+ade(_nested.split('\n'), ['[[1, 2],', ' [3, 4],', ' [5, 6],', ' [7, 8]]'])
+
+# ── 10. indent parameter adjusts inner indentation ──────────────────────────
+
+ae(pformat([1, 2, 3], width=5, indent=4),
+   '[   1,\n    2,\n    3]')
+
+# ── 11. compact=True packs multiple items per line ──────────────────────────
+
+_c = pformat([1, 2, 3, 4, 5, 6, 7, 8], compact=True, width=15)
+ade(_c.split('\n'), ['[1, 2, 3, 4, 5,', ' 6, 7, 8]'])
+
+# ── 12. saferepr — single-line repr; recursive marker for cycles ────────────
+
+ae(saferepr([1, 2, 3]), '[1, 2, 3]')
+ae(saferepr({'a': 1}), '{"a": 1}')
+ae(saferepr('text'), '"text"')
+
+# Self-referential list -> recursive marker, not infinite recursion
+_self_list = [1, 2]
+_self_list.push(_self_list)
+_rep = saferepr(_self_list)
+ok(_rep.indexOf('<Recursion on') >= 0,
+   'saferepr should emit <Recursion on ...> for cycles')
+
+# ── 13. isreadable — True only when no recursion and only readable types ────
+
+ok(isreadable([1, 2, 3]))
+ok(isreadable({'a': 1, 'b': 2}))
+ok(isreadable('hi'))
+ok(isreadable(42))
+
+# Sets are not readable in Python's pprint (set literal != set()).
+ok(not isreadable(set()))   # explicitly empty set -> 'set()' is *not* a readable literal
+
+# A self-referential structure is never readable
+ok(not isreadable(_self_list))
+
+# ── 14. isrecursive — True only for recursive structures ────────────────────
+
+ok(not isrecursive([1, 2, 3]))
+ok(not isrecursive({'a': 1}))
+ok(isrecursive(_self_list))
+
+_self_dict = {}
+_self_dict['k'] = _self_dict
+ok(isrecursive(_self_dict))
+
+# ── 15. PrettyPrinter — class-based use ─────────────────────────────────────
+
+_pp_class = PrettyPrinter(indent=2, width=10)
+ae(_pp_class.pformat([1, 2, 3]), '[1, 2, 3]')
+
+_pp_wide = PrettyPrinter(indent=2, width=8)
+ae(_pp_wide.pformat([10, 20, 30]),
+   '[ 10,\n  20,\n  30]')
+# `[` at col 0, then indent_per_level-1 == 1 space pad, then "10" at col 2
+# subsequent lines indented to col 2
+
+# ── 16. PrettyPrinter.isreadable / isrecursive instance methods ─────────────
+
+_pp_ir = PrettyPrinter()
+ok(_pp_ir.isreadable([1, 2, 3]))
+ok(not _pp_ir.isrecursive([1, 2, 3]))
+ok(_pp_ir.isrecursive(_self_list))
+
+# ── 17. Validation — ValueError for invalid PrettyPrinter args ──────────────
+
+_caught = False
+try:
+    PrettyPrinter(indent=-1)
+except ValueError:
+    _caught = True
+ok(_caught, 'PrettyPrinter should reject indent < 0')
+
+_caught2 = False
+try:
+    PrettyPrinter(depth=0)
+except ValueError:
+    _caught2 = True
+ok(_caught2, 'PrettyPrinter should reject depth <= 0')
+
+# ── 18. Mixed nested structure formatting ───────────────────────────────────
+
+_data = {
+    'count': 2,
+    'users': [
+        {'age': 30, 'name': 'Alice'},
+        {'age': 25, 'name': 'Bob'},
+    ],
+}
+
+# Width permits inline lists.
+ae(pformat(_data, width=120),
+   '{"count": 2, "users": [{"age": 30, "name": "Alice"}, {"age": 25, "name": "Bob"}]}')
+
+# Narrow width forces multi-line expansion.
+_narrow = pformat(_data, width=30)
+ok(_narrow.indexOf('\n') > 0, 'narrow width should produce multi-line output')
+
+# ── 19. Stream output (PrettyPrinter with custom stream) ────────────────────
+
+class _Collector:
+    def __init__(self):
+        self.parts = v'[]'
+
+    def write(self, s):
+        self.parts.push(s)
+
+    def getvalue(self):
+        return self.parts.join('')
+
+_col = _Collector()
+_pp_s = PrettyPrinter(stream=_col)
+_pp_s.pprint([1, 2, 3])
+ae(_col.getvalue(), '[1, 2, 3]\n')
+
+# ── 20. pprint() module-level function with custom stream ───────────────────
+
+_col2 = _Collector()
+pprint({'a': 1}, stream=_col2)
+ae(_col2.getvalue(), '{"a": 1}\n')
+
+# ── 21. Empty / single-element containers do not break ──────────────────────
+
+ae(pformat([42]), '[42]')
+ae(pformat({'k': 'v'}), '{"k": "v"}')
+ae(pformat([], width=1), '[]')
+ae(pformat({}, width=1), '{}')
+
+# ── 22. Numbers and booleans preserved as repr ──────────────────────────────
+
+ae(pformat([True, False, None, 0]), '[True, False, None, 0]')
+
+# ── 23. Strings with special characters get repr-escaped ────────────────────
+
+ae(pformat('a\nb'), '"a\\nb"')
+ae(pformat('"quoted"'), '"\\"quoted\\""')
+
+# ── 24. underscore_numbers parameter is accepted (currently ignored) ────────
+
+ae(pformat(1000000, underscore_numbers=True), '1000000')
+
+# ── 25. pp() with kwargs forwarded ──────────────────────────────────────────
+
+_col3 = _Collector()
+pp({'b': 2, 'a': 1}, stream=_col3, width=80)
+# pp defaults sort_dicts=False, so 'b' comes before 'a' (insertion order)
+ae(_col3.getvalue(), '{"b": 2, "a": 1}\n')

package/test/python_compat.pyj

@@ -235,7 +235,7 @@ strings()
 ae('  hello  '.strip(), 'hello')
 ae('hello world'.upper(), 'HELLO WORLD')
 
-# ── 15. strings() leaves replace() as JS version; split() defaults to ' ' ─────
+# ── 15. strings() patches replace(); split() defaults to ' ' ──────────────────
 # (strings() is active from section 14 above)
 # Python str.split() with no args: splits on any whitespace, strips leading/trailing.
 # RapydScript .split() with no args: transpiles to .split(" ") — splits on single space.
@@ -248,11 +248,9 @@ ade(str.split('a  b c'), ['a', 'b', 'c'])
 ade('a  b'.split(), ['a', '', 'b'])   # double space → empty token between
 ade('a b'.split(' '), ['a', 'b'])     # explicit ' ' separator still works
 
-# Python str.replace() vs JS String.prototype.replace():
-# Python replaces ALL occurrences by default.
-# JS .replace() with a string pattern only replaces the FIRST occurrence.
+# str.replace() and String.prototype.replace() both use Python semantics (replace all).
 ae(str.replace('aaa', 'a', 'b'), 'bbb')     # Python: replaces all
-ae('aaa'.replace('a', 'b'), 'baa')           # JS: replaces only first
+ae('aaa'.replace('a', 'b'), 'bbb')           # also replaces all (pythonized)
 
 # ── 16. Method binding — not automatic ──────────────────────────────────────
 # Python: bound methods carry a reference to self.

package/test/python_modulo.pyj

@@ -0,0 +1,76 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# python_modulo.pyj
+# Tests for Python-style modulo: result takes the sign of the divisor.
+# python_modulo defaults to True; no __python__ import needed.
+
+ae = assrt.equal
+ok = assrt.ok
+
+# ── Positive operands ────────────────────────────────────────────────────────
+ae(7 % 3, 1)
+ae(0 % 5, 0)
+ae(6 % 3, 0)
+
+# ── Negative dividend ────────────────────────────────────────────────────────
+ae(-7 % 3, 2)
+ae(-1 % 3, 2)
+ae(-6 % 3, 0)
+
+# ── Negative divisor ─────────────────────────────────────────────────────────
+ae(7 % -3, -2)
+ae(1 % -3, -2)
+ae(6 % -3, 0)
+
+# ── Both negative ────────────────────────────────────────────────────────────
+ae(-7 % -3, -1)
+ae(-1 % -3, -1)
+ae(-6 % -3, 0)
+
+# ── Floats ───────────────────────────────────────────────────────────────────
+ae(-7.5 % 2, 0.5)
+ae(7.5 % -2, -0.5)
+ae(2.5 % 1, 0.5)
+
+# ── Booleans (treated as numbers) ────────────────────────────────────────────
+ae(5 % True, 0)
+ae(False % 3, 0)
+
+# ── Augmented `%=` ───────────────────────────────────────────────────────────
+x = -7
+x %= 3
+ae(x, 2)
+
+y = 7
+y %= -3
+ae(y, -2)
+
+z = -7
+z %= -3
+ae(z, -1)
+
+# ── Inside expressions ───────────────────────────────────────────────────────
+ae((-7 % 3) + 10, 12)
+ae(((-10) % 3) * 2, 4)
+
+# ── Variables (not just literals) ────────────────────────────────────────────
+a = -7
+b = 3
+ae(a % b, 2)
+
+# ── BigInt (Python semantics already worked; regression guard) ───────────────
+ae(BigInt(-7) % BigInt(3), BigInt(2))
+ae(BigInt(7) % BigInt(-3), BigInt(-2))
+
+# ── Custom __mod__ wins over numeric path ────────────────────────────────────
+# python_modulo routes through ρσ_op_mod_ns which dispatches __mod__/__rmod__
+# even without overload_operators.
+class Mod:
+    def __init__(self, v):
+        self.v = v
+    def __mod__(self, other):
+        return 'mod-' + self.v + '-' + other
+
+m = Mod('a')
+ae(m % 'b', 'mod-a-b')

package/test/python_modulo_off.pyj

@@ -0,0 +1,21 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# python_modulo_off.pyj
+# Tests for opting out of Python-style modulo via no_python_modulo.
+# With the flag off, `%` emits raw JS modulo (sign of dividend).
+
+from __python__ import no_python_modulo
+
+ae = assrt.equal
+
+# JS modulo: result takes the sign of the dividend.
+ae(-7 % 3, -1)   # Python would give 2
+ae(7 % -3, 1)    # Python would give -2
+ae(-7 % -3, -1)  # same as Python here
+ae(7 % 3, 1)     # positive case identical
+
+# Augmented `%=` follows the same flag.
+x = -7
+x %= 3
+ae(x, -1)        # Python would give 2

package/test/statistics.pyj

@@ -0,0 +1,224 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# statistics.pyj
+# Tests for the statistics standard library module.
+
+from statistics import (
+    StatisticsError,
+    mean, fmean, geometric_mean, harmonic_mean,
+    median, median_low, median_high, median_grouped, mode, multimode,
+    variance, pvariance, stdev, pstdev,
+    quantiles,
+    covariance, correlation, linear_regression,
+    NormalDist,
+)
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+
+def close(a, b, tol=1e-9):
+    return Math.abs(a - b) < tol
+
+
+# ── 1. mean ───────────────────────────────────────────────────────────────────
+
+ae(mean([1, 2, 3, 4]), 2.5)
+ae(mean([1, 2, 3]), 2)
+ae(mean([5]), 5)
+ae(mean([-1, 1]), 0)
+ok(close(mean([1, 2, 4]), 7 / 3))
+# any iterable works
+ae(mean(x for x in [2, 4, 6]), 4)
+
+# ── 2. fmean ──────────────────────────────────────────────────────────────────
+
+ae(fmean([1, 2, 3, 4]), 2.5)
+ok(close(fmean([3.5, 4.0, 5.25]), 4.25))
+# weighted
+ok(close(fmean([10, 20, 30], [1, 1, 1]), 20))
+ok(close(fmean([1, 2, 3, 4], [4, 3, 2, 1]), 2.0))
+
+# ── 3. geometric_mean ─────────────────────────────────────────────────────────
+
+ok(close(geometric_mean([4, 1, 1 / 32]), 0.5))
+ok(close(geometric_mean([2, 8]), 4.0))
+ok(close(geometric_mean([10]), 10.0))
+
+# ── 4. harmonic_mean ──────────────────────────────────────────────────────────
+
+ok(close(harmonic_mean([40, 60]), 48.0))
+ok(close(harmonic_mean([1, 2, 4]), 12 / 7))
+ae(harmonic_mean([0, 5, 10]), 0)        # a zero forces the result to zero
+# weighted
+ok(close(harmonic_mean([40, 60], [5, 30]), 56.0))
+
+# ── 5. median family ──────────────────────────────────────────────────────────
+
+ae(median([1, 3, 5]), 3)
+ae(median([1, 3, 5, 7]), 4)
+ae(median([5, 1, 3]), 3)                # unsorted input
+ae(median_low([1, 3, 5, 7]), 3)
+ae(median_low([1, 3, 5]), 3)
+ae(median_high([1, 3, 5, 7]), 5)
+ae(median_high([1, 3, 5]), 3)
+ae(median_grouped([52, 52, 53, 54]), 52.5)
+ok(close(median_grouped([1, 2, 2, 3, 4, 4, 4, 4, 4, 5]), 3.7))
+ok(close(median_grouped([1, 3, 3, 5, 7], 2), 3.5))
+
+# ── 6. mode / multimode ───────────────────────────────────────────────────────
+
+ae(mode([1, 1, 2, 3, 3, 3, 4]), 3)
+ae(mode([1, 1, 1, 2, 2]), 1)
+ae(mode(['red', 'blue', 'red', 'green']), 'red')
+ae(mode([7]), 7)
+# ties: first mode encountered wins
+ae(mode([4, 4, 5, 5]), 4)
+ade(multimode([1, 1, 2, 2, 3]), [1, 2])
+ade(multimode([1, 2, 3]), [1, 2, 3])
+ade(multimode([]), [])
+ade(multimode(['a', 'a', 'b', 'c', 'c']), ['a', 'c'])
+
+# ── 7. variance / stdev ───────────────────────────────────────────────────────
+
+ae(variance([1, 2, 3, 4, 5]), 2.5)
+ae(pvariance([1, 2, 3, 4, 5]), 2.0)
+ok(close(stdev([1, 2, 3, 4, 5]), Math.sqrt(2.5)))
+ok(close(pstdev([1, 2, 3, 4, 5]), Math.sqrt(2.0)))
+ok(close(variance([2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5]), 1.3720238095238095))
+ok(close(pvariance([0.0, 0.25, 0.25, 1.25, 1.5, 1.75, 2.75, 3.25]), 1.25))
+# explicit centre argument
+ae(variance([1, 2, 3, 4, 5], 3), 2.5)
+ae(pvariance([1, 2, 3, 4, 5], 3), 2.0)
+
+# ── 8. quantiles ──────────────────────────────────────────────────────────────
+
+ade(quantiles([1, 2, 3, 4]), [1.25, 2.5, 3.75])
+_q = quantiles([1, 2, 3, 4, 5, 6, 7, 8, 9])
+ae(_q.length, 3)
+_qi = quantiles([1, 2, 3, 4, 5], n=4, method='inclusive')
+ae(_qi.length, 3)
+ade(quantiles([0, 100], n=2, method='inclusive'), [50])
+# deciles
+ae(quantiles([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], n=10).length, 9)
+
+# ── 9. covariance / correlation / linear_regression ──────────────────────────
+
+_cx = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+_cy = [1, 2, 3, 1, 2, 3, 1, 2, 3]
+ok(close(covariance(_cx, _cy), 0.75))
+
+_px = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+_py = [9, 8, 7, 6, 5, 4, 3, 2, 1]
+ok(close(correlation(_px, _px), 1.0))
+ok(close(correlation(_px, _py), -1.0))
+# ranked (Spearman) correlation handles a monotonic non-linear relation
+ok(close(correlation([1, 2, 3, 4, 5], [1, 4, 9, 16, 25], method='ranked'), 1.0))
+
+_lr = linear_regression([1, 2, 3, 4, 5], [2, 4, 6, 8, 10])
+ok(close(_lr.slope, 2.0))
+ok(close(_lr.intercept, 0.0))
+_lr2 = linear_regression([0, 1, 2, 3], [1, 3, 5, 7])
+ok(close(_lr2.slope, 2.0))
+ok(close(_lr2.intercept, 1.0))
+_lrp = linear_regression([1, 2, 3], [2, 4, 6], proportional=True)
+ok(close(_lrp.slope, 2.0))
+ae(_lrp.intercept, 0.0)
+
+# ── 10. NormalDist — basics ───────────────────────────────────────────────────
+
+_nd = NormalDist(100, 15)
+ae(_nd.mean, 100)
+ae(_nd.median, 100)
+ae(_nd.mode, 100)
+ae(_nd.stdev, 15)
+ae(_nd.variance, 225)
+ae(NormalDist().mean, 0)
+ae(NormalDist().stdev, 1)
+
+# ── 11. NormalDist — pdf / cdf / inv_cdf ─────────────────────────────────────
+
+ok(close(_nd.cdf(100), 0.5, 1e-6))
+ok(close(_nd.cdf(115), 0.8413447460685429, 1e-5))
+ok(close(_nd.cdf(85), 0.15865525393145707, 1e-5))
+ae(_nd.inv_cdf(0.5), 100)               # exact: q = 0 ⇒ x = mu
+ok(close(_nd.inv_cdf(0.8413447460685429), 115, 1e-4))
+ok(close(_nd.pdf(100), 1 / Math.sqrt(2 * Math.PI * 225)))
+# cdf and inv_cdf are inverses
+ok(close(_nd.cdf(_nd.inv_cdf(0.25)), 0.25, 1e-5))
+
+# ── 12. NormalDist — zscore / quantiles / from_samples ───────────────────────
+
+ae(_nd.zscore(115), 1.0)
+ae(_nd.zscore(70), -2.0)
+_ndq = _nd.quantiles(4)
+ae(_ndq.length, 3)
+ok(close(_ndq[1], 100))                 # the median cut point
+
+_fs = NormalDist.from_samples([1, 2, 3, 4, 5])
+ok(close(_fs.mean, 3.0))
+ok(close(_fs.stdev, Math.sqrt(2.5)))
+
+# ── 13. NormalDist — overlap / samples / arithmetic ──────────────────────────
+
+ok(close(NormalDist(0, 1).overlap(NormalDist(0, 1)), 1.0, 1e-5))
+_ov = NormalDist(0, 1).overlap(NormalDist(1, 1))
+ok(_ov > 0.5 and _ov < 0.7)             # ~0.6171
+
+_samp = _nd.samples(50, seed=42)
+ae(_samp.length, 50)
+# deterministic with a fixed seed
+_samp2 = _nd.samples(50, seed=42)
+ade(_samp, _samp2)
+
+# arithmetic combines distributions / scalars
+_sum = NormalDist(2, 3).__add__(NormalDist(4, 4))
+ae(_sum.mean, 6)
+ae(_sum.stdev, 5)                        # hypot(3, 4)
+_shift = NormalDist(10, 2).__add__(5)
+ae(_shift.mean, 15)
+ae(_shift.stdev, 2)
+_scaled = NormalDist(10, 2).__mul__(3)
+ae(_scaled.mean, 30)
+ae(_scaled.stdev, 6)
+
+ok(NormalDist(1, 2).__eq__(NormalDist(1, 2)))
+ok(not NormalDist(1, 2).__eq__(NormalDist(1, 3)))
+
+# ── 14. error handling ────────────────────────────────────────────────────────
+
+def raises(fn):
+    try:
+        fn()
+    except StatisticsError:
+        return True
+    return False
+
+ok(raises(def(): return mean([]);))
+ok(raises(def(): return median([]);))
+ok(raises(def(): return mode([]);))
+ok(raises(def(): return variance([1]);))
+ok(raises(def(): return pvariance([]);))
+ok(raises(def(): return geometric_mean([1, -2, 3]);))
+ok(raises(def(): return harmonic_mean([1, -2]);))
+ok(raises(def(): return covariance([1, 2], [1, 2, 3]);))
+ok(raises(def(): return correlation([1, 1, 1], [2, 3, 4]);))
+ok(raises(def(): return linear_regression([1, 1, 1], [2, 3, 4]);))
+
+# inv_cdf rejects out-of-range probabilities
+ok(raises(def(): return NormalDist(0, 1).inv_cdf(0);))
+ok(raises(def(): return NormalDist(0, 1).inv_cdf(1.5);))
+# negative sigma is rejected
+ok(raises(def(): return NormalDist(0, -1);))
+
+# StatisticsError is a subclass of ValueError
+_is_value_error = False
+try:
+    mean([])
+except ValueError:
+    _is_value_error = True
+ok(_is_value_error, 'StatisticsError should be catchable as ValueError')
+
+print('statistics: all tests passed')

package/test/str.pyj

@@ -221,3 +221,17 @@ ae('{{}}'.format(), '{}')
 ae('{x}}}'.format(x=1), '1}')
 a = 1
 ae(f'{{ {a} }}', '{ 1 }')
+
+# str.replace — Python semantics (replace all by default)
+ae('bbb', 'aaa'.replace('a', 'b'))
+ae('hello world', 'hello earth'.replace('earth', 'world'))
+ae('baa', 'aaa'.replace('a', 'b', 1))
+ae('bba', 'aaa'.replace('a', 'b', 2))
+ae('aaa', 'aaa'.replace('a', 'b', 0))
+ae('aaa', 'aaa'.replace('x', 'y'))
+ae('', 'aaa'.replace('a', ''))
+ae('xbxbxb', 'ababab'.replace('a', 'x'))
+ae('a$b$c', 'a-b-c'.replace('-', '$'))
+# negative count replaces all (same as omitting count)
+ae('bbb', 'aaa'.replace('a', 'b', -1))
+ae('bbb', 'aaa'.replace('a', 'b', -99))