Changing test names.

tests/lexer.rs

@@ -0,0 +1,147 @@
+use std::fs::{self, File};
+use std::io::Write;
+use std::path::PathBuf;
+
+use rune::*;
+
+
+
+struct TestCase<'a>
+{
+   name: &'a str,
+   input: &'a str,
+   expected: Vec<(TokenType, &'a str)>
+}
+
+
+
+fn dummy_transform(tokens: &TokenStream<TokenType>) -> TokenStream<TokenType>
+{
+   /*
+   let mut stream: TokenStream<(TokenType, String)> = TokenStream::default();
+
+   stream.lexemes = tokens.lexemes.clone();
+   stream.locations = tokens.locations.clone();
+
+   for 0..tokens.lexemes.len()
+   {
+      stream.variants
+   }
+
+   stream
+   */
+   tokens.clone()
+}
+
+fn write_temp_file(name: &str, content: &str) -> PathBuf
+{
+   let mut path = std::env::temp_dir();
+   path.push(format!("rune_test_{}.txt", name));
+   let mut file = File::create(&path).expect("Failed to create temp file");
+   write!(file, "{}", content).expect("Failed to write test content");
+   path
+}
+
+fn cleanup_temp_file(path: &PathBuf)
+{
+   if path.exists()
+   {
+      let _ = fs::remove_file(path);
+   }
+}
+
+
+
+#[test]
+fn basic_lexing()
+{
+   let tokens =
+      Lexer::scan_text("magic runes", dummy_transform).expect("Lexer should \
+                                                               succeed");
+
+   let tokens = tokens.into_iter()
+                      .map(|t| (*t.variant, String::from(t.lexeme)))
+                      .collect::<Vec<_>>();
+
+   let expected = vec![(TokenType::Text, "magic".to_string()),
+                       (TokenType::Whitespace, " ".to_string()),
+                       (TokenType::Text, "runes".to_string()),];
+
+   assert_eq!(tokens, expected);
+}
+
+
+#[test]
+fn symbols_and_numbers()
+{
+   let tokens =
+      Lexer::scan_text("13 + 37", dummy_transform).expect("Lexer should \
+                                                           succeed");
+
+   let tokens = tokens.into_iter()
+                      .map(|t| (*t.variant, String::from(t.lexeme)))
+                      .collect::<Vec<_>>();
+
+   let expected = vec![(TokenType::Numeric, "13".into()),
+                       (TokenType::Whitespace, " ".into()),
+                       (TokenType::Symbol, "+".into()),
+                       (TokenType::Whitespace, " ".into()),
+                       (TokenType::Numeric, "37".into()),];
+
+   assert_eq!(tokens, expected);
+}
+
+
+#[test]
+fn lexer_with_cases()
+{
+   let cases = vec![TestCase { name: "simple_words",
+                               input: "magic rune",
+                               expected: vec![(TokenType::Text, "magic"),
+                                              (TokenType::Whitespace, " "),
+                                              (TokenType::Text, "rune"),
+                                              (TokenType::Newline, "\n"),] },
+                    TestCase { name: "symbols_and_digits",
+                               input: "12 + 7",
+                               expected: vec![(TokenType::Numeric, "12"),
+                                              (TokenType::Whitespace, " "),
+                                              (TokenType::Symbol, "+"),
+                                              (TokenType::Whitespace, " "),
+                                              (TokenType::Numeric, "7"),
+                                              (TokenType::Newline, "\n"),] },
+                    TestCase { name: "only_symbols",
+                               input: "###",
+                               expected: vec![(TokenType::Symbol, "#"),
+                                              (TokenType::Symbol, "#"),
+                                              (TokenType::Symbol, "#"),
+                                              (TokenType::Newline, "\n"),] },
+                    TestCase { name: "whitespace_and_text",
+                               input: "   spell",
+                               expected: vec![(TokenType::Whitespace, " "),
+                                              (TokenType::Whitespace, " "),
+                                              (TokenType::Whitespace, " "),
+                                              (TokenType::Text, "spell"),
+                                              (TokenType::Newline, "\n"),] },];
+
+   for case in cases
+   {
+      let path = write_temp_file(case.name, case.input);
+      let result =
+         Lexer::scan_file(&path, dummy_transform).expect(&format!("Lexer failed \
+                                                              on case '{}'",
+                                                             case.name));
+
+      let result = result.into_iter()
+                         .map(|t| (*t.variant, String::from(t.lexeme)))
+                         .collect::<Vec<_>>();
+
+      let expected = case.expected
+                         .iter()
+                         .map(|(ty, s)| (*ty, s.to_string()))
+                         .collect::<Vec<_>>();
+
+      assert_eq!(result, expected, "Mismatch in test case '{}'", case.name);
+
+      cleanup_temp_file(&path);
+   }
+}