cargo expand --test test_pyo3test

tests/test_pyo3test.expanded.rs

@@ -0,0 +1,354 @@
+#![feature(prelude_import)]
+#![cfg(all(feature = "testing", not(any(PyPy, GraalPy))))]
+#[prelude_import]
+use std::prelude::rust_2021::*;
+#[macro_use]
+extern crate std;
+use pyo3::prelude::*;
+fn o3_addone(num: isize) -> isize {
+    num + 1
+}
+fn py_addone(num: isize) -> isize {
+    o3_addone(num)
+}
+#[doc(hidden)]
+mod py_addone {
+    pub(crate) struct MakeDef;
+    pub const _PYO3_DEF: ::pyo3::impl_::pymethods::PyMethodDef = MakeDef::_PYO3_DEF;
+}
+impl py_addone::MakeDef {
+    const _PYO3_DEF: ::pyo3::impl_::pymethods::PyMethodDef = ::pyo3::impl_::pymethods::PyMethodDef::fastcall_cfunction_with_keywords(
+        "addone\0",
+        ::pyo3::impl_::pymethods::PyCFunctionFastWithKeywords({
+            unsafe extern "C" fn trampoline(
+                _slf: *mut ::pyo3::ffi::PyObject,
+                _args: *const *mut ::pyo3::ffi::PyObject,
+                _nargs: ::pyo3::ffi::Py_ssize_t,
+                _kwnames: *mut ::pyo3::ffi::PyObject,
+            ) -> *mut ::pyo3::ffi::PyObject {
+                ::pyo3::impl_::trampoline::fastcall_with_keywords(
+                    _slf,
+                    _args,
+                    _nargs,
+                    _kwnames,
+                    __pyfunction_py_addone,
+                )
+            }
+            trampoline
+        }),
+        "addone(num)\n--\n\n\0",
+    );
+}
+#[allow(non_snake_case)]
+unsafe fn __pyfunction_py_addone<'py>(
+    py: ::pyo3::Python<'py>,
+    _slf: *mut ::pyo3::ffi::PyObject,
+    _args: *const *mut ::pyo3::ffi::PyObject,
+    _nargs: ::pyo3::ffi::Py_ssize_t,
+    _kwnames: *mut ::pyo3::ffi::PyObject,
+) -> ::pyo3::PyResult<*mut ::pyo3::ffi::PyObject> {
+    let _slf_ref = &_slf;
+    let function = py_addone;
+    const DESCRIPTION: ::pyo3::impl_::extract_argument::FunctionDescription = ::pyo3::impl_::extract_argument::FunctionDescription {
+        cls_name: ::std::option::Option::None,
+        func_name: "addone",
+        positional_parameter_names: &["num"],
+        positional_only_parameters: 0usize,
+        required_positional_parameters: 1usize,
+        keyword_only_parameters: &[],
+    };
+    let mut output = [::std::option::Option::None; 1usize];
+    let (_args, _kwargs) = DESCRIPTION
+        .extract_arguments_fastcall::<
+            ::pyo3::impl_::extract_argument::NoVarargs,
+            ::pyo3::impl_::extract_argument::NoVarkeywords,
+        >(py, _args, _nargs, _kwnames, &mut output)?;
+    #[allow(clippy::let_unit_value)]
+    let mut holder_0 = ::pyo3::impl_::extract_argument::FunctionArgumentHolder::INIT;
+    let gil_refs_checker_0 = ::pyo3::impl_::deprecations::GilRefs::new();
+    let result = ::pyo3::impl_::wrap::map_result_into_ptr(
+        py,
+        ::pyo3::impl_::wrap::OkWrap::wrap(
+                function(
+                    ::pyo3::impl_::deprecations::inspect_type(
+                        ::pyo3::impl_::extract_argument::extract_argument(
+                            ::pyo3::impl_::extract_argument::unwrap_required_argument(
+                                output[0usize].as_deref(),
+                            ),
+                            &mut holder_0,
+                            "num",
+                        )?,
+                        &gil_refs_checker_0,
+                    ),
+                ),
+            )
+            .map_err(::core::convert::Into::<::pyo3::PyErr>::into),
+    );
+    gil_refs_checker_0.function_arg();
+    result
+}
+#[allow(clippy::used_underscore_binding)]
+fn py_adders(module: &Bound<'_, PyModule>) -> PyResult<()> {
+    let check_gil_refs = ::pyo3::impl_::deprecations::GilRefs::new();
+    let module = ::pyo3::impl_::deprecations::inspect_type(module, &check_gil_refs);
+    check_gil_refs.function_arg();
+    #[allow(unknown_lints, unused_imports, redundant_imports)]
+    use ::pyo3::{PyNativeType, types::PyModuleMethods};
+    module
+        .add_function(
+            {
+                use py_addone as wrapped_pyfunction;
+                let check_gil_refs = ::pyo3::impl_::deprecations::GilRefs::new();
+                let py_or_module = ::pyo3::impl_::deprecations::inspect_type(
+                    module,
+                    &check_gil_refs,
+                );
+                check_gil_refs.is_python();
+                ::pyo3::impl_::pyfunction::WrapPyFunctionArg::wrap_pyfunction(
+                    py_or_module,
+                    &wrapped_pyfunction::_PYO3_DEF,
+                )
+            }?,
+        )?;
+    Ok(())
+}
+mod py_adders {
+    #[doc(hidden)]
+    pub const __PYO3_NAME: &'static str = "adders\u{0}";
+    pub(super) struct MakeDef;
+    #[doc(hidden)]
+    pub static _PYO3_DEF: ::pyo3::impl_::pymodule::ModuleDef = MakeDef::make_def();
+    /// This autogenerated function is called by the python interpreter when importing
+    /// the module.
+    #[doc(hidden)]
+    #[export_name = "PyInit_adders"]
+    pub unsafe extern "C" fn __pyo3_init() -> *mut ::pyo3::ffi::PyObject {
+        ::pyo3::impl_::trampoline::module_init(|py| _PYO3_DEF.make_module(py))
+    }
+}
+impl py_adders::MakeDef {
+    const fn make_def() -> ::pyo3::impl_::pymodule::ModuleDef {
+        fn __pyo3_pymodule(
+            module: &::pyo3::Bound<'_, ::pyo3::types::PyModule>,
+        ) -> ::pyo3::PyResult<()> {
+            py_adders(
+                ::std::convert::Into::into(::pyo3::impl_::pymethods::BoundRef(module)),
+            )
+        }
+        const INITIALIZER: ::pyo3::impl_::pymodule::ModuleInitializer = ::pyo3::impl_::pymodule::ModuleInitializer(
+            __pyo3_pymodule,
+        );
+        unsafe {
+            ::pyo3::impl_::pymodule::ModuleDef::new(
+                py_adders::__PYO3_NAME,
+                "\0",
+                INITIALIZER,
+            )
+        }
+    }
+}
+extern crate test;
+#[cfg(test)]
+#[rustc_test_marker = "test_pyo3test_without_macro"]
+pub const test_pyo3test_without_macro: test::TestDescAndFn = test::TestDescAndFn {
+    desc: test::TestDesc {
+        name: test::StaticTestName("test_pyo3test_without_macro"),
+        ignore: false,
+        ignore_message: ::core::option::Option::None,
+        source_file: "tests/test_pyo3test.rs",
+        start_line: 25usize,
+        start_col: 4usize,
+        end_line: 25usize,
+        end_col: 31usize,
+        compile_fail: false,
+        no_run: false,
+        should_panic: test::ShouldPanic::No,
+        test_type: test::TestType::IntegrationTest,
+    },
+    testfn: test::StaticTestFn(
+        #[coverage(off)]
+        || test::assert_test_result(test_pyo3test_without_macro()),
+    ),
+};
+fn test_pyo3test_without_macro() {
+    unsafe {
+        if ::pyo3::ffi::Py_IsInitialized() != 0 {
+            {
+                ::core::panicking::panic_fmt(
+                    format_args!(
+                        "called `append_to_inittab` but a Python interpreter is already running.",
+                    ),
+                );
+            };
+        }
+        ::pyo3::ffi::PyImport_AppendInittab(
+            py_adders::__PYO3_NAME.as_ptr() as *const ::std::os::raw::c_char,
+            ::std::option::Option::Some(py_adders::__pyo3_init),
+        );
+    };
+    pyo3::prepare_freethreaded_python();
+    Python::with_gil(|py| {
+        let adders = py.import_bound("adders").expect("Failed to import adders");
+        let addone = adders.getattr("addone").expect("Failed to get addone function");
+        let result: PyResult<isize> = match addone.call1((1_isize,)) {
+            Ok(r) => r.extract(),
+            Err(e) => Err(e),
+        };
+        let result = result.unwrap();
+        let expected_result = 2_isize;
+        match (&result, &expected_result) {
+            (left_val, right_val) => {
+                if !(*left_val == *right_val) {
+                    let kind = ::core::panicking::AssertKind::Eq;
+                    ::core::panicking::assert_failed(
+                        kind,
+                        &*left_val,
+                        &*right_val,
+                        ::core::option::Option::None,
+                    );
+                }
+            }
+        };
+    });
+}
+extern crate test;
+#[cfg(test)]
+#[rustc_test_marker = "test_pyo3test_simple_case"]
+pub const test_pyo3test_simple_case: test::TestDescAndFn = test::TestDescAndFn {
+    desc: test::TestDesc {
+        name: test::StaticTestName("test_pyo3test_simple_case"),
+        ignore: false,
+        ignore_message: ::core::option::Option::None,
+        source_file: "tests/test_pyo3test.rs",
+        start_line: 46usize,
+        start_col: 4usize,
+        end_line: 46usize,
+        end_col: 29usize,
+        compile_fail: false,
+        no_run: false,
+        should_panic: test::ShouldPanic::No,
+        test_type: test::TestType::IntegrationTest,
+    },
+    testfn: test::StaticTestFn(
+        #[coverage(off)]
+        || test::assert_test_result(test_pyo3test_simple_case()),
+    ),
+};
+fn test_pyo3test_simple_case() {
+    unsafe {
+        if ::pyo3::ffi::Py_IsInitialized() != 0 {
+            {
+                ::core::panicking::panic_fmt(
+                    format_args!(
+                        "called `append_to_inittab` but a Python interpreter is already running.",
+                    ),
+                );
+            };
+        }
+        ::pyo3::ffi::PyImport_AppendInittab(
+            py_adders::__PYO3_NAME.as_ptr() as *const ::std::os::raw::c_char,
+            ::std::option::Option::Some(py_adders::__pyo3_init),
+        );
+    };
+    pyo3::prepare_freethreaded_python();
+    Python::with_gil(|py| {
+        let adders = py.import_bound("adders").expect("Failed to import adders");
+        let addone = adders.getattr("addone").expect("Failed to get addone function");
+        let result: PyResult<isize> = match addone.call1((1_isize,)) {
+            Ok(r) => r.extract(),
+            Err(e) => Err(e),
+        };
+        let result = result.unwrap();
+        let expected_result = 2_isize;
+        match (&result, &expected_result) {
+            (left_val, right_val) => {
+                if !(*left_val == *right_val) {
+                    let kind = ::core::panicking::AssertKind::Eq;
+                    ::core::panicking::assert_failed(
+                        kind,
+                        &*left_val,
+                        &*right_val,
+                        ::core::option::Option::None,
+                    );
+                }
+            }
+        };
+    });
+}
+extern crate test;
+#[cfg(test)]
+#[rustc_test_marker = "test_pyo3test_import_module_only"]
+pub const test_pyo3test_import_module_only: test::TestDescAndFn = test::TestDescAndFn {
+    desc: test::TestDesc {
+        name: test::StaticTestName("test_pyo3test_import_module_only"),
+        ignore: false,
+        ignore_message: ::core::option::Option::None,
+        source_file: "tests/test_pyo3test.rs",
+        start_line: 58usize,
+        start_col: 4usize,
+        end_line: 58usize,
+        end_col: 36usize,
+        compile_fail: false,
+        no_run: false,
+        should_panic: test::ShouldPanic::No,
+        test_type: test::TestType::IntegrationTest,
+    },
+    testfn: test::StaticTestFn(
+        #[coverage(off)]
+        || test::assert_test_result(test_pyo3test_import_module_only()),
+    ),
+};
+fn test_pyo3test_import_module_only() {
+    unsafe {
+        if ::pyo3::ffi::Py_IsInitialized() != 0 {
+            {
+                ::core::panicking::panic_fmt(
+                    format_args!(
+                        "called `append_to_inittab` but a Python interpreter is already running.",
+                    ),
+                );
+            };
+        }
+        ::pyo3::ffi::PyImport_AppendInittab(
+            py_adders::__PYO3_NAME.as_ptr() as *const ::std::os::raw::c_char,
+            ::std::option::Option::Some(py_adders::__pyo3_init),
+        );
+    };
+    pyo3::prepare_freethreaded_python();
+    Python::with_gil(|py| {
+        let adders = py.import_bound("adders").expect("Failed to import adders");
+        let result: isize = adders
+            .getattr("addone")
+            .unwrap()
+            .call1((1_isize,))
+            .unwrap()
+            .extract()
+            .unwrap();
+        let expected_result = 2_isize;
+        match (&result, &expected_result) {
+            (left_val, right_val) => {
+                if !(*left_val == *right_val) {
+                    let kind = ::core::panicking::AssertKind::Eq;
+                    ::core::panicking::assert_failed(
+                        kind,
+                        &*left_val,
+                        &*right_val,
+                        ::core::option::Option::None,
+                    );
+                }
+            }
+        };
+    });
+}
+#[rustc_main]
+#[coverage(off)]
+pub fn main() -> () {
+    extern crate test;
+    test::test_main_static(
+        &[
+            &test_pyo3test_import_module_only,
+            &test_pyo3test_simple_case,
+            &test_pyo3test_without_macro,
+        ],
+    )
+}