test reorganization

cezaris13 · Dec 8, 2024 · fa8fabc · fa8fabc
1 parent 24d575f
commit fa8fabc
Show file tree

Hide file tree

Showing 3 changed files with 95 additions and 88 deletions.
diff --git a/src/expression_literal_value.rs b/src/expression_literal_value.rs
@@ -4,6 +4,10 @@ use crate::token::{Token, TokenType, LiteralValue as TokenLiteralValue};
 use std::fmt::{Display, Formatter};
 use std::string::String;
 
+#[cfg(test)]
+#[path = "./tests/expression_literal_value_tests.rs"]
+mod tests;
+
 #[derive(Clone, Debug, PartialEq)]
 pub enum LiteralValue {
     IntValue(i64),

diff --git a/src/tests/expression_literal_value_tests.rs b/src/tests/expression_literal_value_tests.rs
@@ -0,0 +1,88 @@
+#[cfg(test)]
+mod tests {
+    use crate::expression_literal_value::LiteralValue;
+    use crate::token::{Token, TokenType};
+
+    #[test]
+    fn literal_value_to_string() {
+        let literals = vec![
+            LiteralValue::Nil,
+            LiteralValue::False,
+            LiteralValue::True,
+            LiteralValue::IntValue(12),
+            LiteralValue::StringValue(String::from("Hello")),
+            LiteralValue::FValue(1.1),
+        ];
+
+        let responses = vec!["nil", "false", "true", "12", "Hello", "1.1"]
+            .iter()
+            .map(|response| String::from(*response))
+            .collect::<Vec<String>>();
+
+        let result = literals
+            .iter()
+            .map(|literal| literal.to_string())
+            .collect::<Vec<String>>();
+
+        assert_eq!(result, responses);
+    }
+
+    #[test]
+    fn literal_value_to_type() {
+        let literals = vec![
+            LiteralValue::Nil,
+            LiteralValue::False,
+            LiteralValue::True,
+            LiteralValue::IntValue(12),
+            LiteralValue::StringValue(String::from("Hello")),
+            LiteralValue::FValue(1.1),
+        ];
+
+        let responses = vec!["Nil", "Bool", "Bool", "Int", "String", "Float"];
+
+        let result = literals
+            .iter()
+            .map(|literal| literal.to_type())
+            .collect::<Vec<&str>>();
+
+        assert_eq!(result, responses);
+    }
+
+    #[test]
+    fn test_from_token() {
+        let tokens = vec![
+            Token::new(TokenType::False, "".to_string(), None, 0),
+            Token::new(TokenType::True, "".to_string(), None, 0),
+            Token::new(TokenType::Nil, "".to_string(), None, 0),
+            Token::new(
+                TokenType::Number,
+                "12".to_string(),
+                Some(crate::token::LiteralValue::IntValue(12)),
+                0,
+            ),
+            Token::new(
+                TokenType::String,
+                "hello".to_string(),
+                Some(crate::token::LiteralValue::StringValue(String::from(
+                    "hello",
+                ))),
+                0,
+            ),
+        ];
+
+        let responses: Vec<LiteralValue> = vec![
+            LiteralValue::False,
+            LiteralValue::True,
+            LiteralValue::Nil,
+            LiteralValue::IntValue(12),
+            LiteralValue::StringValue(String::from("hello")),
+        ];
+
+        let evaluated_expressions = tokens
+            .iter()
+            .map(|token| LiteralValue::from(token.clone()))
+            .collect::<Vec<LiteralValue>>();
+
+        assert_eq!(evaluated_expressions, responses);
+    }
+}
diff --git a/src/tests/expression_tests.rs b/src/tests/expression_tests.rs
@@ -1,12 +1,9 @@
 #[cfg(test)]
 mod tests {
     use crate::environment::Environment;
-    use crate::expression::Expression;
-    use crate::expression::Expression::*;
-    use crate::expression::LiteralValue;
-    use crate::expression::LiteralValue::*;
-    use crate::token::TokenType::*;
-    use crate::token::{Token, TokenType};
+    use crate::expression::Expression::{self, *};
+    use crate::expression_literal_value::LiteralValue::{self, *};
+    use crate::token::{Token, TokenType::*};
     use crate::Parser;
     use crate::Scanner;
 
@@ -166,50 +163,6 @@ mod tests {
         assert_eq!(evaluation.unwrap(), FValue(7.0));
     }
 
-    #[test]
-    fn literal_value_to_string() {
-        let literals = vec![
-            LiteralValue::Nil,
-            LiteralValue::False,
-            LiteralValue::True,
-            LiteralValue::IntValue(12),
-            LiteralValue::StringValue(String::from("Hello")),
-            LiteralValue::FValue(1.1),
-        ];
-
-        let responses = vec!["nil", "false", "true", "12", "Hello", "1.1"]
-            .iter()
-            .map(|response| String::from(*response))
-            .collect::<Vec<String>>();
-
-        let result = literals
-            .iter()
-            .map(|literal| literal.to_string())
-            .collect::<Vec<String>>();
-
-        assert_eq!(result, responses);
-    }
-
-    #[test]
-    fn literal_value_to_type() {
-        let literals = vec![
-            LiteralValue::Nil,
-            LiteralValue::False,
-            LiteralValue::True,
-            LiteralValue::IntValue(12),
-            LiteralValue::StringValue(String::from("Hello")),
-            LiteralValue::FValue(1.1),
-        ];
-
-        let responses = vec!["Nil", "Bool", "Bool", "Int", "String", "Float"];
-
-        let result = literals
-            .iter()
-            .map(|literal| literal.to_type())
-            .collect::<Vec<&str>>();
-
-        assert_eq!(result, responses);
-    }
     #[test]
     fn test_plus_operator() {
         let test_cases: Vec<(&str, Result<LiteralValue, String>)> = vec![
@@ -437,44 +390,6 @@ mod tests {
         assert_eq!(results, expected_results);
     }
 
-    #[test]
-    fn test_from_token() {
-        let tokens = vec![
-            Token::new(TokenType::False, "".to_string(), None, 0),
-            Token::new(TokenType::True, "".to_string(), None, 0),
-            Token::new(TokenType::Nil, "".to_string(), None, 0),
-            Token::new(
-                TokenType::Number,
-                "12".to_string(),
-                Some(crate::token::LiteralValue::IntValue(12)),
-                0,
-            ),
-            Token::new(
-                TokenType::String,
-                "hello".to_string(),
-                Some(crate::token::LiteralValue::StringValue(String::from(
-                    "hello",
-                ))),
-                0,
-            ),
-        ];
-
-        let responses: Vec<LiteralValue> = vec![
-            LiteralValue::False,
-            LiteralValue::True,
-            LiteralValue::Nil,
-            LiteralValue::IntValue(12),
-            LiteralValue::StringValue(String::from("hello")),
-        ];
-
-        let evaluated_expressions = tokens
-            .iter()
-            .map(|token| LiteralValue::from(token.clone()))
-            .collect::<Vec<LiteralValue>>();
-
-        assert_eq!(evaluated_expressions, responses);
-    }
-
     fn evaluate_list_of_sources(sources: &Vec<&str>) -> Vec<Result<LiteralValue, String>> {
         sources
             .iter()