Move unit tests into source

Move the unit tests into the relevant source files. There's no need for them to
be seprate, especially when the `tests` directory is meant to be for integration
tests.

The deserialization tests that include JSON files are still in the `tests` dir,
along with the public prelude re-export tests.

1 files changed, 433 insertions, 0 deletions

diff --git a/src/framework/standard/args.rs b/src/framework/standard/args.rs
index bf3056b..0b915b6 100644
--- a/src/framework/standard/args.rs
+++ b/src/framework/standard/args.rs
@@ -944,3 +944,436 @@ fn quotes_extract(token: &Token) -> &str {
         &token.lit
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::{Args, Error as ArgError};
+
+    #[test]
+    fn single_with_empty_message() {
+        let mut args = Args::new("", &["".to_string()]);
+        assert_matches!(args.single::<String>().unwrap_err(), ArgError::Eos);
+
+        let mut args = Args::new("", &[",".to_string()]);
+        assert_matches!(args.single::<String>().unwrap_err(), ArgError::Eos);
+    }
+
+    #[test]
+    fn single_n_with_empty_message() {
+        let args = Args::new("", &["".to_string()]);
+        assert_matches!(args.single_n::<String>().unwrap_err(), ArgError::Eos);
+
+        let args = Args::new("", &[",".to_string()]);
+        assert_matches!(args.single_n::<String>().unwrap_err(), ArgError::Eos);
+    }
+
+    #[test]
+    fn single_quoted_with_empty_message() {
+        let mut args = Args::new("", &["".to_string()]);
+        assert_matches!(args.single_quoted::<String>().unwrap_err(), ArgError::Eos);
+
+        let mut args = Args::new("", &[",".to_string()]);
+        assert_matches!(args.single_quoted::<String>().unwrap_err(), ArgError::Eos);
+    }
+
+    #[test]
+    fn multiple_with_empty_message() {
+        let args = Args::new("", &["".to_string()]);
+        assert_matches!(args.multiple::<String>().unwrap_err(), ArgError::Eos);
+
+        let args = Args::new("", &[",".to_string()]);
+        assert_matches!(args.multiple::<String>().unwrap_err(), ArgError::Eos);
+    }
+
+    #[test]
+    fn multiple_quoted_with_empty_message() {
+        let args = Args::new("", &["".to_string()]);
+        assert_matches!(args.multiple_quoted::<String>().unwrap_err(), ArgError::Eos);
+
+        let args = Args::new("", &[",".to_string()]);
+        assert_matches!(args.multiple_quoted::<String>().unwrap_err(), ArgError::Eos);
+    }
+
+    #[test]
+    fn skip_with_empty_message() {
+        let mut args = Args::new("", &["".to_string()]);
+        assert_matches!(args.skip(), None);
+
+        let mut args = Args::new("", &[",".to_string()]);
+        assert_matches!(args.skip(), None);
+    }
+
+    #[test]
+    fn skip_for_with_empty_message() {
+        let mut args = Args::new("", &["".to_string()]);
+        assert_matches!(args.skip_for(0), None);
+
+        let mut args = Args::new("", &["".to_string()]);
+        assert_matches!(args.skip_for(5), None);
+
+        let mut args = Args::new("", &[",".to_string()]);
+        assert_matches!(args.skip_for(0), None);
+
+        let mut args = Args::new("", &[",".to_string()]);
+        assert_matches!(args.skip_for(5), None);
+    }
+
+    #[test]
+    fn single_i32_with_2_bytes_long_delimiter() {
+        let mut args = Args::new("1, 2", &[", ".to_string()]);
+
+        assert_eq!(args.single::<i32>().unwrap(), 1);
+        assert_eq!(args.single::<i32>().unwrap(), 2);
+    }
+
+    #[test]
+    fn single_i32_with_1_byte_long_delimiter_i32() {
+        let mut args = Args::new("1,2", &[",".to_string()]);
+
+        assert_eq!(args.single::<i32>().unwrap(), 1);
+        assert_eq!(args.single::<i32>().unwrap(), 2);
+    }
+
+    #[test]
+    fn single_i32_with_wrong_char_after_first_arg() {
+        let mut args = Args::new("1, 2", &[",".to_string()]);
+
+        assert_eq!(args.single::<i32>().unwrap(), 1);
+        assert!(args.single::<i32>().is_err());
+    }
+
+    #[test]
+    fn single_i32_with_one_character_being_3_bytes_long() {
+        let mut args = Args::new("1★2", &["★".to_string()]);
+
+        assert_eq!(args.single::<i32>().unwrap(), 1);
+        assert_eq!(args.single::<i32>().unwrap(), 2);
+    }
+
+    #[test]
+    fn single_i32_with_untrimmed_whitespaces() {
+        let mut args = Args::new(" 1, 2 ", &[",".to_string()]);
+
+        assert!(args.single::<i32>().is_err());
+    }
+
+    #[test]
+    fn single_i32_n() {
+        let args = Args::new("1,2", &[",".to_string()]);
+
+        assert_eq!(args.single_n::<i32>().unwrap(), 1);
+        assert_eq!(args.single_n::<i32>().unwrap(), 1);
+    }
+
+    #[test]
+    fn single_quoted_chaining() {
+        let mut args = Args::new(r#""1, 2" "2" """#, &[" ".to_string()]);
+
+        assert_eq!(args.single_quoted::<String>().unwrap(), "1, 2");
+        assert_eq!(args.single_quoted::<String>().unwrap(), "2");
+        assert_eq!(args.single_quoted::<String>().unwrap(), "");
+    }
+
+    #[test]
+    fn single_quoted_and_single_chaining() {
+        let mut args = Args::new(r#""1, 2" "2" "3" 4"#, &[" ".to_string()]);
+
+        assert_eq!(args.single_quoted::<String>().unwrap(), "1, 2");
+        assert!(args.single_n::<i32>().is_err());
+        assert_eq!(args.single::<String>().unwrap(), "\"2\"");
+        assert_eq!(args.single_quoted::<i32>().unwrap(), 3);
+        assert_eq!(args.single::<i32>().unwrap(), 4);
+    }
+
+    #[test]
+    fn full_on_args() {
+        let test_text = "Some text to ensure `full()` works.";
+        let args = Args::new(test_text, &[" ".to_string()]);
+
+        assert_eq!(args.full(), test_text);
+    }
+
+    #[test]
+    fn multiple_quoted_strings_one_delimiter() {
+        let args = Args::new(r#""1, 2" "a" "3" 4 "5"#, &[" ".to_string()]);
+
+        assert_eq!(args.multiple_quoted::<String>().unwrap(), ["1, 2", "a", "3", "4", "\"5"]);
+    }
+
+    #[test]
+    fn multiple_quoted_strings_with_multiple_delimiter() {
+        let args = Args::new(r#""1, 2" "a","3"4 "5"#, &[" ".to_string(), ",".to_string()]);
+
+        assert_eq!(args.multiple_quoted::<String>().unwrap(), ["1, 2", "a", "3", "4", "\"5"]);
+    }
+
+    #[test]
+    fn multiple_quoted_strings_with_multiple_delimiters() {
+        let args = Args::new(r#""1, 2" "a","3" """#, &[" ".to_string(), ",".to_string()]);
+
+        assert_eq!(args.multiple_quoted::<String>().unwrap(), ["1, 2", "a", "3", ""]);
+    }
+
+    #[test]
+    fn multiple_quoted_i32() {
+        let args = Args::new(r#""1" "2" 3"#, &[" ".to_string()]);
+
+        assert_eq!(args.multiple_quoted::<i32>().unwrap(), [1, 2, 3]);
+    }
+
+    #[test]
+    fn multiple_quoted_quote_appears_without_delimiter_in_front() {
+        let args = Args::new(r#"hello, my name is cake" 2"#, &[",".to_string(), " ".to_string()]);
+
+        assert_eq!(args.multiple_quoted::<String>().unwrap(), ["hello", "my", "name", "is", "cake\"", "2"]);
+    }
+
+    #[test]
+    fn multiple_quoted_single_quote() {
+        let args = Args::new(r#"hello "2 b"#, &[",".to_string(), " ".to_string()]);
+
+        assert_eq!(args.multiple_quoted::<String>().unwrap(), ["hello", "\"2 b"]);
+    }
+
+    #[test]
+    fn multiple_quoted_one_quote_pair() {
+        let args = Args::new(r#"hello "2 b""#, &[",".to_string(), " ".to_string()]);
+
+        assert_eq!(args.multiple_quoted::<String>().unwrap(), ["hello", "2 b"]);
+    }
+
+
+    #[test]
+    fn delimiter_before_multiple_quoted() {
+        let args = Args::new(r#","hello, my name is cake" "2""#, &[",".to_string(), " ".to_string()]);
+
+        assert_eq!(args.multiple_quoted::<String>().unwrap(), ["hello, my name is cake", "2"]);
+    }
+
+    #[test]
+    fn no_quote() {
+        let args = Args::new("hello, my name is cake", &[",".to_string(), " ".to_string()]);
+
+        assert_eq!(args.single_quoted_n::<String>().unwrap(), "hello");
+    }
+
+    #[test]
+    fn single_quoted_n() {
+        let args = Args::new(r#""hello, my name is cake","test"#, &[",".to_string()]);
+
+        assert_eq!(args.single_quoted_n::<String>().unwrap(), "hello, my name is cake");
+        assert_eq!(args.single_quoted_n::<String>().unwrap(), "hello, my name is cake");
+    }
+
+    #[test]
+    fn multiple_quoted_starting_with_wrong_delimiter_in_first_quote() {
+        let args = Args::new(r#""hello, my name is cake" "2""#, &[",".to_string(), " ".to_string()]);
+
+        assert_eq!(args.multiple_quoted::<String>().unwrap(), ["hello, my name is cake", "2"]);
+    }
+
+    #[test]
+    fn multiple_quoted_with_one_correct_and_one_invalid_quote() {
+        let args = Args::new(r#""hello, my name is cake" "2""#, &[",".to_string(), " ".to_string()]);
+
+        assert_eq!(args.multiple_quoted::<String>().unwrap(), ["hello, my name is cake", "2"]);
+    }
+
+    #[test]
+    fn find_i32_one_one_byte_delimiter() {
+        let mut args = Args::new("hello,my name is cake 2", &[" ".to_string()]);
+
+        assert_eq!(args.find::<i32>().unwrap(), 2);
+    }
+
+    #[test]
+    fn find_i32_one_three_byte_delimiter() {
+        let mut args = Args::new("hello,my name is cakeé2", &["é".to_string()]);
+
+        assert_eq!(args.find::<i32>().unwrap(), 2);
+    }
+
+    #[test]
+    fn find_i32_multiple_delimiter_but_i32_not_last() {
+        let mut args = Args::new("hello,my name is 2 cake", &[" ".to_string(), ",".to_string()]);
+
+        assert_eq!(args.find::<i32>().unwrap(), 2);
+    }
+
+    #[test]
+    fn find_i32_multiple_delimiter() {
+        let mut args = Args::new("hello,my name is cake 2", &[" ".to_string(), ",".to_string()]);
+
+        assert_eq!(args.find::<i32>().unwrap(), 2);
+    }
+
+    #[test]
+    fn find_n_i32() {
+        let mut args = Args::new("a 2", &[" ".to_string()]);
+
+        assert_eq!(args.find_n::<i32>().unwrap(), 2);
+        assert_eq!(args.find_n::<i32>().unwrap(), 2);
+    }
+
+    #[test]
+    fn skip() {
+        let mut args = Args::new("1 2", &[" ".to_string()]);
+
+        assert_eq!(args.skip().unwrap(), "1");
+        assert_eq!(args.remaining(), 1);
+        assert_eq!(args.single::<String>().unwrap(), "2");
+    }
+
+    #[test]
+    fn skip_for() {
+        let mut args = Args::new("1 2 neko 100", &[" ".to_string()]);
+
+        assert_eq!(args.skip_for(2).unwrap(), ["1", "2"]);
+        assert_eq!(args.remaining(), 2);
+        assert_eq!(args.single::<String>().unwrap(), "neko");
+        assert_eq!(args.single::<String>().unwrap(), "100");
+    }
+
+    #[test]
+    fn len_with_one_delimiter() {
+        let args = Args::new("1 2 neko 100", &[" ".to_string()]);
+
+        assert_eq!(args.len(), 4);
+        assert_eq!(args.remaining(), 4);
+    }
+
+    #[test]
+    fn len_multiple_quoted() {
+        let args = Args::new(r#""hello, my name is cake" "2""#, &[" ".to_string()]);
+
+        assert_eq!(args.len(), 2);
+    }
+
+    #[test]
+    fn remaining_len_before_and_after_single() {
+        let mut args = Args::new("1 2", &[" ".to_string()]);
+
+        assert_eq!(args.remaining(), 2);
+        assert_eq!(args.single::<i32>().unwrap(), 1);
+        assert_eq!(args.remaining(), 1);
+        assert_eq!(args.single::<i32>().unwrap(), 2);
+        assert_eq!(args.remaining(), 0);
+    }
+
+    #[test]
+    fn remaining_len_before_and_after_single_quoted() {
+        let mut args = Args::new(r#""1" "2" "3""#, &[" ".to_string()]);
+
+        assert_eq!(args.remaining(), 3);
+        assert_eq!(args.single_quoted::<i32>().unwrap(), 1);
+        assert_eq!(args.remaining(), 2);
+        assert_eq!(args.single_quoted::<i32>().unwrap(), 2);
+        assert_eq!(args.remaining(), 1);
+        assert_eq!(args.single_quoted::<i32>().unwrap(), 3);
+        assert_eq!(args.remaining(), 0);
+    }
+
+    #[test]
+    fn remaining_len_before_and_after_skip() {
+        let mut args = Args::new("1 2", &[" ".to_string()]);
+
+        assert_eq!(args.remaining(), 2);
+        assert_eq!(args.skip().unwrap(), "1");
+        assert_eq!(args.remaining(), 1);
+        assert_eq!(args.skip().unwrap(), "2");
+        assert_eq!(args.remaining(), 0);
+    }
+
+    #[test]
+    fn remaining_len_before_and_after_skip_empty_string() {
+        let mut args = Args::new("", &[" ".to_string()]);
+
+        assert_eq!(args.remaining(), 0);
+        assert_eq!(args.skip(), None);
+        assert_eq!(args.remaining(), 0);
+    }
+
+    #[test]
+    fn remaining_len_before_and_after_skip_for() {
+        let mut args = Args::new("1 2", &[" ".to_string()]);
+
+        assert_eq!(args.remaining(), 2);
+        assert_eq!(args.skip_for(2), Some(vec!["1".to_string(), "2".to_string()]));
+        assert_eq!(args.skip_for(2), None);
+        assert_eq!(args.remaining(), 0);
+    }
+
+    #[test]
+    fn remaining_len_before_and_after_find() {
+        let mut args = Args::new("a 2 6", &[" ".to_string()]);
+
+        assert_eq!(args.remaining(), 3);
+        assert_eq!(args.find::<i32>().unwrap(), 2);
+        assert_eq!(args.remaining(), 2);
+        assert_eq!(args.find::<i32>().unwrap(), 6);
+        assert_eq!(args.remaining(), 1);
+        assert_eq!(args.find::<String>().unwrap(), "a");
+        assert_eq!(args.remaining(), 0);
+        assert_matches!(args.find::<String>().unwrap_err(), ArgError::Eos);
+        assert_eq!(args.remaining(), 0);
+    }
+
+    #[test]
+    fn remaining_len_before_and_after_find_n() {
+        let mut args = Args::new("a 2 6", &[" ".to_string()]);
+
+        assert_eq!(args.remaining(), 3);
+        assert_eq!(args.find_n::<i32>().unwrap(), 2);
+        assert_eq!(args.remaining(), 3);
+    }
+
+
+    #[test]
+    fn multiple_strings_with_one_delimiter() {
+        let args = Args::new("hello, my name is cake 2", &[" ".to_string()]);
+
+        assert_eq!(args.multiple::<String>().unwrap(), ["hello,", "my", "name", "is", "cake", "2"]);
+    }
+
+    #[test]
+    fn multiple_i32_with_one_delimiter() {
+        let args = Args::new("1 2 3", &[" ".to_string()]);
+
+        assert_eq!(args.multiple::<i32>().unwrap(), [1, 2, 3]);
+    }
+
+    #[test]
+    fn multiple_i32_with_one_delimiter_and_parse_error() {
+        let args = Args::new("1 2 3 abc", &[" ".to_string()]);
+
+        assert_matches!(args.multiple::<i32>().unwrap_err(), ArgError::Parse(_));
+    }
+
+    #[test]
+    fn multiple_i32_with_three_delimiters() {
+        let args = Args::new("1 2 3", &[" ".to_string(), ",".to_string()]);
+
+        assert_eq!(args.multiple::<i32>().unwrap(), [1, 2, 3]);
+    }
+
+    #[test]
+    fn single_after_failed_single() {
+        let mut args = Args::new("b 2", &[" ".to_string()]);
+
+        assert_matches!(args.single::<i32>().unwrap_err(), ArgError::Parse(_));
+        // Test that `single` short-circuts on an error and leaves the source as is.
+        assert_eq!(args.remaining(), 2);
+        assert_eq!(args.single::<String>().unwrap(), "b");
+        assert_eq!(args.single::<String>().unwrap(), "2");
+    }
+
+    #[test]
+    fn remaining_len_after_failed_single_quoted() {
+        let mut args = Args::new("b a", &[" ".to_string()]);
+
+        assert_eq!(args.remaining(), 2);
+        // Same goes for `single_quoted` and the alike.
+        assert_matches!(args.single_quoted::<i32>().unwrap_err(), ArgError::Parse(_));
+        assert_eq!(args.remaining(), 2);
+    }
+}