def test_mdarray(self):
N = 10
FFI = self.FFI
ArTy = FFI.arrayType(FFI.DoubleTy, N)
Ar = ArTy()
for i in range(len(Ar)):
Ar[i] = i
Ref = [float(i) for i in range(len(Ar))]
self.assertEqual(list(Ar), Ref)
ArV = memoryview(Ar)
self.assertEqual(ArV.format, "d")
def upck_double(v):
if isinstance(v, float):
return v
return struct.unpack("d", v)[0]
self.assertTrue(all(upck_double(a) == b for a, b in zip(ArV, Ref)))
Ar2Ty = FFI.arrayType(FFI.arrayType(FFI.DoubleTy, 10), 2)
Ar = Ar2Ty()
ArV = memoryview(Ar)
self.assertEqual(ArV.format, "d")
self.assertEqual(ArV.ndim, 2)
self.assertEqual(ArV.shape, (2, 10))
self.assertEqual(ArV.strides, (80, 8))
try:
import numpy as np
except ImportError:
return
ar = np.ndarray(N)
car = pydffi.view_as(ArTy, ar)
self.assertTrue(all(a == b for a, b in zip(ar, car)))
def test_views(self):
F = self.FFI
CU = F.cdef('''
#include <stdint.h>
typedef struct {
uint32_t a;
uint64_t b;
} A;
''')
A = CU.types.A
Len = A.size
S = pydffi.view_as(pydffi.const(A), b"A" * Len)
self.assertEqual(int(S.a), 0x41414141)
self.assertEqual(int(S.b), 0x4141414141414141)
B = bytearray(pydffi.view_as_bytes(S))
self.assertEqual(B, b"A" * Len)
B = pydffi.view_as_bytes(S)
One = 1 if sys.version_info >= (3, 0) else struct.pack("B", 1)
B[0] = One
B[1] = One
B[2] = One
B[3] = One
self.assertEqual(int(S.a), 0x01010101)
def test_structsformat(self):
FFI = pydffi.FFI()
CU = FFI.cdef('''
#include <stdbool.h>
typedef struct {
bool a;
unsigned int b;
unsigned short c;
} A;
typedef struct {
unsigned char buf[9];
unsigned short v0;
A a;
unsigned short v1;
} B;
''')
vA = CU.types.A(a=1,b=0xAAAAAAAA,c=0x4444)
buf = pydffi.view_as_bytes(vA)
vAup = struct.unpack(CU.types.A.format, buf)
self.assertEqual(vAup, (1,0xAAAAAAAA,0x4444))
buf_ref = bytearray(b"012345678")
vB = CU.types.B(v0=1,v1=2,a=vA,buf=pydffi.view_as(CU.types.B.buf.type, buf_ref))
buf = pydffi.view_as_bytes(vB)
vBup = struct.unpack(CU.types.B.format, buf)
self.assertEqual(bytearray(vBup[:9]), buf_ref)
self.assertEqual(vBup[9:], (1,1,0xAAAAAAAA,0x4444,2))
def test_buffers(self):
CU = self.FFI.compile('''
#include <stdio.h>
#include <stdint.h>
void print(const char* msg) {
puts(msg);
}
void print_u8(uint8_t const* buf, size_t len) {
for (size_t i = 0; i < len; ++i) {
printf("%02X ", buf[i]);
}
printf("\\n");
}
void bytesupper(uint8_t* S) {
const size_t Len = strlen(S);
printf("%lu\\n", Len);
for (size_t i = 0; i < Len; ++i) {
S[i] = toupper(S[i]);
}
}
void strupper(char* S) {
bytesupper(S);
}
''')
print_ = getattr(CU.funcs, "print")
print_u8 = CU.funcs.print_u8
bytesupper = CU.funcs.bytesupper
strupper = CU.funcs.strupper
# CHECK: coucou
print_("coucou")
# CHECK: héllo
print_("héllo")
buf = u"héllo".encode("utf8")
# CHECK: 68 C3 A9 6C 6C 6F
print_u8(buf, len(buf))
buf = bytearray(b"hello")
bytesupper(buf)
self.assertEqual(buf, b"HELLO")
buf = bytearray(b"hello")
buf_char = pydffi.view_as(self.FFI.arrayType(self.FFI.UInt8Ty, len(buf)), buf)
strupper(pydffi.cast(pydffi.ptr(buf_char),self.FFI.CharPtrTy))
self.assertEqual(buf, b"HELLO")
def test_union(self):
FFI = pydffi.FFI()
CU = FFI.cdef('''
#include <stdint.h>
typedef union {
struct {
uint8_t v8[4];
};
uint32_t v32;
} IP;
''')
Obj = CU.types.IP()
Obj.v32 = 0xAABBCCDD
for IP in self.generated_types(CU.types.IP, "IP"):
V = self.purectypes.unpack(IP, bytes(pydffi.view_as_bytes(Obj)))
self.assertEqual(V.v32, 0xAABBCCDD)
for i in range(4):
self.assertEqual(V.v8[i], Obj.v8[i])
V = self.purectypes.pack(IP, V)
V = pydffi.view_as(pydffi.const(CU.types.IP), V)
self.assertEqual(V.v32, 0xAABBCCDD)
def test_views(self):
F = self.FFI
CU = F.cdef('''
typedef struct {
unsigned int a;
unsigned long long b;
} A;
''')
S = pydffi.view_as(pydffi.const(CU.types.A), b"A" * 16)
self.assertEqual(int(S.a), 0x41414141)
self.assertEqual(int(S.b), 0x4141414141414141)
B = bytearray(pydffi.view_as_bytes(S))
self.assertEqual(B, b"A" * 16)
B = pydffi.view_as_bytes(S)
One = 1 if sys.version_info >= (3, 0) else struct.pack("B", 1)
B[0] = One
B[1] = One
B[2] = One
B[3] = One
self.assertEqual(int(S.a), 0x01010101)
def test_struct(self):
FFI = pydffi.FFI()
CU = FFI.cdef('''
typedef struct {
unsigned char a;
int b;
int c;
short d;
} A;
''')
Obj = CU.types.A(a=1, b=2, c=10, d=20)
for A in self.generated_types(CU.types.A, "A"):
V = self.purectypes.unpack(A, bytes(pydffi.view_as_bytes(Obj)))
self.assertEqual(V.a, 1)
self.assertEqual(V.b, 2)
self.assertEqual(V.c, 10)
self.assertEqual(V.d, 20)
V = self.purectypes.pack(A, V)
V = pydffi.view_as(CU.types.A, V)
self.assertEqual(Obj.a, V.a)
self.assertEqual(Obj.b, V.b)
self.assertEqual(Obj.c, V.c)
self.assertEqual(Obj.d, V.d)
def get_buf_view(self):
FFI = getFFI()
buf = bytearray(b"hello\x00")
return FFI, pydffi.view_as(FFI.arrayType(FFI.UInt8Ty, len(buf)), buf)
}
void strupper(char* S) {
bytesupper(S);
}
''')
print_ = getattr(CU.funcs, "print")
print_u8 = CU.funcs.print_u8
bytesupper = CU.funcs.bytesupper
strupper = CU.funcs.strupper
# CHECK: coucou
print_("coucou")
# CHECK: héllo
print_("héllo")
buf = u"héllo".encode("utf8")
# CHECK: 68 C3 A9 6C 6C 6F
print_u8(buf, len(buf))
buf = bytearray(b"hello")
# CHECK: 5
bytesupper(buf)
assert(buf == b"HELLO")
buf = bytearray(b"hello")
buf_char = pydffi.view_as(FFI.arrayType(FFI.UInt8Ty, len(buf)), buf)
# CHECK: 5
strupper(pydffi.cast(pydffi.ptr(buf_char),FFI.CharPtrTy))
assert(buf == b"HELLO")
Ref = [float(i) for i in range(len(Ar))]
assert (list(Ar) == Ref)
ArV = memoryview(Ar)
assert (ArV.format == "d")
def upck_double(v):
if isinstance(v, float):
return v
return struct.unpack("d", v)[0]
assert (all(upck_double(a) == b for a, b in zip(ArV, Ref)))
Ar2Ty = FFI.arrayType(FFI.arrayType(FFI.DoubleTy, 10), 2)
Ar = Ar2Ty()
ArV = memoryview(Ar)
assert (ArV.format == "d")
assert (ArV.ndim == 2)
assert (ArV.shape == (2, 10))
assert (ArV.strides == (80, 8))
try:
import numpy as np
except ImportError:
sys.exit(0)
ar = np.ndarray(N)
car = pydffi.view_as(ArTy, ar)
assert (all(a == b for a, b in zip(ar, car)))
# RUN: "%python" "%s"
import pydffi
import sys
import struct
F = pydffi.FFI()
CU = F.compile('''
#include <stdio.h>
struct A {
unsigned int a;
unsigned long long b;
};
void print(struct A a) { printf("%u %lu\\n", a.a, a.b); }
''')
S = pydffi.view_as(pydffi.const(CU.types.A), b"A"*16)
assert(int(S.a) == 0x41414141)
assert(int(S.b) == 0x4141414141414141)
B = bytearray(pydffi.view_as_bytes(S))
assert(B == b"A"*16)
B = pydffi.view_as_bytes(S)
One = 1 if sys.version_info >= (3, 0) else struct.pack("B", 1)
B[0] = One
B[1] = One
B[2] = One
B[3] = One
assert(int(S.a) == 0x01010101)
CU = FFI.cdef('''
#include <stdbool.h>
typedef struct {
bool a;
unsigned int b;
unsigned short c;
} A;
typedef struct {
unsigned char buf[9];
unsigned short v0;
A a;
unsigned short v1;
} B;
''')
vA = CU.types.A(a=1, b=0xAAAAAAAA, c=0x4444)
buf = pydffi.view_as_bytes(vA)
vAup = struct.unpack(CU.types.A.format, buf)
assert (vAup == (1, 0xAAAAAAAA, 0x4444))
buf_ref = bytearray(b"012345678")
vB = CU.types.B(v0=1,
v1=2,
a=vA,
buf=pydffi.view_as(CU.types.B.buf.type, buf_ref))
buf = pydffi.view_as_bytes(vB)
vBup = struct.unpack(CU.types.B.format, buf)
assert (bytearray(vBup[:9]) == buf_ref)
assert (vBup[9:] == (1, 1, 0xAAAAAAAA, 0x4444, 2))
