Function make_api_calls

crates/fuzzing/src/oracles/api.rs:7–1333

Invoke the given API calls.

(api: ApiCalls)

/// Invoke the given API calls.
pub fn make_api_calls(api: ApiCalls) {
    // The generator always starts with StoreNew; use its config to build the
    // shared engine that all stores in this sequence will use.
    let (engine, gc_enabled) = match api.calls.first() {
        Some(ApiCall::StoreNew { config, .. }) => (
            Engine::new(&config.to_wasmtime()).unwrap(),
            config.module_config.config.gc_enabled,
        ),
        _ => return,
    };

    let mut stores: HashMap<usize, Store<StoreLimits>> = Default::default();
    let mut modules: HashMap<usize, Module> = Default::default();
    let mut instances: HashMap<usize, (Instance, usize)> = Default::default();
    let mut global_types: HashMap<usize, GlobalType> = Default::default();
    let mut globals: HashMap<usize, (Global, usize)> = Default::default();
    let mut table_types: HashMap<usize, TableType> = Default::default();
    let mut tables: HashMap<usize, (Table, usize)> = Default::default();
    let mut memory_types: HashMap<usize, MemoryType> = Default::default();
    let mut memories: HashMap<usize, (Memory, usize)> = Default::default();
    let mut func_types: HashMap<usize, FuncType> = Default::default();
    let mut funcs: HashMap<usize, (Func, usize)> = Default::default();
    let mut tag_types: HashMap<usize, TagType> = Default::default();
    let mut tags: HashMap<usize, (Tag, usize)> = Default::default();
    let mut struct_types: HashMap<usize, StructType> = Default::default();
    let mut struct_ref_pres: HashMap<usize, (StructRefPre, StructType, usize)> = Default::default();
    let mut struct_refs: HashMap<usize, (OwnedRooted<StructRef>, usize)> = Default::default();
    let mut array_types: HashMap<usize, ArrayType> = Default::default();
    let mut array_ref_pres: HashMap<usize, (ArrayRefPre, ArrayType, usize)> = Default::default();
    let mut array_refs: HashMap<usize, (OwnedRooted<ArrayRef>, usize)> = Default::default();
    let mut exn_types: HashMap<usize, ExnType> = Default::default();
    let mut exn_ref_pres: HashMap<usize, (ExnRefPre, ExnType, usize)> = Default::default();
    let mut exn_refs: HashMap<usize, (OwnedRooted<ExnRef>, usize)> = Default::default();

    for call in api.calls {
        match call {
            ApiCall::StoreNew { id, config } => {
                log::trace!("creating store {id}");
                let mut store = Store::new(&engine, StoreLimits::new());
                config.configure_store(&mut store);
                let old = stores.insert(id, store);
                assert!(old.is_none());
            }

            ApiCall::StoreDrop { id } => {
                log::trace!("dropping store {id}");
                instances.retain(|_, (_, store_id)| *store_id != id);
                globals.retain(|_, (_, store_id)| *store_id != id);
                tables.retain(|_, (_, store_id)| *store_id != id);
                memories.retain(|_, (_, store_id)| *store_id != id);
                funcs.retain(|_, (_, store_id)| *store_id != id);
                tags.retain(|_, (_, store_id)| *store_id != id);
                struct_ref_pres.retain(|_, (_, _, store_id)| *store_id != id);
                struct_refs.retain(|_, (_, store_id)| *store_id != id);
                array_ref_pres.retain(|_, (_, _, store_id)| *store_id != id);
                array_refs.retain(|_, (_, store_id)| *store_id != id);
                exn_ref_pres.retain(|_, (_, _, store_id)| *store_id != id);
                exn_refs.retain(|_, (_, store_id)| *store_id != id);