185 lines
3.6 KiB
Plaintext
185 lines
3.6 KiB
Plaintext
[case testBytesBasics]
|
|
def f(num: int, l: list, d: dict, s: str) -> None:
|
|
b1 = bytes()
|
|
b2 = bytes(num)
|
|
b3 = bytes(l)
|
|
b4 = bytes(d)
|
|
b5 = bytes(s)
|
|
[out]
|
|
def f(num, l, d, s):
|
|
num :: int
|
|
l :: list
|
|
d :: dict
|
|
s :: str
|
|
r0, r1 :: object
|
|
r2, b1 :: bytes
|
|
r3, r4, r5 :: object
|
|
r6, b2, r7, b3, r8, b4, r9, b5 :: bytes
|
|
L0:
|
|
r0 = load_address PyBytes_Type
|
|
r1 = PyObject_CallFunctionObjArgs(r0, 0)
|
|
r2 = cast(bytes, r1)
|
|
b1 = r2
|
|
r3 = load_address PyBytes_Type
|
|
r4 = box(int, num)
|
|
r5 = PyObject_CallFunctionObjArgs(r3, r4, 0)
|
|
r6 = cast(bytes, r5)
|
|
b2 = r6
|
|
r7 = PyBytes_FromObject(l)
|
|
b3 = r7
|
|
r8 = PyBytes_FromObject(d)
|
|
b4 = r8
|
|
r9 = PyBytes_FromObject(s)
|
|
b5 = r9
|
|
return 1
|
|
|
|
[case testBytearrayBasics]
|
|
def f(s: str, num: int) -> None:
|
|
a = bytearray()
|
|
b = bytearray(s)
|
|
c = bytearray(num)
|
|
[out]
|
|
def f(s, num):
|
|
s :: str
|
|
num :: int
|
|
r0 :: object
|
|
r1 :: str
|
|
r2, r3, a :: object
|
|
r4 :: bytes
|
|
b, r5 :: object
|
|
r6 :: bytes
|
|
c :: object
|
|
L0:
|
|
r0 = builtins :: module
|
|
r1 = 'bytearray'
|
|
r2 = CPyObject_GetAttr(r0, r1)
|
|
r3 = PyObject_CallFunctionObjArgs(r2, 0)
|
|
a = r3
|
|
r4 = PyByteArray_FromObject(s)
|
|
b = r4
|
|
r5 = box(int, num)
|
|
r6 = PyByteArray_FromObject(r5)
|
|
c = r6
|
|
return 1
|
|
|
|
[case testBytesEquality]
|
|
def eq(x: bytes, y: bytes) -> bool:
|
|
return x == y
|
|
|
|
def neq(x: bytes, y: bytes) -> bool:
|
|
return x != y
|
|
[out]
|
|
def eq(x, y):
|
|
x, y :: bytes
|
|
r0 :: int32
|
|
r1, r2 :: bit
|
|
L0:
|
|
r0 = CPyBytes_Compare(x, y)
|
|
r1 = r0 >= 0 :: signed
|
|
r2 = r0 == 1
|
|
return r2
|
|
def neq(x, y):
|
|
x, y :: bytes
|
|
r0 :: int32
|
|
r1, r2 :: bit
|
|
L0:
|
|
r0 = CPyBytes_Compare(x, y)
|
|
r1 = r0 >= 0 :: signed
|
|
r2 = r0 != 1
|
|
return r2
|
|
|
|
[case testBytesSlicing]
|
|
def f(a: bytes, start: int, end: int) -> bytes:
|
|
return a[start:end]
|
|
[out]
|
|
def f(a, start, end):
|
|
a :: bytes
|
|
start, end :: int
|
|
r0 :: bytes
|
|
L0:
|
|
r0 = CPyBytes_GetSlice(a, start, end)
|
|
return r0
|
|
|
|
[case testBytesIndex]
|
|
def f(a: bytes, i: int) -> int:
|
|
return a[i]
|
|
[out]
|
|
def f(a, i):
|
|
a :: bytes
|
|
i, r0 :: int
|
|
L0:
|
|
r0 = CPyBytes_GetItem(a, i)
|
|
return r0
|
|
|
|
[case testBytesConcat]
|
|
def f(a: bytes, b: bytes) -> bytes:
|
|
return a + b
|
|
[out]
|
|
def f(a, b):
|
|
a, b, r0 :: bytes
|
|
L0:
|
|
r0 = CPyBytes_Concat(a, b)
|
|
return r0
|
|
|
|
[case testBytesJoin]
|
|
from typing import List
|
|
def f(b: List[bytes]) -> bytes:
|
|
return b" ".join(b)
|
|
[out]
|
|
def f(b):
|
|
b :: list
|
|
r0, r1 :: bytes
|
|
L0:
|
|
r0 = b' '
|
|
r1 = CPyBytes_Join(r0, b)
|
|
return r1
|
|
|
|
[case testBytesLen]
|
|
def f(b: bytes) -> int:
|
|
return len(b)
|
|
[out]
|
|
def f(b):
|
|
b :: bytes
|
|
r0 :: ptr
|
|
r1 :: native_int
|
|
r2 :: short_int
|
|
L0:
|
|
r0 = get_element_ptr b ob_size :: PyVarObject
|
|
r1 = load_mem r0 :: native_int*
|
|
keep_alive b
|
|
r2 = r1 << 1
|
|
return r2
|
|
|
|
[case testBytesFormatting]
|
|
def f(var: bytes, num: int) -> None:
|
|
b1 = b'aaaa%bbbbb%s' % (var, var)
|
|
b2 = b'aaaa%bbbbb%s%d' % (var, var, num)
|
|
b3 = b'%b' % var
|
|
b4 = b'%ssss' % var
|
|
[typing fixtures/typing-full.pyi]
|
|
[out]
|
|
def f(var, num):
|
|
var :: bytes
|
|
num :: int
|
|
r0, r1, r2, b1, r3 :: bytes
|
|
r4 :: tuple[bytes, bytes, int]
|
|
r5, r6 :: object
|
|
r7, b2, r8, b3, r9, r10, b4 :: bytes
|
|
L0:
|
|
r0 = b'aaaa'
|
|
r1 = b'bbbb'
|
|
r2 = CPyBytes_Build(4, r0, var, r1, var)
|
|
b1 = r2
|
|
r3 = b'aaaa%bbbbb%s%d'
|
|
r4 = (var, var, num)
|
|
r5 = box(tuple[bytes, bytes, int], r4)
|
|
r6 = PyNumber_Remainder(r3, r5)
|
|
r7 = cast(bytes, r6)
|
|
b2 = r7
|
|
r8 = CPyBytes_Build(1, var)
|
|
b3 = r8
|
|
r9 = b'sss'
|
|
r10 = CPyBytes_Build(2, var, r9)
|
|
b4 = r10
|
|
return 1
|