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: memo.rs
    path of file: ./repos/leptos/leptos_reactive/tests
    
    the code of the file until where you have to start completion: use leptos_reactive::*;

#[test]
fn basic_memo() {
    let runtime = create_runtime();

    let a = create_memo(|_| 5);
    assert_eq!(a.get(), 5);

    runtime.dispose();
}

#[test]
fn signal_with_untracked() {
    use leptos_reactive::SignalWithUntracked;

    let runtime = create_runtime();

    let m = create_memo(move |_| 5);
    let copied_out = m.with_untracked(|value| *value);
    assert_eq!(copied_out, 5);

    runtime.dispose();
}

#[test]
fn signal_get_untracked() {
    use leptos_reactive::SignalGetUntracked;

    let runtime = create_runtime();

    let m = create_memo(move |_| "memo".to_owned());
    let cloned_out = m.get_untracked();
    assert_eq!(cloned_out, "memo".to_owned());

    runtime.dispose();
}

#[test]
fn memo_with_computed_value() {
    let runtime = create_runtime();

    let (a, set_a) = create_signal(0);
    let (b, set_b) = create_signal(0);
    let c = create_memo(move |_| a.get() + b.get());
    assert_eq!(c.get(), 0);
    set_a.set(5);
    assert_eq!(c.get(), 5);
    set_b.set(1);
    assert_
    
fn memo_runs_only_when_inputs_change() {
    use std::{cell::Cell, rc::Rc};

    let runtime = create_runtime();

    let call_count = Rc::new(Cell::new(0));
    let (a, set_a) = create_signal(0);
    let (b, _) = create_signal(0);
    let (c, _) = create_signal(0);

    // pretend that this is some kind of expensive computation and we need to access its its value often
    // we could do this with a derived signal, but that would re-run the computation
    // memos should only run when their inputs actually change: this is the only point
    let c = create_memo({
        let call_count = call_count.clone();
        move |_| {
            call_count.set(call_count.get() + 1);
            a.get() + b.get() + c.get()
        }
    });

    // initially the memo has not been called at all, because it's lazy
    assert_eq!(call_count.get(), 0);

    // here we access the value a bunch of times
    assert_eq!(c.get(), 0);
    assert_eq!(c.get(), 0);
    assert_eq!(c.get(), 0);
    assert_eq!(c.get(), 0);
    assert_eq!(c.get(), 0);

    // we've still only called the memo calculation once
    assert_eq!(call_count.get(), 1);

    // and we only call it again when an input changes
    set_a.set(1);
    assert_eq!(c.get(), 1);
    assert_eq!(call_count.get(), 2);

    runtime.dispose();
}