rapydscript-ns 0.9.2 → 0.9.4

package/test/asyncio.pyj

@@ -0,0 +1,307 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# asyncio.pyj
+# Tests for the asyncio standard library module.
+#
+# Most tests verify synchronous-observable behaviour (exceptions, queue state,
+# lock/event/semaphore flags, iscoroutine/iscoroutinefunction) because the
+# vm.runInNewContext test runner is synchronous.  Async coroutine execution
+# is tested by verifying that async functions compile correctly and return
+# thenable Promises.
+
+from asyncio import (
+    sleep, gather, create_task, ensure_future, run,
+    shield, wait_for, iscoroutine, iscoroutinefunction,
+    current_task, all_tasks, get_event_loop, get_running_loop, new_event_loop,
+    CancelledError, TimeoutError, InvalidStateError, RuntimeError,
+    QueueEmpty, QueueFull,
+    Lock, Event, Semaphore, BoundedSemaphore,
+    Queue, LifoQueue, PriorityQueue
+)
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+# ── 1. Exception classes ─────────────────────────────────────────────────────
+
+try:
+    raise CancelledError('cancelled')
+    ok(False)
+except CancelledError as e:
+    ae(e.message, 'cancelled')
+
+try:
+    raise TimeoutError('timed out')
+    ok(False)
+except TimeoutError as e:
+    ae(e.message, 'timed out')
+
+try:
+    raise InvalidStateError('bad state')
+    ok(False)
+except InvalidStateError as e:
+    ae(e.message, 'bad state')
+
+try:
+    raise QueueEmpty('empty')
+    ok(False)
+except QueueEmpty as e:
+    ae(e.message, 'empty')
+
+try:
+    raise QueueFull('full')
+    ok(False)
+except QueueFull as e:
+    ae(e.message, 'full')
+
+# ── 2. sleep / gather return Promises ────────────────────────────────────────
+
+ok(iscoroutine(sleep(0)))
+ok(iscoroutine(sleep(0.1)))
+ok(iscoroutine(gather()))
+ok(iscoroutine(gather(Promise.resolve(1), Promise.resolve(2))))
+
+# ── 3. create_task / ensure_future / run / shield pass through Promises ──────
+
+p = Promise.resolve(42)
+ok(iscoroutine(create_task(p)))
+ok(iscoroutine(ensure_future(p)))
+ok(iscoroutine(run(p)))
+ok(iscoroutine(shield(p)))
+
+# ── 4. iscoroutine / iscoroutinefunction ─────────────────────────────────────
+
+ok(not iscoroutine(42))
+ok(not iscoroutine(None))
+ok(not iscoroutine('string'))
+ok(not iscoroutine([]))
+
+async def _async_fn():
+    return 1
+
+ok(iscoroutinefunction(_async_fn))
+
+def _sync_fn():
+    return 1
+
+ok(not iscoroutinefunction(_sync_fn))
+ok(not iscoroutinefunction(42))
+ok(not iscoroutinefunction(None))
+
+# Async functions return Promises
+p2 = _async_fn()
+ok(iscoroutine(p2))
+
+# ── 5. current_task / all_tasks ───────────────────────────────────────────────
+
+ok(current_task() is None)
+ok(len(all_tasks()) == 0)
+
+# ── 6. Event loop stubs ───────────────────────────────────────────────────────
+
+loop = get_event_loop()
+ok(loop is not None)
+ok(loop is get_running_loop())
+
+loop2 = new_event_loop()
+ok(loop2 is not None)
+ok(not loop2.is_closed())
+ok(loop2.is_running())
+
+p3 = Promise.resolve(99)
+ok(iscoroutine(loop.run_until_complete(p3)))
+ok(iscoroutine(loop.create_task(p3)))
+
+# ── 7. Lock — synchronous state ──────────────────────────────────────────────
+
+lock = Lock()
+ok(not lock.locked())
+
+# acquire() returns a Promise (since it's async def)
+acq = lock.acquire()
+ok(iscoroutine(acq))
+
+# After acquiring asynchronously lock should become locked.
+# We can test the synchronous fast-path by observing the side-effect in a
+# chained then (fire-and-forget style; the VM won't await it but we verify
+# the structure is correct):
+lock2 = Lock()
+ok(not lock2.locked())
+
+try:
+    lock2.release()
+    ok(False)
+except RuntimeError:
+    ok(True)
+
+# ── 8. Event — synchronous set/clear/is_set ──────────────────────────────────
+
+ev = Event()
+ok(not ev.is_set())
+
+ev.set()
+ok(ev.is_set())
+
+ev.clear()
+ok(not ev.is_set())
+
+# wait() returns a Promise
+ok(iscoroutine(ev.wait()))
+
+# If event is already set, wait() still returns a thenable
+ev.set()
+ok(iscoroutine(ev.wait()))
+
+# ── 9. Semaphore — synchronous state ─────────────────────────────────────────
+
+sem = Semaphore(2)
+ok(not sem.locked())
+
+sem.release()
+ok(not sem.locked())
+
+sem.release()
+ok(not sem.locked())
+
+# acquire() returns a Promise
+ok(iscoroutine(sem.acquire()))
+
+try:
+    Semaphore(-1)
+    ok(False)
+except ValueError:
+    ok(True)
+
+# ── 10. BoundedSemaphore ─────────────────────────────────────────────────────
+
+# BoundedSemaphore(n) starts at value=n (same as bound).
+# Releasing without a prior acquire immediately exceeds the bound.
+bsem = BoundedSemaphore(1)
+ok(not bsem.locked())
+try:
+    bsem.release()
+    ok(False)
+except ValueError:
+    ok(True)
+
+# BoundedSemaphore(0) is always locked and cannot be released at all.
+bsem0 = BoundedSemaphore(0)
+ok(bsem0.locked())
+try:
+    bsem0.release()
+    ok(False)
+except ValueError:
+    ok(True)
+
+# ── 11. Queue — synchronous put_nowait / get_nowait ──────────────────────────
+
+q = Queue()
+ok(q.empty())
+ok(q.qsize() == 0)
+ok(not q.full())
+
+q.put_nowait('a')
+q.put_nowait('b')
+q.put_nowait('c')
+ok(q.qsize() == 3)
+ok(not q.empty())
+
+ae(q.get_nowait(), 'a')
+q.task_done()
+ae(q.get_nowait(), 'b')
+q.task_done()
+ae(q.get_nowait(), 'c')
+q.task_done()
+ok(q.empty())
+
+# QueueFull with bounded queue
+q2 = Queue(2)
+ok(not q2.full())
+q2.put_nowait(1)
+q2.put_nowait(2)
+ok(q2.full())
+try:
+    q2.put_nowait(3)
+    ok(False)
+except QueueFull:
+    ok(True)
+
+# QueueEmpty
+q3 = Queue()
+try:
+    q3.get_nowait()
+    ok(False)
+except QueueEmpty:
+    ok(True)
+
+# task_done() overflow check
+q4 = Queue()
+q4.put_nowait('x')
+ae(q4.get_nowait(), 'x')
+q4.task_done()
+try:
+    q4.task_done()
+    ok(False)
+except ValueError:
+    ok(True)
+
+# put() and get() return Promises (async methods) — test on fresh queues
+q5 = Queue()
+put_p = q5.put('async-item')  # no waiters, goes to internal queue
+ok(iscoroutine(put_p))
+ae(q5.get_nowait(), 'async-item')
+q5.task_done()
+
+q6 = Queue()
+get_p = q6.get()  # empty queue → adds a getter waiter
+ok(iscoroutine(get_p))
+
+# join() returns a Promise
+q7 = Queue()
+ok(iscoroutine(q7.join()))
+
+# ── 12. LifoQueue — last-in first-out ordering ───────────────────────────────
+
+lq = LifoQueue()
+lq.put_nowait(1)
+lq.put_nowait(2)
+lq.put_nowait(3)
+ae(lq.get_nowait(), 3)
+ae(lq.get_nowait(), 2)
+ae(lq.get_nowait(), 1)
+
+# ── 13. PriorityQueue — lowest value dequeued first ──────────────────────────
+
+pq = PriorityQueue()
+pq.put_nowait(30)
+pq.put_nowait(10)
+pq.put_nowait(20)
+ae(pq.get_nowait(), 10)
+ae(pq.get_nowait(), 20)
+ae(pq.get_nowait(), 30)
+
+# ── 14. async def / await compiles correctly ─────────────────────────────────
+
+async def _add_async(a, b):
+    return a + b
+
+ok(iscoroutinefunction(_add_async))
+p4 = _add_async(3, 4)
+ok(iscoroutine(p4))
+
+async def _chain():
+    x = await Promise.resolve(10)
+    y = await Promise.resolve(20)
+    return x + y
+
+p5 = _chain()
+ok(iscoroutine(p5))
+
+async def _gather_test():
+    results = await gather(Promise.resolve(1), Promise.resolve(2), Promise.resolve(3))
+    return results
+
+p6 = _gather_test()
+ok(iscoroutine(p6))

