Unused warnings don't show if file compiles.

[luckynumberke7in]

Hi, I was working on quiz2 and I accidentally skipped the use the mutable variable output. The finished code compiled but it didn't work as intended (as I didn't write the changes to the mutable variable).

The corresponding text from running the tests was unhelpful for me debugging my issue. if the unused warning was shown before the output of the test info, it would have been a lot easier to figure out.

The test output was tests::itworks panicked at 'index out of bounds: the len is 0 but the index is 0'

My code inside quiz2 was as follows:

// quiz2.rs
// This is a quiz for the following sections:
// - Strings
// - Vecs
// - Move semantics
// - Modules
// - Enums

// Let's build a little machine in the form of a function.
// As input, we're going to give a list of strings and commands. These commands
// determine what action is going to be applied to the string. It can either be:
// - Uppercase the string
// - Trim the string
// - Append "bar" to the string a specified amount of times
// The exact form of this will be:
// - The input is going to be a Vector of a 2-length tuple,
//   the first element is the string, the second one is the command.
// - The output element is going to be a Vector of strings.
// No hints this time!

// I AM NOT DONE

pub enum Command {
    Uppercase,
    Trim,
    Append(usize),
}

mod my_module {
    use super::Command;

    // TODO: Complete the function signature!
    pub fn transformer(input: Vec<(String, Command)>) -> Vec<String> {
        use crate::Command::*;
        // TODO: Complete the output declaration!
        fn add_bar(count: &usize, string: &String) -> String {
            let mut i = 0;
            let mut bard = string.to_string();
            while &i < count {
                bard += "bar";
                i += 1;
            }
            return bard;
        }
        let mut output = vec![];
        for (string, command) in input.iter() {
            // TODO: Complete the function body. You can do it!
            match command {
                Uppercase => string.to_uppercase(), // i needed to push this to output
                Trim => string.trim().to_string(), // and this
                Append(count) => add_bar(count, string), // and this
            };
        }
        return output;
    }
    fn make_test() {
        let test = transformer(vec![("hello".into(), Command::Uppercase)]);
        println!("hello in caps is: {}", test[0]);
    }
}

#[cfg(test)]
mod tests {
    // TODO: What do we need to import to have `transformer` in scope?
    use super::Command;
    use crate::my_module::transformer;

    #[test]
    fn it_works() {
        let output = transformer(vec![
            ("hello".into(), Command::Uppercase),
            (" all roads lead to rome! ".into(), Command::Trim),
            ("foo".into(), Command::Append(1)),
            ("bar".into(), Command::Append(5)),
        ]);
        assert_eq!(output[0], "HELLO");
        assert_eq!(output[1], "all roads lead to rome!");
        assert_eq!(output[2], "foobar");
        assert_eq!(output[3], "barbarbarbarbarbar");
    }
}