Function run

crates/environ/src/module_artifacts.rs:807–866

(u: &mut Unstructured<'_>)

        arbtest::arbtest(|u| run(u)).budget_ms(1_000);

        fn run(u: &mut Unstructured<'_>) -> Result<()> {
            let mut funcs = Vec::new();

            // Build up a random set of functions with random indices.
            for _ in 0..u.int_in_range(1..=200)? {
                #[cfg(feature = "component-model")]
                let choice = u.int_in_range(0..=6)?;
                #[cfg(not(feature = "component-model"))]
                let choice = u.int_in_range(0..=4)?;

                let key = match choice {
                    0 => FuncKey::DefinedWasmFunction(idx(u, 10)?, idx(u, 200)?),
                    1 => FuncKey::ArrayToWasmTrampoline(idx(u, 10)?, idx(u, 200)?),
                    2 => FuncKey::WasmToArrayTrampoline(idx(u, 100)?),
                    3 => FuncKey::WasmToBuiltinTrampoline(u.arbitrary()?),
                    4 => FuncKey::PulleyHostCall(u.arbitrary()?),
                    #[cfg(feature = "component-model")]
                    5 => FuncKey::ComponentTrampoline(u.arbitrary()?, idx(u, 50)?),
                    #[cfg(feature = "component-model")]
                    6 => FuncKey::ResourceDropTrampoline,
                    _ => unreachable!(),
                };
                funcs.push(key);
            }

            // Sort/dedup our list of `funcs` to satisfy the requirement of
            // `CompiledFunctionsTableBuilder::push_func`.
            funcs.sort();
            funcs.dedup();

            let mut builder = CompiledFunctionsTableBuilder::new();
            let mut size = 0;
            let mut expected = Vec::new();
            for key in funcs {
                let length = u.int_in_range(1..=10)?;
                for _ in 0..length {
                    expected.push(key);
                }
                // println!("push {key:?} - {length}");
                builder.push_func(
                    key,
                    FunctionLoc {
                        start: size,
                        length,
                    },
                    FilePos::none(),
                );
                size += length;
            }
            let index = builder.finish();

            let mut expected = expected.iter();
            for i in 0..size {
                // println!("lookup {i}");
                let actual = index.func_by_text_offset(i).unwrap();
                assert_eq!(Some(&actual), expected.next());
            }