rapydscript-ns 0.8.3 → 0.9.0

package/test/baselib.pyj

@@ -99,6 +99,20 @@ assrt.deepEqual(list(map(def(a):return a*2;, iter([1, 2]))), [2, 4])
 assrt.deepEqual(list(filter(def(a):return a > 1;, [1, 2])), [2])
 assrt.deepEqual(list(filter(def(a):return a > 1;, iter([1, 2]))), [2])
 assrt.deepEqual(list(zip([1,2], [3,4])), [[1,3], [2, 4]])
+assrt.deepEqual(list(zip([1,2], [3,4], strict=True)), [[1,3], [2, 4]])
+assrt.deepEqual(list(zip(strict=True)), [])
+_zip_err = False
+try:
+    list(zip([1,2], [3], strict=True))
+except:
+    _zip_err = True
+assrt.ok(_zip_err)
+_zip_err2 = False
+try:
+    list(zip([1], [3,4], strict=True))
+except:
+    _zip_err2 = True
+assrt.ok(_zip_err2)
 
 # lists
 a = [1, 2]
@@ -317,3 +331,80 @@ assrt.equal(all(iter([1, 2, 3])), True)
 assrt.equal(all(iter([1, 0, 3])), False)
 assrt.equal(all(range(1, 4)), True)
 assrt.equal(all(range(0, 3)), False)
+
+# complex() builtin and j-literal syntax
+c1 = complex(3, 4)
+assrt.equal(c1.real, 3)
+assrt.equal(c1.imag, 4)
+
+# j literal syntax
+c2 = 4j
+assrt.equal(c2.real, 0)
+assrt.equal(c2.imag, 4)
+
+# 3+4j literal — + goes through ρσ_list_add which dispatches __add__
+c3 = 3+4j
+assrt.equal(c3.real, 3)
+assrt.equal(c3.imag, 4)
+
+# abs() dispatches to __abs__
+assrt.equal(abs(complex(3, 4)), 5.0)
+assrt.equal(abs(complex(-5, 0)), 5)
+
+# arithmetic via dunder methods (no overload_operators needed)
+assrt.ok(complex(1, 2).__add__(complex(3, 4)) == complex(4, 6))
+assrt.ok(complex(5, 6).__sub__(complex(3, 4)) == complex(2, 2))
+assrt.ok(complex(1, 2).__mul__(complex(3, 4)) == complex(-5, 10))
+assrt.ok(complex(2, 0).__truediv__(complex(4, 0)) == complex(0.5, 0))
+
+# mixed complex + number
+assrt.ok(complex(3, 4) + 1 == complex(4, 4))  # ρσ_list_add → __add__
+assrt.ok(complex(3, 4).__radd__(1) == complex(4, 4))
+assrt.ok(complex(3, 4).__sub__(1) == complex(2, 4))
+assrt.ok(complex(3, 4).__rmul__(2) == complex(6, 8))
+assrt.ok(complex(6, 8).__truediv__(2) == complex(3, 4))
+
+# 1 + complex — ρσ_list_add dispatches __radd__ when left has no __add__
+assrt.ok(1 + complex(3, 4) == complex(4, 4))
+
+# unary via dunder
+assrt.ok(complex(3, 4).__neg__() == complex(-3, -4))
+assrt.ok(complex(3, 4).__pos__() == complex(3, 4))
+
+# conjugate
+assrt.ok(complex(3, 4).conjugate() == complex(3, -4))
+
+# zero-argument form
+assrt.ok(complex() == complex(0, 0))
+
+# single-argument number
+assrt.ok(complex(5) == complex(5, 0))
+
+# single-argument string
+assrt.ok(complex('3+4j') == complex(3, 4))
+assrt.ok(complex('3-4j') == complex(3, -4))
+assrt.ok(complex('4j') == complex(0, 4))
+assrt.ok(complex('3') == complex(3, 0))
+assrt.ok(complex('j') == complex(0, 1))
+assrt.ok(complex('-j') == complex(0, -1))
+
+# isinstance
+assrt.ok(isinstance(complex(1, 2), complex))
+assrt.ok(not isinstance(42, complex))
+
+# bool — __bool__ dispatch works, and truthiness is correct in conditions
+assrt.ok(complex(0, 0).__bool__() is False)
+assrt.ok(complex(1, 0).__bool__() is True)
+assrt.ok(complex(0, 1).__bool__() is True)
+
+# repr / str
+assrt.equal(repr(complex(0, 0)), '0j')
+assrt.equal(repr(complex(1, 0)), '(1+0j)')
+assrt.equal(repr(complex(0, 1)), '1j')
+assrt.equal(repr(complex(3, 4)), '(3+4j)')
+assrt.equal(repr(complex(3, -4)), '(3-4j)')
+assrt.equal(str(complex(3, 4)), '(3+4j)')
+
+# abs() still works on numbers
+assrt.equal(abs(-5), 5)
+assrt.equal(abs(3.0), 3.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__',