You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: guest_fault.rs
    path of file: ./repos/lucet/lucet-runtime/lucet-runtime-tests/src
    
    the code of the file until where you have to start completion: #[macro_export]
macro_rules! guest_fault_common_defs {
    () => {
        use common::{
            mock_traps_module, stack_testcase, wat_traps_module, HOSTCALL_TEST_ERROR,
            RECOVERABLE_PTR,
        };
        pub mod common {
            use lucet_module::{FunctionPointer, TrapCode, TrapSite};
            use lucet_runtime::vmctx::{lucet_vmctx, Vmctx};
            use lucet_runtime::{lucet_hostcall, lucet_hostcall_terminate, DlModule, Module};
            use std::panic::panic_any;
            use std::sync::Arc;
            use tempfile::TempDir;
            use $crate::build::test_module_wasm;
            use $crate::helpers::{MockExportBuilder, MockModuleBuilder};

            pub const HOSTCALL
    
                fn hostcall_insufficient_stack() {
                    test_nonex(|| {
                        // NOTE: we must use `wat_traps_module` here because we want to test an
                        // artifact that only exists through `lucetc`: hostcall trampolines. The
                        // mock module will not have trampolines as lucetc generates, and this test
                        // will not see the expected failure if a mock module is used.
                        let module = wat_traps_module();

                        // Require that the entire stack be free when making a hostcall. Since at
                        // least some of the stack will always be used for the backstop, this has
                        // the effect of failing the check for any hostcall.
                        let impossible_hostcall_limits = Limits::default()
                            .with_hostcall_reservation(Limits::default().stack_size);
                        let region =
                            <TestRegion as RegionCreate>::create(
                                1,
                                &impossible_hostcall_limits
                            ).expect("region can be created");
                        let mut inst = region
                            .new_instance(module)
                            .expect("instance can be created");

                        // Run the hostcall `onetwothree` because other than the hostcall stack
                        // limit check, the hostcall in question should complete successfully.
                        match inst.run("make_onetwothree_hostcall", &[]) {
                            Err(Error::RuntimeFault(details)) => {
                                assert_eq!(details.trapcode, Some(TrapCode::StackOverflow));
                            },
                            res => panic!("unexpected result: {:?}", res),
                        }

                        // after a fault, can reset and run a normal function
                        inst.reset().expect("instance resets");

                        run_onetwothree(&mut inst);
                    });
                }