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: conversion.rs
    path of file: ./repos/grafbase/engine/crates/engine-v2/schema/tests
    
    the code of the file until where you have to start completion: use engine_v2_schema::{Definition, Schema};

    
fn should_remove_all_inaccessible_items() {
    let graph = FederatedGraph::from_sdl(SCHEMA_WITH_INACCESSIBLES)
        .unwrap()
        .into_latest();
    let config = config::VersionedConfig::V3(config::latest::Config::from_graph(graph)).into_latest();
    let schema = Schema::from(config);

    // Inaccessible types are still in the schema, they're just not reachable through input and output fields.
    assert!(schema.walker().definition_by_name("BookInput").is_some());
    assert!(schema.walker().definition_by_name("TVContent").is_some());
    assert!(schema.walker().definition_by_name("UngulateType").is_some());
    assert!(schema.walker().definition_by_name("Old").is_some());

    // Input object fields
    {
        let Some(Definition::InputObject(book_input_2)) = schema.walker().definition_by_name("BookInput2") else {
            panic!("missing BookInput2");
        };

        let book_input_2 = schema.walk(book_input_2);

        assert!(!book_input_2.input_fields().any(|field| field.name() == "author"));
    }

    // Field arguments
    {
        let Some(Definition::Object(mutation)) = schema.walker().definition_by_name("Mutation") else {
            panic!("missing Mutation");
        };

        let mutation = schema.walk(mutation);

        let field = mutation.fields().find(|field| field.name() == "addBook").unwrap();

        assert!(field.argument_by_name("input").is_none())
    }

    // Object fields
    {
        let Some(Definition::Object(query)) = schema.walker().definition_by_name("Query") else {
            panic!("missing Query");
        };

        let query = schema.walk(query);

        assert!(!query.fields().any(|f| f.name() == "currentTime"));
        assert!(query.fields().any(|f| f.name() == "getNew"));
    }

    // Enum values
    {
        let Some(Definition::Enum(ungulate_type)) = schema.definition_by_name("UngulateType") else {
            panic!("Expected UngulateType to be defined");
        };

        let r#enum = schema.walk(ungulate_type);
        assert!(r#enum.values().any(|value| value.name() == "GIRAFFE"));
        assert!(!r#enum.values().any(|value| value.name() == "HORSE"));
    }

    // Union members
    {
        let Some(Definition::Union(continent)) = schema.definition_by_name("Continent") else {
            panic!("Expected Continent to be defined");
        };

        let members = schema
            .walk(continent)
            .possible_types()
            .map(|t| t.name())
            .collect::<Vec<_>>();

        assert_eq!(members, &["New"])
    }
}