pyo3/tests/test_datetime.rs

#![feature(concat_idents)]

extern crate pyo3;

use pyo3::prelude::*;

use pyo3::ffi::*;

fn _get_subclasses<'p>(
    py: &'p Python,
    py_type: &str,
    args: &str,
) -> (&'p PyObjectRef, &'p PyObjectRef, &'p PyObjectRef) {
    macro_rules! unwrap_py {
        ($e:expr) => {
            ($e).map_err(|e| e.print(*py)).unwrap()
        };
    };

    // Import the class from Python and create some subclasses
    let datetime = unwrap_py!(py.import("datetime"));

    let locals = PyDict::new(*py);
    locals
        .set_item(py_type, datetime.get(py_type).unwrap())
        .unwrap();

    let make_subclass_py = format!("class Subklass({}):\n    pass", py_type);

    let make_sub_subclass_py = "class SubSubklass(Subklass):\n    pass";

    unwrap_py!(py.run(&make_subclass_py, None, Some(&locals)));
    unwrap_py!(py.run(&make_sub_subclass_py, None, Some(&locals)));

    // Construct an instance of the base class
    let obj = unwrap_py!(py.eval(&format!("{}({})", py_type, args), None, Some(&locals)));

    // Construct an instance of the subclass
    let sub_obj = unwrap_py!(py.eval(&format!("Subklass({})", args), None, Some(&locals)));

    // Construct an instance of the sub-subclass
    let sub_sub_obj = unwrap_py!(py.eval(&format!("SubSubklass({})", args), None, Some(&locals)));

    (obj, sub_obj, sub_sub_obj)
}

macro_rules! assert_check_exact {
    ($check_func:ident, $obj: expr) => {
        unsafe {
            assert!($check_func(($obj).as_ptr()) != 0);
            assert!(concat_idents!($check_func, Exact)(($obj).as_ptr()) != 0);
        }
    };
}

macro_rules! assert_check_only {
    ($check_func:ident, $obj: expr) => {
        unsafe {
            assert!($check_func(($obj).as_ptr()) != 0);
            assert!(concat_idents!($check_func, Exact)(($obj).as_ptr()) == 0);
        }
    };
}

#[test]
fn test_date_check() {
    let gil = Python::acquire_gil();
    let py = gil.python();
    let (obj, sub_obj, sub_sub_obj) = _get_subclasses(&py, "date", "2018, 1, 1");

    assert_check_exact!(PyDate_Check, obj);
    assert_check_only!(PyDate_Check, sub_obj);
    assert_check_only!(PyDate_Check, sub_sub_obj);
}

#[test]
fn test_time_check() {
    let gil = Python::acquire_gil();
    let py = gil.python();
    let (obj, sub_obj, sub_sub_obj) = _get_subclasses(&py, "time", "12, 30, 15");

    assert_check_exact!(PyTime_Check, obj);
    assert_check_only!(PyTime_Check, sub_obj);
    assert_check_only!(PyTime_Check, sub_sub_obj);
}

#[test]
fn test_datetime_check() {
    let gil = Python::acquire_gil();
    let py = gil.python();
    let (obj, sub_obj, sub_sub_obj) = _get_subclasses(&py, "datetime", "2018, 1, 1, 13, 30, 15");

    assert_check_only!(PyDate_Check, obj);
    assert_check_exact!(PyDateTime_Check, obj);
    assert_check_only!(PyDateTime_Check, sub_obj);
    assert_check_only!(PyDateTime_Check, sub_sub_obj);
}

#[test]
fn test_delta_check() {
    let gil = Python::acquire_gil();
    let py = gil.python();
    let (obj, sub_obj, sub_sub_obj) = _get_subclasses(&py, "timedelta", "1, -3");

    assert_check_exact!(PyDelta_Check, obj);
    assert_check_only!(PyDelta_Check, sub_obj);
    assert_check_only!(PyDelta_Check, sub_sub_obj);
}