package/test/base64.pyj

@@ -0,0 +1,202 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# base64.pyj
+# Tests for the base64 standard library module.
+
+from base64 import b64encode, b64decode, standard_b64encode, standard_b64decode
+from base64 import urlsafe_b64encode, urlsafe_b64decode
+from base64 import b32encode, b32decode
+from base64 import b16encode, b16decode
+from base64 import encodebytes, decodebytes
+from base64 import Error
+
+ae    = assrt.equal
+ade   = assrt.deepEqual
+ok    = assrt.ok
+throws = assrt.throws
+
+# Helper: convert bytes to ASCII string for easy comparison
+def _str(b):
+    return b.decode('ascii')
+
+
+# ── 1. b64encode — basic round-trips ─────────────────────────────────────────
+
+ae(_str(b64encode(bytes([]))),          '')
+ae(_str(b64encode(bytes([0]))),         'AA==')
+ae(_str(b64encode(bytes([0, 0]))),      'AAA=')
+ae(_str(b64encode(bytes([0, 0, 0]))),   'AAAA')
+ae(_str(b64encode(bytes([77, 97, 110]))), 'TWFu')  # 'Man'
+
+# Known Python vectors
+ae(_str(b64encode(bytes([104, 101, 108, 108, 111]))), 'aGVsbG8=')  # 'hello'
+ae(_str(b64encode(bytes([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]))), 'aGVsbG8gd29ybGQ=')  # 'hello world'
+
+
+# ── 2. b64decode ──────────────────────────────────────────────────────────────
+
+_dec1 = b64decode('TWFu')
+ade(list(_dec1), [77, 97, 110])
+
+_dec2 = b64decode('aGVsbG8=')
+ade(list(_dec2), [104, 101, 108, 108, 111])
+
+# Empty string
+ade(list(b64decode('')), [])
+
+# Missing padding — Python strips whitespace and pads internally
+_dec3 = b64decode('aGVsbG8')
+ade(list(_dec3), [104, 101, 108, 108, 111])
+
+# With embedded whitespace (stripped by default)
+_dec4 = b64decode('aGVs bG8=')
+ade(list(_dec4), [104, 101, 108, 108, 111])
+
+# Accepts bytes input
+_dec5 = b64decode(bytes([84, 87, 70, 117]))  # b'TWFu'
+ade(list(_dec5), [77, 97, 110])
+
+
+# ── 3. b64encode / b64decode with altchars ────────────────────────────────────
+
+# altchars b'-_': replaces + and /
+_enc_alt = b64encode(bytes([251, 239, 190]), altchars=bytes([45, 95]))  # b'-_'
+_enc_std = b64encode(bytes([251, 239, 190]))
+ok(_str(_enc_alt).indexOf('-') >= 0 or _str(_enc_alt).indexOf('_') >= 0
+   or (_str(_enc_alt) == _str(_enc_std)),
+   'altchars encoding should differ or be identical if no + or / present')
+
+# Round-trip with altchars
+_data_alt = bytes([200, 100, 50, 25])
+_enc2 = b64encode(_data_alt, altchars=bytes([45, 95]))
+_dec6 = b64decode(_enc2, altchars=bytes([45, 95]))
+ade(list(_dec6), list(_data_alt))
+
+
+# ── 4. standard_b64encode / standard_b64decode ────────────────────────────────
+
+_s_enc = standard_b64encode(bytes([104, 101, 108, 108, 111]))
+ae(_str(_s_enc), 'aGVsbG8=')
+
+_s_dec = standard_b64decode('aGVsbG8=')
+ade(list(_s_dec), [104, 101, 108, 108, 111])
+
+
+# ── 5. urlsafe_b64encode / urlsafe_b64decode ──────────────────────────────────
+
+# bytes([251, 239, 190]) encodes to '----' in URL-safe (all 6-bit groups are 62)
+_us_enc = urlsafe_b64encode(bytes([251, 239, 190]))
+ok(_str(_us_enc).indexOf('+') < 0,  'URL-safe should not contain +')
+ok(_str(_us_enc).indexOf('/') < 0,  'URL-safe should not contain /')
+ae(_str(_us_enc), '----')
+
+# Round-trip with data that produces + and / in standard encoding
+_us_data = bytes([251, 254, 254])   # encodes to '-_7-' in URL-safe
+_us_enc2 = urlsafe_b64encode(_us_data)
+ae(_str(_us_enc2), '-_7-')
+
+# URL-safe decode
+_us_dec = urlsafe_b64decode('-_7-')
+ade(list(_us_dec), [251, 254, 254])
+
+# Round-trip with general data
+_us_rt_data = bytes([0, 1, 2, 127, 128, 255])
+_us_rt = urlsafe_b64decode(urlsafe_b64encode(_us_rt_data))
+ade(list(_us_rt), list(_us_rt_data))
+
+
+# ── 6. b32encode / b32decode ─────────────────────────────────────────────────
+
+ae(_str(b32encode(bytes([]))),       '')
+ae(_str(b32encode(bytes([102]))),    'MY======')       # b'f'  → 'MY======'
+ae(_str(b32encode(bytes([102, 111]))), 'MZXQ====')    # b'fo' → 'MZXQ===='
+ae(_str(b32encode(bytes([102, 111, 111]))), 'MZXW6===') # b'foo'
+ae(_str(b32encode(bytes([102, 111, 111, 98]))), 'MZXW6YQ=') # b'foob'
+ae(_str(b32encode(bytes([102, 111, 111, 98, 97]))), 'MZXW6YTB') # b'fooba'
+
+# Round-trip several lengths
+for _rt_data in [bytes([]), bytes([42]), bytes([1, 2, 3]), bytes([255, 0, 128, 64])]:
+    ade(list(b32decode(b32encode(_rt_data))), list(_rt_data))
+
+# casefold
+_b32_lc = b32decode('mzxw6ytb', casefold=True)
+ade(list(_b32_lc), list(bytes([102, 111, 111, 98, 97])))
+
+
+# ── 7. b16encode / b16decode ──────────────────────────────────────────────────
+
+ae(_str(b16encode(bytes([]))),          '')
+ae(_str(b16encode(bytes([0]))),         '00')
+ae(_str(b16encode(bytes([255]))),       'FF')
+ae(_str(b16encode(bytes([0, 1, 254, 255]))), '0001FEFF')
+ae(_str(b16encode(bytes([171]))),       'AB')
+
+# Round-trip
+ade(list(b16decode(b16encode(bytes([10, 20, 30, 40, 250])))), [10, 20, 30, 40, 250])
+
+# casefold
+ade(list(b16decode('0001feff', casefold=True)), [0, 1, 254, 255])
+
+# Error on invalid hex
+_b16_err = False
+try:
+    b16decode('ZZ')
+except Error:
+    _b16_err = True
+ok(_b16_err, 'b16decode of non-hex should raise Error')
+
+# Error on odd-length string
+_b16_odd = False
+try:
+    b16decode('A')
+except Error:
+    _b16_odd = True
+ok(_b16_odd, 'b16decode of odd-length string should raise Error')
+
+
+# ── 8. encodebytes / decodebytes ──────────────────────────────────────────────
+
+# encodebytes wraps at 76 chars per line
+_long_data = bytes(list(range(57)))   # 57 bytes → exactly 76 base64 chars (one line)
+_enc_lines = encodebytes(_long_data)
+_enc_lines_str = _str(_enc_lines)
+# Each line ends with \n
+ok(_enc_lines_str[-1:] == '\n', 'encodebytes output should end with newline')
+
+# Decode should recover original
+_dec_lines = decodebytes(_enc_lines)
+ade(list(_dec_lines), list(_long_data))
+
+# More than 57 bytes → multiple lines
+_long2 = bytes(list(range(100)))
+_enc2b = encodebytes(_long2)
+ok(_str(_enc2b).split('\n').length > 2, 'long encodebytes should have multiple lines')
+ade(list(decodebytes(_enc2b)), list(_long2))
+
+# Empty bytes
+ade(list(decodebytes(encodebytes(bytes([])))), [])
+
+
+# ── 9. b64decode validate=True ────────────────────────────────────────────────
+
+# Valid input should not raise
+_valid = b64decode('aGVsbG8=', validate=True)
+ade(list(_valid), [104, 101, 108, 108, 111])
+
+# Invalid character raises Error when validate=True
+_bad_raised = False
+try:
+    b64decode('aGVs!G8=', validate=True)
+except Error:
+    _bad_raised = True
+ok(_bad_raised, 'validate=True should raise Error on non-base64 character')
+
+
+# ── 10. b64encode returns bytes ───────────────────────────────────────────────
+
+_enc_type = b64encode(bytes([1, 2, 3]))
+ok(isinstance(_enc_type, bytes), 'b64encode should return bytes')
+
+_dec_type = b64decode('AQID')
+ok(isinstance(_dec_type, bytes), 'b64decode should return bytes')

