luxolus/pyo3
2
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

py_class! can't be nested within a function on stable rust

Browse source
This commit is contained in:
Daniel Grunwald 2016-03-12 20:32:19 +01:00
parent e608d5eabe
commit 867666cb2b
1 changed files with 50 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

99
tests/test_class.rs
View file

@ -1,94 +1,95 @@
#![allow(dead_code)]
#[macro_use] extern crate cpython;
use cpython::{PyResult, Python, NoArgs, ObjectProtocol};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
#[test]
#[allow(dead_code)]
fn empty_class() {
py_class!(class Empty |py| { });
py_class!(class EmptyClass |py| { });
#[test]
fn empty_class() {
let gil = Python::acquire_gil();
let py = gil.python();
let typeobj = py.get_type::<Empty>();
let typeobj = py.get_type::<EmptyClass>();
// By default, don't allow creating instances from python.
assert!(typeobj.call(py, NoArgs, None).is_err());
}
py_class!(class EmptyClassWithNew |py| {
def __new__(_cls) -> PyResult<EmptyClassWithNew> {
EmptyClassWithNew::create_instance(py)
}
});
#[test]
fn empty_class_with_new() {
py_class!(class Empty |py| {
def __new__(_cls) -> PyResult<Empty> {
Empty::create_instance(py)
}
});
let gil = Python::acquire_gil();
let py = gil.python();
let typeobj = py.get_type::<Empty>();
assert!(typeobj.call(py, NoArgs, None).unwrap().cast_into::<Empty>(py).is_ok());
let typeobj = py.get_type::<EmptyClassWithNew>();
assert!(typeobj.call(py, NoArgs, None).unwrap().cast_into::<EmptyClassWithNew>(py).is_ok());
}
py_class!(class NewWithOneArg |py| {
data _data: i32;
def __new__(_cls, arg: i32) -> PyResult<NewWithOneArg> {
NewWithOneArg::create_instance(py, arg)
}
});
#[test]
fn new_with_one_arg() {
py_class!(class C |py| {
data _data: i32;
def __new__(_cls, arg: i32) -> PyResult<C> {
C::create_instance(py, arg)
}
});
let gil = Python::acquire_gil();
let py = gil.python();
let typeobj = py.get_type::<C>();
let obj = typeobj.call(py, (42,), None).unwrap().cast_into::<C>(py).unwrap();
let typeobj = py.get_type::<NewWithOneArg>();
let obj = typeobj.call(py, (42,), None).unwrap().cast_into::<NewWithOneArg>(py).unwrap();
assert_eq!(*obj._data(py), 42);
}
py_class!(class NewWithTwoArgs |py| {
data _data1: i32;
data _data2: i32;
def __new__(_cls, arg1: i32, arg2: i32) -> PyResult<NewWithTwoArgs> {
NewWithTwoArgs::create_instance(py, arg1, arg2)
}
});
#[test]
fn new_with_two_args() {
py_class!(class C |py| {
data _data1: i32;
data _data2: i32;
def __new__(_cls, arg1: i32, arg2: i32) -> PyResult<C> {
C::create_instance(py, arg1, arg2)
}
});
let gil = Python::acquire_gil();
let py = gil.python();
let typeobj = py.get_type::<C>();
let obj = typeobj.call(py, (10, 20), None).unwrap().cast_into::<C>(py).unwrap();
let typeobj = py.get_type::<NewWithTwoArgs>();
let obj = typeobj.call(py, (10, 20), None).unwrap().cast_into::<NewWithTwoArgs>(py).unwrap();
assert_eq!(*obj._data1(py), 10);
assert_eq!(*obj._data2(py), 20);
}
struct TestDropCall {
drop_called: Arc<AtomicBool>
}
impl Drop for TestDropCall {
fn drop(&mut self) {
self.drop_called.store(true, Ordering::Relaxed);
}
}
py_class!(class DataIsDropped |py| {
data member1: TestDropCall;
data member2: TestDropCall;
});
#[test]
#[allow(dead_code)]
fn data_is_dropped() {
struct MyObj {
drop_called: Arc<AtomicBool>
}
impl Drop for MyObj {
fn drop(&mut self) {
self.drop_called.store(true, Ordering::Relaxed);
}
}
py_class!(class C |py| {
data member1: MyObj;
data member2: MyObj;
});
let gil = Python::acquire_gil();
let py = gil.python();
let drop_called1 = Arc::new(AtomicBool::new(false));
let drop_called2 = Arc::new(AtomicBool::new(false));
let inst = C::create_instance(py,
MyObj { drop_called: drop_called1.clone() },
MyObj { drop_called: drop_called2.clone() });
let inst = DataIsDropped::create_instance(py,
TestDropCall { drop_called: drop_called1.clone() },
TestDropCall { drop_called: drop_called2.clone() });
assert!(drop_called1.load(Ordering::Relaxed) == false);
assert!(drop_called2.load(Ordering::Relaxed) == false);
drop(inst);