rapydscript-ns 0.9.0 → 0.9.1

package/test/io.pyj

@@ -0,0 +1,316 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# io.pyj
+# Tests for the io standard library module (StringIO and BytesIO).
+
+from io import StringIO, BytesIO, UnsupportedOperation
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+throws = assrt.throws
+
+# ── 1. StringIO — construction ────────────────────────────────────────────────
+
+_sio = StringIO()
+ae(_sio.getvalue(), '')
+ae(_sio.tell(), 0)
+ok(not _sio.closed)
+
+_sio2 = StringIO('hello')
+ae(_sio2.getvalue(), 'hello')
+ae(_sio2.tell(), 0)
+
+# ── 2. StringIO — read ────────────────────────────────────────────────────────
+
+_s = StringIO('hello world')
+ae(_s.read(5), 'hello')
+ae(_s.read(1), ' ')
+ae(_s.read(),  'world')
+ae(_s.read(),  '')     # at end
+
+_s.seek(0)
+ae(_s.read(),  'hello world')
+
+# read with size=0
+_s.seek(0)
+ae(_s.read(0), '')
+ae(_s.tell(),  0)
+
+# ── 3. StringIO — readline ────────────────────────────────────────────────────
+
+_ml = StringIO('line1\nline2\nline3')
+ae(_ml.readline(),      'line1\n')
+ae(_ml.readline(),      'line2\n')
+ae(_ml.readline(),      'line3')
+ae(_ml.readline(),      '')     # past end
+
+# readline with size limit
+_ml2 = StringIO('abcdef\nghijkl')
+ae(_ml2.readline(3),    'abc')
+ae(_ml2.readline(100),  'def\n')
+
+# ── 4. StringIO — readlines ───────────────────────────────────────────────────
+
+_rls = StringIO('a\nb\nc\n')
+ade(_rls.readlines(), ['a\n', 'b\n', 'c\n'])
+
+_rls2 = StringIO('x\ny\nz')
+ade(_rls2.readlines(), ['x\n', 'y\n', 'z'])
+
+# hint stops early (total >= hint)
+_hint = StringIO('aa\nbb\ncc\n')
+_hlines = _hint.readlines(hint=4)
+ok(_hlines.length >= 1)
+ok(_hlines.length <= 3)
+
+# ── 5. StringIO — write ───────────────────────────────────────────────────────
+
+_w = StringIO()
+_w.write('hello')
+_w.write(' ')
+_w.write('world')
+ae(_w.getvalue(), 'hello world')
+ae(_w.tell(), 11)
+
+# write returns the number of chars written
+_w2 = StringIO()
+ae(_w2.write('abc'), 3)
+ae(_w2.write(''),    0)
+
+# overwrite in the middle
+_ow = StringIO('hello world')
+_ow.seek(6)
+_ow.write('Python')
+ae(_ow.getvalue(), 'hello Python')
+
+# ── 6. StringIO — writelines ──────────────────────────────────────────────────
+
+_wl = StringIO()
+_wl.writelines(['one', ' ', 'two'])
+ae(_wl.getvalue(), 'one two')
+
+# ── 7. StringIO — seek / tell ─────────────────────────────────────────────────
+
+_sk = StringIO('abcde')
+ae(_sk.seek(2), 2)
+ae(_sk.tell(), 2)
+ae(_sk.read(2), 'cd')
+
+# whence=1 (relative)
+_sk.seek(0)
+_sk.seek(2, 1)
+ae(_sk.tell(), 2)
+
+# whence=2 (from end)
+_sk.seek(-2, 2)
+ae(_sk.tell(), 3)
+ae(_sk.read(), 'de')
+
+# seek before start clamps to 0
+_sk.seek(-99)
+ae(_sk.tell(), 0)
+
+# ── 8. StringIO — truncate ────────────────────────────────────────────────────
+
+_tr = StringIO('hello world')
+_tr.seek(5)
+ae(_tr.truncate(), 5)
+ae(_tr.getvalue(), 'hello')
+
+_tr2 = StringIO('hello world')
+ae(_tr2.truncate(3), 3)
+ae(_tr2.getvalue(), 'hel')
+
+# ── 9. StringIO — closed / context manager ────────────────────────────────────
+
+_cm = StringIO('text')
+with _cm as _f:
+    ae(_f.read(), 'text')
+ok(_cm.closed)
+
+_err_raised = False
+try:
+    _cm.read()
+except ValueError:
+    _err_raised = True
+ok(_err_raised, 'read on closed StringIO should raise ValueError')
+
+# ── 10. StringIO — readable / writable / seekable ────────────────────────────
+
+_rws = StringIO()
+ok(_rws.readable())
+ok(_rws.writable())
+ok(_rws.seekable())
+
+# ── 11. StringIO — iteration ──────────────────────────────────────────────────
+
+_it = StringIO('line1\nline2\nline3\n')
+_lines = list(_it)
+ade(_lines, ['line1\n', 'line2\n', 'line3\n'])
+
+# ── 12. BytesIO — construction ────────────────────────────────────────────────
+
+_bio = BytesIO()
+ae(len(_bio.getvalue()), 0)
+ae(_bio.tell(), 0)
+ok(not _bio.closed)
+
+_bio2 = BytesIO(bytes([72, 101, 108, 108, 111]))
+ae(len(_bio2.getvalue()), 5)
+ae(_bio2.getvalue()[0], 72)
+ae(_bio2.getvalue()[4], 111)
+
+# init from bytearray
+_bio3 = BytesIO(bytearray([1, 2, 3]))
+ae(len(_bio3.getvalue()), 3)
+
+# ── 13. BytesIO — read ────────────────────────────────────────────────────────
+
+_br = BytesIO(bytes([10, 20, 30, 40, 50]))
+ae(_br.read(2)[0], 10)
+ae(_br.read(2)[0], 30)
+ae(len(_br.read()), 1)
+ae(len(_br.read()), 0)   # at end
+
+_br.seek(0)
+ae(len(_br.read()), 5)
+
+# ── 14. BytesIO — readline ────────────────────────────────────────────────────
+
+# b'line1\nline2' (0x0a is newline)
+_brl = BytesIO(bytes([108, 49, 10, 108, 50]))   # 'l1\nl2'
+_first = _brl.readline()
+ae(len(_first), 3)
+ae(_first[2], 10)   # includes the newline byte
+
+_second = _brl.readline()
+ae(len(_second), 2)
+
+ae(len(_brl.readline()), 0)   # at end
+
+# ── 15. BytesIO — write ───────────────────────────────────────────────────────
+
+_bw = BytesIO()
+ae(_bw.write(bytes([1, 2, 3])), 3)
+ae(_bw.write(bytes([4, 5])),    2)
+_bw.seek(0)
+ae(len(_bw.read()), 5)
+ae(_bw.getvalue()[0], 1)
+ae(_bw.getvalue()[4], 5)
+
+# write returns byte count
+_bw2 = BytesIO()
+ae(_bw2.write(bytes()), 0)
+
+# overwrite in the middle
+_bo = BytesIO(bytes([1, 2, 3, 4, 5]))
+_bo.seek(1)
+_bo.write(bytes([20, 30]))
+_bo.seek(0)
+_boval = _bo.read()
+ae(_boval[0], 1)
+ae(_boval[1], 20)
+ae(_boval[2], 30)
+ae(_boval[3], 4)
+ae(_boval[4], 5)
+
+# write past end extends with zeros
+_bext = BytesIO(bytes([1, 2]))
+_bext.seek(4)
+_bext.write(bytes([99]))
+_bextval = _bext.getvalue()
+ae(len(_bextval), 5)
+ae(_bextval[2], 0)
+ae(_bextval[3], 0)
+ae(_bextval[4], 99)
+
+# ── 16. BytesIO — writelines ─────────────────────────────────────────────────
+
+_bwl = BytesIO()
+_bwl.writelines([bytes([1, 2]), bytes([3, 4])])
+ae(len(_bwl.getvalue()), 4)
+
+# ── 17. BytesIO — seek / tell ─────────────────────────────────────────────────
+
+_bsk = BytesIO(bytes([10, 20, 30, 40, 50]))
+ae(_bsk.seek(3), 3)
+ae(_bsk.tell(), 3)
+ae(_bsk.read(1)[0], 40)
+
+# whence=1
+_bsk.seek(0)
+_bsk.seek(2, 1)
+ae(_bsk.tell(), 2)
+
+# whence=2
+_bsk.seek(-1, 2)
+ae(_bsk.tell(), 4)
+ae(_bsk.read(1)[0], 50)
+
+# clamp below 0
+_bsk.seek(-999)
+ae(_bsk.tell(), 0)
+
+# ── 18. BytesIO — truncate ────────────────────────────────────────────────────
+
+_btr = BytesIO(bytes([1, 2, 3, 4, 5]))
+_btr.seek(3)
+ae(_btr.truncate(), 3)
+ae(len(_btr.getvalue()), 3)
+
+_btr2 = BytesIO(bytes([10, 20, 30, 40]))
+ae(_btr2.truncate(2), 2)
+ae(len(_btr2.getvalue()), 2)
+ae(_btr2.getvalue()[1], 20)
+
+# ── 19. BytesIO — closed / context manager ───────────────────────────────────
+
+_bcm = BytesIO(bytes([7, 8, 9]))
+with _bcm as _bf:
+    _bf.seek(0)
+    ae(_bf.read()[0], 7)
+ok(_bcm.closed)
+
+_berr_raised = False
+try:
+    _bcm.read()
+except ValueError:
+    _berr_raised = True
+ok(_berr_raised, 'read on closed BytesIO should raise ValueError')
+
+# ── 20. BytesIO — readable / writable / seekable ─────────────────────────────
+
+_brws = BytesIO()
+ok(_brws.readable())
+ok(_brws.writable())
+ok(_brws.seekable())
+
+# ── 21. BytesIO — iteration ───────────────────────────────────────────────────
+
+_bit = BytesIO(bytes([65, 66, 10, 67, 68, 10]))  # 'AB\nCD\n'
+_bitlines = list(_bit)
+ae(_bitlines.length, 2)
+ae(_bitlines[0][0], 65)   # 'A'
+ae(_bitlines[0][2], 10)   # '\n'
+
+# ── 22. getvalue() does not depend on position ────────────────────────────────
+
+_gv = StringIO('hello')
+_gv.seek(3)
+ae(_gv.getvalue(), 'hello')   # full buffer regardless of pos
+
+_bgv = BytesIO(bytes([1, 2, 3]))
+_bgv.seek(2)
+ae(len(_bgv.getvalue()), 3)
+
+# ── 23. round-trip with json.dump / json.load ────────────────────────────────
+
+from json import dump, load
+_jsio = StringIO()
+dump({'key': 'value', 'n': 42}, _jsio)
+_jsio.seek(0)
+_result = load(_jsio)
+ae(_result.key,   'value')
+ae(_result.n,     42)