package/test/baselib.pyj

@@ -159,6 +159,29 @@ a.sort()
 assrt.deepEqual(a, [1,2,3,4])
 a.sort(reverse=True)
 assrt.deepEqual(a, [4,3,2,1])
+
+# sort: a positional two-argument function is treated as a comparator
+assrt.deepEqual(sorted([3, 1, 2, 10], def(x, y): return x - y;), [1, 2, 3, 10])
+assrt.deepEqual(sorted([3, 1, 2, 10], def(x, y): return y - x;), [10, 3, 2, 1])
+sort_cmp = [5, 2, 8, 1]
+sort_cmp.sort(def(x, y): return x - y;)
+assrt.deepEqual(sort_cmp, [1, 2, 5, 8])
+# a one-argument function is still a key function
+assrt.deepEqual(sorted([3, 1, 2], key=def(x): return -x;), [3, 2, 1])
+# comparator path keeps ties in their original order (stable)
+assrt.deepEqual(sorted([[1, 'a'], [1, 'b'], [0, 'c']], def(p, q): return p[0] - q[0];),
+                [[0, 'c'], [1, 'a'], [1, 'b']])
+
+# sort: custom objects are ordered via their __lt__ method
+class SortOrd:
+    def __init__(self, v):
+        self.v = v
+    def __lt__(self, other):
+        return self.v < other.v
+ord_asc = sorted([SortOrd(3), SortOrd(1), SortOrd(2)])
+assrt.deepEqual([ord_asc[0].v, ord_asc[1].v, ord_asc[2].v], [1, 2, 3])
+ord_desc = sorted([SortOrd(3), SortOrd(1), SortOrd(2)], reverse=True)
+assrt.deepEqual([ord_desc[0].v, ord_desc[1].v, ord_desc[2].v], [3, 2, 1])
 assrt.deepEqual(a, a.slice())
 assrt.ok(a is not a.slice())
 assrt.ok(a.slice().extend is not undefined)