rapydscript-ns 0.8.4 → 0.9.0

package/test/bytes.pyj

@@ -0,0 +1,467 @@
+# vim:fileencoding=utf-8
+# globals: assrt
+from __python__ import overload_operators, truthiness
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+# ---------------------------------------------------------------------------
+# Construction
+# ---------------------------------------------------------------------------
+
+# Empty bytes
+b = bytes()
+ae(len(b), 0)
+ok(isinstance(b, bytes))
+
+# From integer — n zero bytes
+b = bytes(4)
+ae(len(b), 4)
+ae(b[0], 0)
+ae(b[3], 0)
+
+# From list of ints
+b = bytes([72, 101, 108, 108, 111])
+ae(len(b), 5)
+ae(b[0], 72)
+ae(b[4], 111)
+
+# From string with encoding
+b = bytes('Hello', 'utf-8')
+ae(len(b), 5)
+ae(b[0], 72)   # H
+ae(b[1], 101)  # e
+
+# From another bytes object (copy)
+b2 = bytes(b)
+ok(b2 == b)
+ok(b2 is not b)
+
+# ---------------------------------------------------------------------------
+# bytearray construction
+# ---------------------------------------------------------------------------
+
+ba = bytearray()
+ae(len(ba), 0)
+ok(isinstance(ba, bytearray))
+
+ba = bytearray(3)
+ae(len(ba), 3)
+ae(ba[0], 0)
+
+ba = bytearray([1, 2, 3])
+ae(ba[0], 1)
+ae(ba[2], 3)
+
+ba = bytearray('Hi', 'utf-8')
+ae(ba[0], 72)   # H
+ae(ba[1], 105)  # i
+
+# From bytes (copy)
+src = bytes([10, 20, 30])
+ba = bytearray(src)
+ok(ba == src)
+ok(ba is not src)
+
+# ---------------------------------------------------------------------------
+# isinstance checks
+# ---------------------------------------------------------------------------
+
+ok(isinstance(bytes([1, 2]), bytes))
+ok(isinstance(bytearray([1, 2]), bytearray))
+ok(isinstance(bytearray([1, 2]), bytes))   # bytearray is subclass of bytes
+
+# ---------------------------------------------------------------------------
+# Indexing and slicing
+# ---------------------------------------------------------------------------
+
+b = bytes([10, 20, 30, 40, 50])
+
+# Integer index
+ae(b[0], 10)
+ae(b[-1], 50)
+ae(b[2], 30)
+
+# Slice returns bytes
+s = b[1:4]
+ok(isinstance(s, bytes))
+ae(len(s), 3)
+ae(s[0], 20)
+ae(s[2], 40)
+
+# Slice with step
+s = b[::2]
+ae(len(s), 3)
+ae(s[0], 10)
+ae(s[1], 30)
+ae(s[2], 50)
+
+# Negative slice
+s = b[-2:]
+ae(len(s), 2)
+ae(s[0], 40)
+ae(s[1], 50)
+
+# ---------------------------------------------------------------------------
+# bytearray item assignment
+# ---------------------------------------------------------------------------
+
+ba = bytearray([1, 2, 3, 4, 5])
+ba[0] = 99
+ae(ba[0], 99)
+
+ba[-1] = 88
+ae(ba[4], 88)
+
+# Slice assignment via __setitem__
+ba.__setitem__(slice(1, 3), bytes([20, 30]))
+ae(ba[1], 20)
+ae(ba[2], 30)
+
+# ---------------------------------------------------------------------------
+# Equality
+# ---------------------------------------------------------------------------
+
+ok(bytes([1, 2, 3]) == bytes([1, 2, 3]))
+ok(not (bytes([1, 2, 3]) == bytes([1, 2, 4])))
+ok(bytes([1, 2]) == bytearray([1, 2]))
+ok(bytearray([1, 2]) == bytes([1, 2]))
+
+# ---------------------------------------------------------------------------
+# Concatenation and repetition
+# ---------------------------------------------------------------------------
+
+b1 = bytes([1, 2])
+b2 = bytes([3, 4])
+b3 = b1 + b2
+ae(len(b3), 4)
+ae(b3[0], 1)
+ae(b3[3], 4)
+
+b4 = bytes([7]) * 3
+ae(len(b4), 3)
+ae(b4[0], 7)
+ae(b4[2], 7)
+
+ba = bytearray([1, 2])
+ba += bytearray([3, 4])
+ae(len(ba), 4)
+ae(ba[2], 3)
+
+# ---------------------------------------------------------------------------
+# Containment
+# ---------------------------------------------------------------------------
+
+b = bytes([10, 20, 30, 40])
+ok(20 in b)
+ok(not (99 in b))
+ok(bytes([20, 30]) in b)
+ok(not (bytes([20, 40]) in b))
+
+# ---------------------------------------------------------------------------
+# Iteration
+# ---------------------------------------------------------------------------
+
+b = bytes([5, 10, 15])
+vals = [x for x in b]
+ade(vals, [5, 10, 15])
+
+total = 0
+for byte in bytes([1, 2, 3, 4]):
+    total += byte
+ae(total, 10)
+
+# ---------------------------------------------------------------------------
+# hex() and fromhex()
+# ---------------------------------------------------------------------------
+
+b = bytes([0, 15, 255])
+ae(b.hex(), '000fff')
+
+ae(bytes([72, 101, 108, 108, 111]).hex(), '48656c6c6f')
+
+b2 = bytes.fromhex('48656c6c6f')
+ok(b2 == bytes([72, 101, 108, 108, 111]))
+
+# hex() with separator
+b = bytes([1, 2, 3])
+ae(b.hex(':', 1), '01:02:03')
+
+# ---------------------------------------------------------------------------
+# decode()
+# ---------------------------------------------------------------------------
+
+b = bytes([72, 101, 108, 108, 111])
+ae(b.decode('utf-8'), 'Hello')
+
+b = bytes('café', 'utf-8')
+ae(b.decode('utf-8'), 'café')
+
+b = bytes([65, 66, 67])
+ae(b.decode('ascii'), 'ABC')
+
+# ---------------------------------------------------------------------------
+# count(), find(), index(), rfind(), rindex()
+# ---------------------------------------------------------------------------
+
+b = bytes([1, 2, 1, 2, 1])
+ae(b.count(1), 3)
+ae(b.count(bytes([1, 2])), 2)
+
+ae(b.find(1), 0)
+ae(b.find(2), 1)
+ae(b.find(bytes([1, 2])), 0)
+ae(b.find(99), -1)
+
+ae(b.index(2), 1)
+
+ae(b.rfind(1), 4)
+ae(b.rindex(2), 3)
+
+# ---------------------------------------------------------------------------
+# startswith() / endswith()
+# ---------------------------------------------------------------------------
+
+b = bytes([1, 2, 3, 4, 5])
+ok(b.startswith(bytes([1, 2])))
+ok(not b.startswith(bytes([2, 3])))
+ok(b.endswith(bytes([4, 5])))
+ok(not b.endswith(bytes([3, 4])))
+
+# ---------------------------------------------------------------------------
+# join()
+# ---------------------------------------------------------------------------
+
+sep = bytes([0])
+parts = [bytes([1]), bytes([2]), bytes([3])]
+result = sep.join(parts)
+ade(list(result), [1, 0, 2, 0, 3])
+
+# Empty separator
+result = bytes().join([bytes([1, 2]), bytes([3, 4])])
+ade(list(result), [1, 2, 3, 4])
+
+# ---------------------------------------------------------------------------
+# split()
+# ---------------------------------------------------------------------------
+
+b = bytes([1, 0, 2, 0, 3])
+parts = b.split(bytes([0]))
+ae(len(parts), 3)
+ok(parts[0] == bytes([1]))
+ok(parts[1] == bytes([2]))
+ok(parts[2] == bytes([3]))
+
+# Split with maxsplit
+parts = b.split(bytes([0]), 1)
+ae(len(parts), 2)
+ok(parts[0] == bytes([1]))
+ok(parts[1] == bytes([2, 0, 3]))
+
+# Whitespace split
+b = bytes([32, 65, 32, 66, 32])
+parts = b.split()
+ae(len(parts), 2)
+ok(parts[0] == bytes([65]))
+ok(parts[1] == bytes([66]))
+
+# ---------------------------------------------------------------------------
+# replace()
+# ---------------------------------------------------------------------------
+
+b = bytes([1, 2, 3, 1, 2])
+r = b.replace(bytes([1, 2]), bytes([9]))
+ade(list(r), [9, 3, 9])
+
+r = b.replace(bytes([1, 2]), bytes([9]), 1)
+ade(list(r), [9, 3, 1, 2])
+
+# ---------------------------------------------------------------------------
+# strip() / lstrip() / rstrip()
+# ---------------------------------------------------------------------------
+
+b = bytes([32, 32, 65, 66, 32])
+ok(b.strip() == bytes([65, 66]))
+ok(b.lstrip() == bytes([65, 66, 32]))
+ok(b.rstrip() == bytes([32, 32, 65, 66]))
+
+b = bytes([1, 2, 65, 66, 2, 1])
+ok(b.strip(bytes([1, 2])) == bytes([65, 66]))
+
+# ---------------------------------------------------------------------------
+# upper() / lower()
+# ---------------------------------------------------------------------------
+
+b = bytes([104, 101, 108, 108, 111])   # hello
+ok(b.upper() == bytes([72, 69, 76, 76, 79]))  # HELLO
+
+b = bytes([72, 69, 76, 76, 79])  # HELLO
+ok(b.lower() == bytes([104, 101, 108, 108, 111]))
+
+# ---------------------------------------------------------------------------
+# bytearray mutation methods
+# ---------------------------------------------------------------------------
+
+ba = bytearray([1, 2, 3])
+
+ba.append(4)
+ade(list(ba), [1, 2, 3, 4])
+
+ba.extend([5, 6])
+ade(list(ba), [1, 2, 3, 4, 5, 6])
+
+ba.insert(0, 0)
+ae(ba[0], 0)
+ae(len(ba), 7)
+
+popped = ba.pop()
+ae(popped, 6)
+ae(len(ba), 6)
+
+popped = ba.pop(0)
+ae(popped, 0)
+ae(ba[0], 1)
+
+ba.remove(3)
+ok(not (3 in ba))
+
+ba2 = bytearray([10, 20, 30])
+ba2.reverse()
+ade(list(ba2), [30, 20, 10])
+
+ba3 = bytearray([1, 2, 3])
+ba3.clear()
+ae(len(ba3), 0)
+
+# ---------------------------------------------------------------------------
+# copy()
+# ---------------------------------------------------------------------------
+
+b = bytes([1, 2, 3])
+b2 = b.copy()
+ok(b == b2)
+ok(b is not b2)
+
+ba = bytearray([1, 2, 3])
+ba2 = ba.copy()
+ok(ba == ba2)
+ok(ba is not ba2)
+ok(isinstance(ba2, bytearray))
+
+# ---------------------------------------------------------------------------
+# repr() / str()
+# ---------------------------------------------------------------------------
+
+b = bytes([72, 101, 108, 108, 111])
+ae(repr(b), "b'Hello'")
+ae(str(b), "b'Hello'")
+
+b = bytes([0, 1, 255])
+ae(repr(b), "b'\\x00\\x01\\xff'")
+
+b = bytes([10, 13, 9, 39, 92])
+ae(repr(b), "b'\\n\\r\\t\\'\\\\'")
+
+ba = bytearray([72, 105])
+ok(repr(ba).startsWith('bytearray('))
+
+# ---------------------------------------------------------------------------
+# bool / truthiness
+# ---------------------------------------------------------------------------
+
+ok(not bytes())
+ok(bytes([0]))
+ok(not bytearray())
+ok(bytearray([0]))
+
+# ---------------------------------------------------------------------------
+# hash()
+# ---------------------------------------------------------------------------
+
+b1 = bytes([1, 2, 3])
+b2 = bytes([1, 2, 3])
+ae(hash(b1), hash(b2))
+
+# ---------------------------------------------------------------------------
+# Uint8Array interop
+# ---------------------------------------------------------------------------
+
+ua = v'new Uint8Array([10, 20, 30])'
+b = bytes(ua)
+ae(len(b), 3)
+ae(b[0], 10)
+ae(b[2], 30)
+
+# ---------------------------------------------------------------------------
+# b'...' bytes literal syntax
+# ---------------------------------------------------------------------------
+
+# Basic ASCII literal
+b = b'Hello'
+ok(isinstance(b, bytes))
+ae(len(b), 5)
+ae(b[0], 72)   # H
+ae(b[1], 101)  # e
+ae(b[4], 111)  # o
+ok(b == bytes([72, 101, 108, 108, 111]))
+
+# Uppercase B prefix
+b = B'ABC'
+ok(isinstance(b, bytes))
+ae(len(b), 3)
+ae(b[0], 65)   # A
+
+# Empty bytes literal
+b = b''
+ae(len(b), 0)
+ok(isinstance(b, bytes))
+
+# Hex escape sequences
+b = b'\x48\x65\x6c\x6c\x6f'  # Hello
+ae(len(b), 5)
+ae(b[0], 72)
+ok(b == bytes([72, 101, 108, 108, 111]))
+
+# Control character escapes
+b = b'\n\t\r'
+ae(len(b), 3)
+ae(b[0], 10)   # \n
+ae(b[1], 9)    # \t
+ae(b[2], 13)   # \r
+
+# Null byte and max Latin-1 byte
+b = b'\x00\xff'
+ae(len(b), 2)
+ae(b[0], 0)
+ae(b[1], 255)
+
+# Adjacent bytes literal concatenation
+b = b'foo' b'bar'
+ae(len(b), 6)
+ok(b == bytes([102, 111, 111, 98, 97, 114]))  # foobar
+
+# Raw bytes literal - backslash sequences not interpreted
+b = rb'\n\t'
+ae(len(b), 4)
+ae(b[0], 92)   # backslash
+ae(b[1], 110)  # n
+ae(b[2], 92)   # backslash
+ae(b[3], 116)  # t
+
+# Double-quoted bytes literal
+b = b"World"
+ae(len(b), 5)
+ae(b[0], 87)   # W
+
+# bytes literal behaves like bytes constructed from equivalent list
+b1 = b'Hello'
+b2 = bytes([72, 101, 108, 108, 111])
+ok(b1 == b2)
+ok(b1.decode('utf-8') is 'Hello')
+
+# Operations on bytes from literal
+b = b'hello'
+ok(b.upper() == bytes([72, 69, 76, 76, 79]))
+ae(len(b + b'!'), 6)
+ok(b'\x00\x01' + b'\x02' == bytes([0, 1, 2]))

