Function run_tool_session

tests/integration/kernel_integration.rs:183–236

Boot the shell with a set of `tools` installed (each named by its catalog key; source, aux modules, and install path come from the user catalog) plus extra `files`, drive `session` over UART, and return (outcome, uart). Collapses the compile-shell + elf-ify-tools + build-image + boot boilerplate every toolchain test repeats; tests keep their own assertions.

(
    tools: &[&str],
    files: &[(&str, &[u8])],
    session: &str,
    max_steps: u64,
)

}

// Collapses the compile-shell, elf-ify-tools, build-image and boot boilerplate
// every toolchain test repeats. Tests keep their own assertions.
fn run_tool_session(
    tools: &[&str],
    files: &[(&str, &[u8])],
    session: &str,
    max_steps: u64,
) -> (StepOutcome, String) {
    let shell = compile_hosted_program("shell");
    let tool_elfs: Vec<(&str, Vec<u8>)> = tools
        .iter()
        .map(|name| {
            let prog = user::program(name).expect("tool not in user catalog");
            let path = prog.install_path.expect("tool has no install path");
            let elf = assembled_to_elf_file(&compile_hosted_program(name));
            (path, elf)
        })
        .collect();

    // Create every parent directory the tool/file paths need, shallowest first.
    let mut dirs: Vec<String> = Vec::new();
    for path in tool_elfs
        .iter()
        .map(|(p, _)| *p)
        .chain(files.iter().map(|(p, _)| *p))
    {
        let mut idx = 0;
        while let Some(slash) = path[idx + 1..].find('/') {
            let end = idx + 1 + slash;
            let dir = path[..end].to_owned();
            if !dirs.contains(&dir) {
                dirs.push(dir);
            }
            idx = end;
        }
    }
    dirs.sort_by_key(|d| d.matches('/').count());

    let mut entries: Vec<FsEntry<'_>> = dirs.iter().map(|d| FsEntry::Dir { path: d }).collect();
    for (path, elf) in &tool_elfs {
        entries.push(FsEntry::File { path, data: elf });
    }
    for (path, data) in files {
        entries.push(FsEntry::File { path, data });
    }
    let image = build_fs_image(&entries);

    let (_, outcome, uart) = boot_kernel(
        cached_kernel(),
        Some(&shell),
        Some(&image),
        session,
        max_steps,
    );
    (outcome, uart)
}