rapydscript-ns 0.9.1 → 0.9.3

package/test/logging.pyj

@@ -0,0 +1,356 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# logging.pyj
+# Tests for the logging standard library module.
+
+from logging import (
+    Logger, Handler, StreamHandler, NullHandler, Formatter, Filter,
+    LogRecord, makeLogRecord,
+    getLogger, basicConfig, disable,
+    addLevelName, getLevelName,
+    NOTSET, DEBUG, INFO, WARNING, ERROR, CRITICAL,
+    lastResort, root,
+)
+import logging
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+
+# ── 1. Level constants ────────────────────────────────────────────────────────
+
+ae(NOTSET,   0)
+ae(DEBUG,    10)
+ae(INFO,     20)
+ae(WARNING,  30)
+ae(ERROR,    40)
+ae(CRITICAL, 50)
+ae(logging.WARN,  WARNING)
+ae(logging.FATAL, CRITICAL)
+
+
+# ── 2. getLevelName ───────────────────────────────────────────────────────────
+
+ae(getLevelName(DEBUG),    'DEBUG')
+ae(getLevelName(INFO),     'INFO')
+ae(getLevelName(WARNING),  'WARNING')
+ae(getLevelName(ERROR),    'ERROR')
+ae(getLevelName(CRITICAL), 'CRITICAL')
+ae(getLevelName(0),        'NOTSET')
+ae(getLevelName(42),       'Level 42')
+
+ae(getLevelName('DEBUG'),    DEBUG)
+ae(getLevelName('WARNING'),  WARNING)
+ae(getLevelName('CRITICAL'), CRITICAL)
+ae(getLevelName('WARN'),     WARNING)
+ae(getLevelName('FATAL'),    CRITICAL)
+
+
+# ── 3. addLevelName ───────────────────────────────────────────────────────────
+
+addLevelName(25, 'TRACE')
+ae(getLevelName(25),      'TRACE')
+ae(getLevelName('TRACE'), 25)
+
+
+# ── 4. LogRecord.getMessage — %-formatting ────────────────────────────────────
+
+_r1 = LogRecord('test', DEBUG, '', 0, 'hello world', [], None)
+ae(_r1.getMessage(), 'hello world')
+
+_r2 = LogRecord('test', INFO, '', 0, 'Hello %s', ['Alice'], None)
+ae(_r2.getMessage(), 'Hello Alice')
+
+_r3 = LogRecord('test', WARNING, '', 0, 'Val=%d x=%f', [42, 3.14], None)
+ae(_r3.getMessage(), 'Val=42 x=3.140000')
+
+_r4 = LogRecord('test', ERROR, '', 0, '100%%', [], None)
+ae(_r4.getMessage(), '100%')
+
+
+# ── 5. LogRecord attributes ───────────────────────────────────────────────────
+
+_r5 = LogRecord('myapp', ERROR, '/foo.py', 10, 'boom', [], None)
+ae(_r5.name,      'myapp')
+ae(_r5.levelno,   ERROR)
+ae(_r5.levelname, 'ERROR')
+ae(_r5.lineno,    10)
+ae(_r5.threadName, 'MainThread')
+ok(_r5.created > 0, 'created is positive')
+ok(_r5.relativeCreated >= 0, 'relativeCreated is non-negative')
+
+
+# ── 6. makeLogRecord ──────────────────────────────────────────────────────────
+
+_d = {}
+_d['name']    = 'foo'
+_d['levelno'] = WARNING
+_d['msg']     = 'hi'
+_mr = makeLogRecord(_d)
+ae(_mr.name,    'foo')
+ae(_mr.levelno, WARNING)
+ae(_mr.msg,     'hi')
+
+
+# ── 7. Formatter ──────────────────────────────────────────────────────────────
+
+class _Buf:
+    def __init__(self):
+        self.lines = []
+    def write(self, s):
+        self.lines.push(s)
+
+
+_fmt1 = Formatter('%(levelname)s:%(name)s:%(message)s')
+_rec  = LogRecord('myapp', INFO, '', 0, 'hello', [], None)
+ae(_fmt1.format(_rec), 'INFO:myapp:hello')
+
+_fmt2 = Formatter('%(levelno)d %(name)s %(message)s')
+_rec2 = LogRecord('app', WARNING, '', 0, 'watch out', [], None)
+ae(_fmt2.format(_rec2), '30 app watch out')
+
+ok(_fmt1.usesTime() is False, 'usesTime False')
+_fmt3 = Formatter('%(asctime)s %(message)s')
+ok(_fmt3.usesTime() is True, 'usesTime True')
+
+# asctime must be a non-empty string
+_rec3 = LogRecord('t', INFO, '', 0, 'msg', [], None)
+_s3   = _fmt3.format(_rec3)
+ok(_s3.length > 5, 'asctime result is non-empty')
+
+
+# ── 8. Filter ─────────────────────────────────────────────────────────────────
+
+_f_all  = Filter()
+_f_app  = Filter('myapp')
+_f_sub  = Filter('myapp.sub')
+
+_rA = LogRecord('myapp',        INFO, '', 0, 'm', [], None)
+_rB = LogRecord('myapp.sub',    INFO, '', 0, 'm', [], None)
+_rC = LogRecord('myapp.sub.x',  INFO, '', 0, 'm', [], None)
+_rD = LogRecord('otherapp',     INFO, '', 0, 'm', [], None)
+
+ok(_f_all.filter(_rA) is True,  'empty filter accepts all')
+ok(_f_all.filter(_rD) is True,  'empty filter accepts all 2')
+
+ok(_f_app.filter(_rA) is True,  'parent name matches')
+ok(_f_app.filter(_rB) is True,  'child name matches')
+ok(_f_app.filter(_rC) is True,  'deep child matches')
+ok(_f_app.filter(_rD) is False, 'unrelated rejected')
+
+ok(_f_sub.filter(_rB) is True,  'sub self-match')
+ok(_f_sub.filter(_rC) is True,  'sub child match')
+ok(_f_sub.filter(_rA) is False, 'parent of sub rejected')
+
+
+# ── 9. StreamHandler with custom stream ──────────────────────────────────────
+
+_buf9 = _Buf()
+_sh9  = StreamHandler(_buf9)
+_sh9.setFormatter(Formatter('%(levelname)s:%(name)s:%(message)s'))
+_sh9.setLevel(DEBUG)
+
+_l9 = Logger('test9')
+_l9.addHandler(_sh9)
+_l9.setLevel(DEBUG)
+_l9.propagate = False
+
+_l9.debug('dbg')
+_l9.info('inf')
+_l9.warning('wrn')
+_l9.error('err')
+_l9.critical('crit')
+
+ae(_buf9.lines.length, 5)
+ae(_buf9.lines[0], 'DEBUG:test9:dbg\n')
+ae(_buf9.lines[1], 'INFO:test9:inf\n')
+ae(_buf9.lines[2], 'WARNING:test9:wrn\n')
+ae(_buf9.lines[3], 'ERROR:test9:err\n')
+ae(_buf9.lines[4], 'CRITICAL:test9:crit\n')
+
+
+# ── 10. NullHandler ───────────────────────────────────────────────────────────
+
+_nh = NullHandler()
+_rn = LogRecord('x', WARNING, '', 0, 'msg', [], None)
+ok(_nh.handle(_rn) is None or _nh.handle(_rn) is False or True, 'NullHandler.handle does not throw')
+
+
+# ── 11. Logger.isEnabledFor / getEffectiveLevel ───────────────────────────────
+
+_la = Logger('lvltest')
+_la.setLevel(WARNING)
+_la.propagate = False
+
+ok(_la.isEnabledFor(DEBUG)    is False, 'DEBUG below WARNING')
+ok(_la.isEnabledFor(INFO)     is False, 'INFO below WARNING')
+ok(_la.isEnabledFor(WARNING)  is True,  'WARNING == WARNING')
+ok(_la.isEnabledFor(ERROR)    is True,  'ERROR above WARNING')
+ok(_la.isEnabledFor(CRITICAL) is True,  'CRITICAL above WARNING')
+
+ae(_la.getEffectiveLevel(), WARNING)
+
+_la.setLevel(NOTSET)
+_la.parent = None
+ae(_la.getEffectiveLevel(), WARNING)  # no parent → falls back to WARNING
+
+
+# ── 12. Logger level filtering (messages suppressed below level) ──────────────
+
+_buf12 = _Buf()
+_sh12  = StreamHandler(_buf12)
+_sh12.setFormatter(Formatter('%(levelname)s'))
+_sh12.setLevel(NOTSET)
+
+_l12 = Logger('filt12')
+_l12.addHandler(_sh12)
+_l12.setLevel(WARNING)
+_l12.propagate = False
+
+_l12.debug('no')
+_l12.info('no')
+_l12.warning('yes')
+_l12.error('yes')
+
+ae(_buf12.lines.length, 2)
+ae(_buf12.lines[0], 'WARNING\n')
+ae(_buf12.lines[1], 'ERROR\n')
+
+
+# ── 13. Logger.log() with numeric level ──────────────────────────────────────
+
+_buf13 = _Buf()
+_sh13  = StreamHandler(_buf13)
+_sh13.setFormatter(Formatter('%(levelno)d:%(message)s'))
+_l13   = Logger('log13')
+_l13.addHandler(_sh13)
+_l13.setLevel(DEBUG)
+_l13.propagate = False
+_l13.log(ERROR, 'test via log()')
+ae(_buf13.lines[0], '40:test via log()\n')
+
+
+# ── 14. %-style args in Logger methods ────────────────────────────────────────
+
+_buf14 = _Buf()
+_sh14  = StreamHandler(_buf14)
+_sh14.setFormatter(Formatter('%(message)s'))
+_l14   = Logger('args14')
+_l14.addHandler(_sh14)
+_l14.setLevel(DEBUG)
+_l14.propagate = False
+_l14.info('x=%d y=%s', 7, 'foo')
+ae(_buf14.lines[0], 'x=7 y=foo\n')
+
+
+# ── 15. Logger.addFilter / Filterer ──────────────────────────────────────────
+
+_buf15 = _Buf()
+_sh15  = StreamHandler(_buf15)
+_sh15.setFormatter(Formatter('%(message)s'))
+_l15   = Logger('parent15')
+_l15.addHandler(_sh15)
+_l15.setLevel(DEBUG)
+_l15.propagate = False
+_l15.addFilter(Filter('parent15.child'))  # only pass records from parent15.child*
+
+_ra15 = LogRecord('parent15',       DEBUG, '', 0, 'parent', [], None)
+_rb15 = LogRecord('parent15.child', DEBUG, '', 0, 'child',  [], None)
+_l15.handle(_ra15)
+_l15.handle(_rb15)
+ae(_buf15.lines.length, 1)
+ae(_buf15.lines[0], 'child\n')
+
+
+# ── 16. Handler.addFilter ─────────────────────────────────────────────────────
+
+_buf16 = _Buf()
+_sh16  = StreamHandler(_buf16)
+_sh16.setFormatter(Formatter('%(message)s'))
+_sh16.addFilter(Filter('ok'))
+
+_l16 = Logger('hdlr16')
+_l16.addHandler(_sh16)
+_l16.setLevel(DEBUG)
+_l16.propagate = False
+
+_l16.handle(LogRecord('ok',  DEBUG, '', 0, 'pass',  [], None))
+_l16.handle(LogRecord('bad', DEBUG, '', 0, 'block', [], None))
+ae(_buf16.lines.length, 1)
+ae(_buf16.lines[0], 'pass\n')
+
+
+# ── 17. getLogger — same name returns same instance ──────────────────────────
+
+_ga = getLogger('getlogger_test')
+_gb = getLogger('getlogger_test')
+ok(_ga is _gb, 'getLogger returns same instance for same name')
+ok(getLogger() is root, 'getLogger() returns root')
+ok(getLogger('root') is root, 'getLogger("root") returns root')
+
+
+# ── 18. Logger hierarchy — propagation ────────────────────────────────────────
+
+_buf18 = _Buf()
+_sh18  = StreamHandler(_buf18)
+_sh18.setFormatter(Formatter('%(name)s:%(message)s'))
+
+_parent18 = Logger('app18')
+_parent18.addHandler(_sh18)
+_parent18.setLevel(DEBUG)
+_parent18.propagate = False
+
+_child18  = Logger('app18.mod')
+_child18.parent    = _parent18
+_child18.setLevel(DEBUG)
+_child18.propagate = True
+
+_child18.info('from child')
+ae(_buf18.lines.length, 1)
+ae(_buf18.lines[0], 'app18.mod:from child\n')
+
+
+# ── 19. disable() ─────────────────────────────────────────────────────────────
+
+_buf19 = _Buf()
+_sh19  = StreamHandler(_buf19)
+_sh19.setFormatter(Formatter('%(message)s'))
+_l19 = Logger('dis19')
+_l19.addHandler(_sh19)
+_l19.setLevel(DEBUG)
+_l19.propagate = False
+
+_l19.warning('before disable')
+logging.disable(CRITICAL)
+_l19.warning('after disable – suppressed')
+_l19.critical('also suppressed')
+ae(_buf19.lines.length, 1)
+
+# reset disable level so later tests aren't affected
+logging.disable(NOTSET)
+
+
+# ── 20. hasHandlers ───────────────────────────────────────────────────────────
+
+_l20 = Logger('hashdlr20')
+_l20.parent = None
+_l20.propagate = False
+ok(_l20.hasHandlers() is False, 'no handlers')
+_l20.addHandler(NullHandler())
+ok(_l20.hasHandlers() is True, 'has handler')
+
+
+# ── 21. exception() logs at ERROR ─────────────────────────────────────────────
+
+_buf21 = _Buf()
+_sh21  = StreamHandler(_buf21)
+_sh21.setFormatter(Formatter('%(levelname)s:%(message)s'))
+_l21   = Logger('exc21')
+_l21.addHandler(_sh21)
+_l21.setLevel(DEBUG)
+_l21.propagate = False
+_l21.exception('something went wrong')
+ae(_buf21.lines.length, 1)
+ae(_buf21.lines[0], 'ERROR:something went wrong\n')

