From a90919c7d1de970039d4a61169267342bcabef2c Mon Sep 17 00:00:00 2001 From: Mike Foster Date: Sun, 21 Apr 2024 11:50:31 +0000 Subject: [PATCH] cargo expand --test test_pyo3test --- tests/test_pyo3test.expanded.rs | 354 ++++++++++++++++++++++++++++++++ 1 file changed, 354 insertions(+) create mode 100644 tests/test_pyo3test.expanded.rs diff --git a/tests/test_pyo3test.expanded.rs b/tests/test_pyo3test.expanded.rs new file mode 100644 index 00000000000..ee10b3fb01b --- /dev/null +++ b/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 = 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 = 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, + ], + ) +}