package/test/classes.pyj

@@ -69,6 +69,7 @@ assrt.equal(bound(), angela.how_long())
 # function methods
 assrt.deepEqual(sorted(dir(angela)), [
     'HAIRS',
+    '__format__',
     "__init__",
     '__repr__',
     '__str__',

package/test/comparison_ops.pyj

@@ -0,0 +1,173 @@
+from __python__ import overload_operators
+
+# ── helpers ──────────────────────────────────────────────────────────────────
+
+def _raises(fn, exc_type):
+    """Return True if fn() raises exc_type, False otherwise."""
+    try:
+        fn()
+    except exc_type:
+        return True
+    return False
+
+# ── 1. Numeric comparisons (should still work correctly) ─────────────────────
+
+assert 1 < 2
+assert not (2 < 1)
+assert 2 > 1
+assert not (1 > 2)
+assert 1 <= 1
+assert 2 <= 3
+assert not (3 <= 2)
+assert 3 >= 3
+assert 3 >= 2
+assert not (2 >= 3)
+
+# ── 2. String comparisons ────────────────────────────────────────────────────
+
+assert 'abc' < 'abd'
+assert 'abc' <= 'abc'
+assert 'z' > 'a'
+assert 'abc' >= 'abc'
+assert not ('b' < 'a')
+
+# ── 3. List lexicographic ordering ───────────────────────────────────────────
+
+# First differing element determines order
+assert [1, 2] < [1, 3]
+assert not ([1, 3] < [1, 2])
+
+# Prefix rule: shorter list with equal prefix is smaller
+assert [1, 2] < [1, 2, 0]
+assert not ([1, 2, 0] < [1, 2])
+
+# First element dominates
+assert [2] > [1, 99]
+assert not ([1, 99] > [2])
+
+# Equal lists
+assert [1, 2] <= [1, 2]
+assert [1, 2] >= [1, 2]
+assert not ([1, 2] < [1, 2])
+assert not ([1, 2] > [1, 2])
+
+# Empty lists
+assert [] < [1]
+assert [] <= []
+assert [1] > []
+assert not ([] > [])
+
+# ── 4. Nested list lexicographic ordering ────────────────────────────────────
+
+assert [[1, 2], [3]] < [[1, 2], [4]]
+assert [[1], [2]] < [[1], [2], []]
+
+# ── 5. Bool operands (bool is int in Python) ─────────────────────────────────
+
+assert not (True < True)
+assert False < True
+assert True > False
+assert True >= True
+
+# ── 6. Custom __lt__ / __le__ / __gt__ / __ge__ dispatch ────────────────────
+
+class Vec:
+    def __init__(self, x):
+        self.x = x
+    def __lt__(self, other):
+        return self.x < other.x
+    def __le__(self, other):
+        return self.x <= other.x
+    def __gt__(self, other):
+        return self.x > other.x
+    def __ge__(self, other):
+        return self.x >= other.x
+
+v1 = Vec(1)
+v2 = Vec(2)
+v3 = Vec(2)
+
+assert v1 < v2
+assert not (v2 < v1)
+assert v2 > v1
+assert not (v1 > v2)
+assert v1 <= v2
+assert v2 <= v3
+assert v2 >= v3
+assert v2 >= v1
+assert not (v1 >= v2)
+
+# ── 7. Reflected dunder dispatch ─────────────────────────────────────────────
+# When left has no __gt__, Python calls right.__lt__
+
+class LtOnly:
+    """Only defines __lt__; reflected ops depend on the right-hand operand."""
+    def __init__(self, x):
+        self.x = x
+    def __lt__(self, other):
+        return self.x < other.x
+
+a = LtOnly(1)
+b = LtOnly(2)
+
+assert a < b        # a.__lt__(b)
+assert b > a        # b.__gt__ absent → ρσ_op_gt falls back → ρσ_op_lt(a, b) → a.__lt__(b)
+
+# ── 8. TypeError for incompatible types ──────────────────────────────────────
+
+assert _raises(def(): return 1 < 'x';, TypeError)
+assert _raises(def(): return 'x' < 1;, TypeError)
+assert _raises(def(): return [1] < 1;, TypeError)
+assert _raises(def(): return 1 < [1];, TypeError)
+assert _raises(def(): return 1 > 'x';, TypeError)
+assert _raises(def(): return 1 <= 'x';, TypeError)
+assert _raises(def(): return 1 >= 'x';, TypeError)
+
+# ── 9. TypeError message contains operator symbol ────────────────────────────
+
+def _err_msg(fn):
+    try:
+        fn()
+    except TypeError as e:
+        return str(e)
+    return ''
+
+msg = _err_msg(def(): return 1 < 'x';)
+assert "'<'" in msg, msg
+assert 'int' in msg, msg
+assert 'str' in msg, msg
+
+msg = _err_msg(def(): return 1 > [1];)
+assert "'>'" in msg, msg
+
+msg = _err_msg(def(): return 1 <= {};)
+assert "'<='" in msg, msg
+
+msg = _err_msg(def(): return 1 >= {};)
+assert "'>='" in msg, msg
+
+# ── 10. Chained comparisons with overloaded ops ───────────────────────────────
+
+assert 1 < 2 < 3
+assert not (1 < 2 < 2)
+assert 3 > 2 > 1
+assert 1 <= 1 <= 2
+assert [1] < [2] < [3]
+assert [3] > [2] > [1]
+
+# Mixed direction chain
+assert 1 < 2 > 0
+assert not (1 < 2 > 3)
+
+# ── 11. Chained comparison: middle expression evaluated once ─────────────────
+
+counter = [0]
+def inc_and_return(val):
+    counter[0] += 1
+    return val
+
+# a < inc_and_return(b) < c  — middle must be evaluated exactly once
+assert 1 < inc_and_return(2) < 3
+assert counter[0] == 1, counter[0]
+
+print('All comparison_ops tests passed.')