package/test/long.pyj

@@ -0,0 +1,130 @@
+# vim:fileencoding=utf-8
+# globals: assrt
+from __python__ import overload_operators
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+throws = assrt.throws
+
+# ── construction ──────────────────────────────────────────────────────────────
+
+# from int
+ok(jstype(long(0)) is 'bigint')
+ok(jstype(long(42)) is 'bigint')
+ok(jstype(long(-99)) is 'bigint')
+
+# from string (base 10)
+ok(jstype(long('12345678901234567890')) is 'bigint')
+ae(str(long('42')), '42')
+ae(str(long('-7')), '-7')
+
+# from string with explicit base 10
+ae(str(long('255', 10)), '255')
+
+# from string base 16
+ae(str(long('ff', 16)), '255')
+ae(str(long('FF', 16)), '255')
+ae(str(long('0xff', 16)), '255')
+ae(str(long('0xFF', 16)), '255')
+
+# from string base 2
+ae(str(long('1010', 2)), '10')
+ae(str(long('0b1010', 2)), '10')
+
+# from string base 8
+ae(str(long('17', 8)), '15')
+ae(str(long('0o17', 8)), '15')
+
+# from bool
+ae(str(long(True)), '1')
+ae(str(long(False)), '0')
+
+# identity: long of long
+x = long(7)
+ae(str(long(x)), '7')
+
+# very large integer (beyond JS Number precision)
+big = long('99999999999999999999999999999999')
+ae(str(big), '99999999999999999999999999999999')
+
+# ── error cases ───────────────────────────────────────────────────────────────
+
+throws(def(): long('abc');, ValueError)
+throws(def(): long('xyz', 16);, ValueError)
+throws(def(): long(3.14);, TypeError)
+throws(def(): long(None);, TypeError)
+
+# ── arithmetic ────────────────────────────────────────────────────────────────
+
+a = long(10)
+b = long(3)
+
+ae(str(a + b), '13')
+ae(str(a - b), '7')
+ae(str(a * b), '30')
+
+# floor division — Python semantics (floor toward -inf)
+ae(str(a // b), '3')
+ae(str(long(-7) // long(2)), '-4')   # Python: -4, JS truncate: -3
+ae(str(long(7) // long(-2)), '-4')   # Python: -4, JS truncate: -3
+ae(str(long(-7) // long(-2)), '3')   # both negative
+
+# modulo — Python semantics (result has same sign as divisor)
+ae(str(long(7) % long(3)), '1')
+ae(str(long(-7) % long(3)), '2')     # Python: 2, JS BigInt: -1
+ae(str(long(7) % long(-3)), '-2')    # Python: -2, JS BigInt: 1
+ae(str(long(-7) % long(-3)), '-1')   # both negative
+
+# power
+ae(str(long(2) ** long(10)), '1024')
+ae(str(long(3) ** long(0)), '1')
+
+# negative exponent raises ValueError
+throws(def(): long(2) ** long(-1);, ValueError)
+
+# truediv raises TypeError (use // instead)
+throws(def(): long(10) / long(3);, TypeError)
+
+# ── bitwise ───────────────────────────────────────────────────────────────────
+
+ae(str(long(0b1010) & long(0b1100)), '8')   # 0b1000 = 8
+ae(str(long(0b1010) | long(0b1100)), '14')  # 0b1110 = 14
+ae(str(long(0b1010) ^ long(0b1100)), '6')   # 0b0110 = 6
+ae(str(long(1) << long(4)), '16')
+ae(str(long(16) >> long(2)), '4')
+
+# mixed long + int raises TypeError
+throws(def(): long(1) + 1;, TypeError)
+throws(def(): long(1) & 1;, TypeError)
+
+# ── comparisons ───────────────────────────────────────────────────────────────
+
+ok(long(1) < long(2))
+ok(long(2) > long(1))
+ok(long(3) <= long(3))
+ok(long(3) >= long(3))
+ok(long(1) == long(1))
+ok(long(1) != long(2))
+
+# ── isinstance / type ─────────────────────────────────────────────────────────
+
+ok(isinstance(long(5), long))
+ok(isinstance(long(0), long))
+ok(isinstance(long(-1), long))
+ok(not isinstance(5, long))
+ok(not isinstance('5', long))
+
+# ── str() conversion ──────────────────────────────────────────────────────────
+
+ae(str(long(0)), '0')
+ae(str(long(12345)), '12345')
+ae(str(long(-42)), '-42')
+ae(str(long('99999999999999999999')), '99999999999999999999')
+
+# ── identity with large numbers ───────────────────────────────────────────────
+
+# Verify precision is maintained (JS Number loses this)
+n = long('9007199254740993')  # 2^53 + 1, not representable as JS Number
+ae(str(n), '9007199254740993')
+ae(str(n + long(1)), '9007199254740994')

package/test/parenthesized_with.pyj

@@ -0,0 +1,141 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# parenthesized_with.pyj
+# Tests for Python 3.10+ parenthesized `with` statement.
+
+ae  = assrt.equal
+ok  = assrt.ok
+
+# ── Helper context manager ────────────────────────────────────────────────────
+
+class _CM:
+    def __init__(self, name, log):
+        self.name = name
+        self.log = log
+
+    def __enter__(self):
+        self.log.push('enter:' + self.name)
+        return self
+
+    def __exit__(self, *args):
+        self.log.push('exit:' + self.name)
+        return False
+
+# ── 1. Single clause, alias inside parens ─────────────────────────────────────
+
+_log1 = []
+with (_CM('a', _log1) as cm):
+    _log1.push('body')
+ae(_log1[0], 'enter:a')
+ae(_log1[1], 'body')
+ae(_log1[2], 'exit:a')
+
+# ── 2. Single clause, no alias ────────────────────────────────────────────────
+
+_log2 = []
+
+class _SimpleCM:
+    def __init__(self, log):
+        self.log = log
+    def __enter__(self):
+        self.log.push('entered')
+        return self
+    def __exit__(self):
+        self.log.push('exited')
+
+with (_SimpleCM(_log2)):
+    _log2.push('body')
+ae(_log2[0], 'entered')
+ae(_log2[1], 'body')
+ae(_log2[2], 'exited')
+
+# ── 3. Multi-clause, LIFO exit order ──────────────────────────────────────────
+
+_log3 = []
+with (_CM('a', _log3) as a, _CM('b', _log3) as b):
+    _log3.push('body')
+ae(_log3[0], 'enter:a')
+ae(_log3[1], 'enter:b')
+ae(_log3[2], 'body')
+ae(_log3[3], 'exit:b')  # LIFO: b exits before a
+ae(_log3[4], 'exit:a')
+
+# ── 4. Trailing comma ─────────────────────────────────────────────────────────
+
+_log4 = []
+with (_CM('x', _log4) as x,):
+    _log4.push('body')
+ae(_log4[0], 'enter:x')
+ae(_log4[1], 'body')
+ae(_log4[2], 'exit:x')
+
+# ── 5. Multi-line form ────────────────────────────────────────────────────────
+
+_log5 = []
+with (
+    _CM('p', _log5) as p,
+    _CM('q', _log5) as q,
+):
+    _log5.push('body')
+ae(_log5[0], 'enter:p')
+ae(_log5[1], 'enter:q')
+ae(_log5[2], 'body')
+ae(_log5[3], 'exit:q')
+ae(_log5[4], 'exit:p')
+
+# ── 6. __enter__ return value assigned to alias ───────────────────────────────
+
+class _ValCM:
+    def __init__(self, val):
+        self.val = val
+    def __enter__(self):
+        return self.val
+    def __exit__(self):
+        pass
+
+with (_ValCM(99) as v):
+    ae(v, 99)
+
+# ── 7. Exception suppression via __exit__ ─────────────────────────────────────
+
+class _SuppressCM:
+    def __enter__(self):
+        return self
+    def __exit__(self, *args):
+        return True  # suppress any exception
+
+_raised = False
+with (_SuppressCM()):
+    raise Error('suppressed')
+_raised = True
+ok(_raised)
+
+# ── 8. Exception propagation (unsuppressed) ──────────────────────────────────
+
+_caught = False
+try:
+    with (_CM('err', []) as _ignored):
+        raise Error('propagated')
+except Exception as _e:
+    _caught = True
+ok(_caught)
+
+# ── 9. Non-parenthesized form still works (regression) ───────────────────────
+
+_log9 = []
+with _CM('r', _log9) as r, _CM('s', _log9) as s:
+    _log9.push('body')
+ae(_log9[0], 'enter:r')
+ae(_log9[3], 'exit:s')
+ae(_log9[4], 'exit:r')
+
+# ── 10. Parenthesized expression (not parenthesized-with) still works ─────────
+
+_log10 = []
+_cm10 = _CM('t', _log10)
+with (_cm10) as t:
+    _log10.push('body')
+ae(_log10[0], 'enter:t')
+ae(_log10[1], 'body')
+ae(_log10[2], 'exit:t')

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.