package/test/json.pyj

@@ -0,0 +1,196 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# json.pyj
+# Tests for the json standard library module.
+
+from json import dumps, loads, dump, load, JSONDecodeError
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+throws = assrt.throws
+
+# ── 1. dumps — basic types ────────────────────────────────────────────────────
+
+ae(dumps(None),        'null')
+ae(dumps(True),        'true')
+ae(dumps(False),       'false')
+ae(dumps(42),          '42')
+ae(dumps(3.14),        '3.14')
+ae(dumps('hello'),     '"hello"')
+ae(dumps('with "quotes"'), '"with \\"quotes\\""')
+
+# ── 2. dumps — collections ────────────────────────────────────────────────────
+
+ae(dumps([]),          '[]')
+ae(dumps([1, 2, 3]),   '[1,2,3]')
+ae(dumps({}),          '{}')
+
+# Object with single key (no ordering ambiguity)
+_d1 = dumps({'a': 1})
+ae(_d1, '{"a":1}')
+
+# ── 3. dumps — indent ─────────────────────────────────────────────────────────
+
+_pretty = dumps([1, 2], indent=2)
+ok(_pretty.indexOf('\n') >= 0, 'indented output should contain newlines')
+ok(_pretty.indexOf('  ') >= 0, 'indented output should contain spaces')
+
+# ── 4. dumps — sort_keys ──────────────────────────────────────────────────────
+
+_sk = dumps({'b': 2, 'a': 1}, sort_keys=True)
+ae(_sk, '{"a":1,"b":2}')
+
+# Nested sort_keys
+_sk2 = dumps({'z': {'y': 3, 'x': 4}, 'a': 1}, sort_keys=True)
+ae(_sk2, '{"a":1,"z":{"x":4,"y":3}}')
+
+# ── 5. dumps — separators ─────────────────────────────────────────────────────
+
+# Compact form used in Python: separators=(',', ':')
+_compact = dumps({'a': 1, 'b': 2}, sort_keys=True, separators=(',', ':'))
+ae(_compact, '{"a":1,"b":2}')
+
+# ── 6. dumps — default callback ───────────────────────────────────────────────
+
+class _Point:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+def _point_default(obj):
+    if isinstance(obj, _Point):
+        return {'x': obj.x, 'y': obj.y}
+    raise TypeError('not serializable')
+
+_pt_json = dumps(_Point(3, 4), dflt=_point_default)
+_pt_obj  = loads(_pt_json)
+ae(_pt_obj.x, 3)
+ae(_pt_obj.y, 4)
+
+# ── 7. dumps — allow_nan ──────────────────────────────────────────────────────
+
+_nan_raised = False
+try:
+    dumps(v'NaN')
+except ValueError:
+    _nan_raised = True
+ok(_nan_raised, 'dumps(NaN) should raise ValueError by default')
+
+_inf_raised = False
+try:
+    dumps(v'Infinity')
+except ValueError:
+    _inf_raised = True
+ok(_inf_raised, 'dumps(Infinity) should raise ValueError by default')
+
+# allow_nan=True should not raise
+_nan_str = dumps(v'NaN', allow_nan=True)
+ok(_nan_str.length > 0, 'allow_nan=True should return a string')
+
+# ── 8. loads — basic types ────────────────────────────────────────────────────
+
+ae(loads('null'),    None)
+ae(loads('true'),    True)
+ae(loads('false'),   False)
+ae(loads('42'),      42)
+ae(loads('3.14'),    3.14)
+ae(loads('"hello"'), 'hello')
+
+# ── 9. loads — collections ────────────────────────────────────────────────────
+
+_arr = loads('[1, 2, 3]')
+ade(_arr, [1, 2, 3])
+
+_obj = loads('{"a": 1, "b": 2}')
+ae(_obj.a, 1)
+ae(_obj.b, 2)
+
+# ── 10. loads — nested structures ─────────────────────────────────────────────
+
+_nested = loads('{"users": [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]}')
+ae(_nested.users.length, 2)
+ae(_nested.users[0].name, 'Alice')
+ae(_nested.users[1].age,  25)
+
+# ── 11. loads — object_hook ───────────────────────────────────────────────────
+
+class _NameAge:
+    def __init__(self, d):
+        self.name = d.name if d.name else ''
+        self.age  = d.age  if d.age  else 0
+
+def _obj_hook(d):
+    if d.name is not None:
+        return _NameAge(d)
+    return d
+
+_h = loads('{"name": "Alice", "age": 30}', object_hook=_obj_hook)
+ok(isinstance(_h, _NameAge), 'object_hook should produce a _NameAge instance')
+ae(_h.name, 'Alice')
+ae(_h.age,  30)
+
+# ── 12. loads — object_pairs_hook ─────────────────────────────────────────────
+
+_pairs_result = []
+def _pairs_hook(pairs):
+    _pairs_result.push(pairs.length)
+    return pairs
+
+loads('{"x": 1, "y": 2}', object_pairs_hook=_pairs_hook)
+ae(_pairs_result[0], 2, 'object_pairs_hook should receive 2 pairs')
+
+# ── 13. loads — parse_float / parse_int ───────────────────────────────────────
+
+_floats = []
+def _capture_float(s):
+    _floats.push(s)
+    return float(s)
+
+loads('3.14', parse_float=_capture_float)
+ae(_floats.length, 1)
+ae(_floats[0], '3.14')
+
+_ints = []
+def _capture_int(s):
+    _ints.push(s)
+    return int(s)
+
+loads('42', parse_int=_capture_int)
+ae(_ints.length, 1)
+ae(_ints[0], '42')
+
+# ── 14. loads — JSONDecodeError ───────────────────────────────────────────────
+
+_err_raised = False
+try:
+    loads('{invalid json}')
+except JSONDecodeError as e:
+    _err_raised = True
+    ok(isinstance(e, JSONDecodeError), 'should be JSONDecodeError')
+    ok(isinstance(e, ValueError), 'JSONDecodeError should be a ValueError')
+ok(_err_raised, 'invalid JSON should raise JSONDecodeError')
+
+# ── 15. round-trip ────────────────────────────────────────────────────────────
+
+_original = {'name': 'test', 'values': [1, 2, 3], 'nested': {'ok': True}}
+_rt = loads(dumps(_original))
+ae(_rt.name,          _original.name)
+ade(_rt.values,       _original.values)
+ae(_rt.nested.ok,     _original.nested.ok)
+
+# ── 16. dump / load via file-like object ──────────────────────────────────────
+
+class _StringIO:
+    def __init__(self):
+        self._buf = ''
+    def write(self, s):
+        self._buf += s
+    def read(self):
+        return self._buf
+
+_sio = _StringIO()
+dump({'key': 'value'}, _sio)
+_loaded = load(_sio)
+ae(_loaded.key, 'value')