Add more tests for array

Author: BijanVeyssi

src/error/mod.rs

@@ -465,6 +465,10 @@ mod tests {
             EvalexprError::expected_type(&Value::Tuple(vec![]), Value::Empty),
             EvalexprError::expected_tuple(Value::Empty)
         );
+        assert_eq!(
+            EvalexprError::expected_type(&Value::Array(vec![]), Value::Empty),
+            EvalexprError::expected_array(Value::Empty)
+        );
         assert_eq!(
             EvalexprError::expected_type(&Value::Empty, Value::String("abc".to_string())),
             EvalexprError::expected_empty(Value::String("abc".to_string()))

src/token/mod.rs

@@ -517,7 +517,7 @@ mod tests {
     #[test]
     fn test_token_display() {
         let token_string =
-            "+ - * / % ^ == != > < >= <= && || ! ( ) = += -= *= /= %= ^= &&= ||= , ; ";
+            "+ - * / % ^ == != > < >= <= && || ! ( ) = += -= *= /= %= ^= &&= ||= , ; { } ";
         let tokens = tokenize(token_string).unwrap();
         let mut result_string = String::new();
 

src/value/mod.rs

@@ -315,7 +315,7 @@ impl TryFrom<Value> for () {
 
 #[cfg(test)]
 mod tests {
-    use crate::value::{TupleType, Value};
+    use crate::value::{ArrayType, TupleType, Value};
 
     #[test]
     fn test_value_conversions() {
@@ -330,6 +330,16 @@ mod tests {
             Value::from(TupleType::new()).as_tuple(),
             Ok(TupleType::new())
         );
+        assert_eq!(Value::from(TupleType::new()).as_vec(), Ok(vec![]));
+        assert_eq!(Value::Array(ArrayType::new()).as_vec(), Ok(vec![]));
+        assert_eq!(
+            Value::from(TupleType::new()).as_slice(),
+            Ok(vec![].as_slice())
+        );
+        assert_eq!(
+            Value::Array(ArrayType::new()).as_slice(),
+            Ok(vec![].as_slice())
+        );
     }
 
     #[test]
@@ -339,5 +349,6 @@ mod tests {
         assert!(Value::from(3.3).is_float());
         assert!(Value::from(true).is_boolean());
         assert!(Value::from(TupleType::new()).is_tuple());
+        assert!(Value::Array(ArrayType::new()).is_array());
     }
 }

tests/integration.rs

@@ -572,6 +572,10 @@ fn test_builtin_functions() {
         eval("str::from(1, 2, 3)"),
         Ok(Value::String(String::from("(1, 2, 3)")))
     );
+    assert_eq!(
+        eval("str::from({1, 2, 3})"),
+        Ok(Value::String(String::from("{1, 2, 3}")))
+    );
     assert_eq!(eval("str::from()"), Ok(Value::String(String::from("()"))));
     assert_eq!(
         eval("str::substring(\"foobar\", 3)"),
@@ -910,6 +914,46 @@ fn test_shortcut_functions() {
         Err(EvalexprError::VariableIdentifierNotFound("3a3".to_owned()))
     );
 
+    assert_eq!(eval_array("{3,3}"), Ok(vec![Value::Int(3), Value::Int(3)]));
+    assert_eq!(
+        eval_array("33"),
+        Err(EvalexprError::ExpectedArray {
+            actual: Value::Int(33)
+        })
+    );
+    assert_eq!(
+        eval_array("3a3"),
+        Err(EvalexprError::VariableIdentifierNotFound("3a3".to_owned()))
+    );
+    assert_eq!(
+        eval_array_with_context("{3,3}", &context),
+        Ok(vec![Value::Int(3), Value::Int(3)])
+    );
+    assert_eq!(
+        eval_array_with_context("33", &context),
+        Err(EvalexprError::ExpectedArray {
+            actual: Value::Int(33)
+        })
+    );
+    assert_eq!(
+        eval_array_with_context("3a3", &context),
+        Err(EvalexprError::VariableIdentifierNotFound("3a3".to_owned()))
+    );
+    assert_eq!(
+        eval_array_with_context_mut("{3,3}", &mut context),
+        Ok(vec![Value::Int(3), Value::Int(3)])
+    );
+    assert_eq!(
+        eval_array_with_context_mut("33", &mut context),
+        Err(EvalexprError::ExpectedArray {
+            actual: Value::Int(33)
+        })
+    );
+    assert_eq!(
+        eval_array_with_context_mut("3a3", &mut context),
+        Err(EvalexprError::VariableIdentifierNotFound("3a3".to_owned()))
+    );
+
     assert_eq!(eval_empty(""), Ok(EMPTY_VALUE));
     assert_eq!(eval_empty("()"), Ok(EMPTY_VALUE));
     assert_eq!(
@@ -1789,6 +1833,12 @@ fn test_error_constructors() {
             actual: Value::Int(4)
         })
     );
+    assert_eq!(
+        eval_array("4"),
+        Err(EvalexprError::ExpectedArray {
+            actual: Value::Int(4)
+        })
+    );
     assert_eq!(
         Value::Tuple(vec![Value::Int(4), Value::Int(5)]).as_fixed_len_tuple(3),
         Err(EvalexprError::ExpectedFixedLengthTuple {
@@ -1898,6 +1948,7 @@ fn test_value_type() {
     assert_eq!(ValueType::from(&Value::Int(0)), ValueType::Int);
     assert_eq!(ValueType::from(&Value::Boolean(true)), ValueType::Boolean);
     assert_eq!(ValueType::from(&Value::Tuple(Vec::new())), ValueType::Tuple);
+    assert_eq!(ValueType::from(&Value::Array(Vec::new())), ValueType::Array);
     assert_eq!(ValueType::from(&Value::Empty), ValueType::Empty);
 
     assert_eq!(
@@ -1914,20 +1965,26 @@ fn test_value_type() {
         ValueType::from(&mut Value::Tuple(Vec::new())),
         ValueType::Tuple
     );
+    assert_eq!(
+        ValueType::from(&mut Value::Array(Vec::new())),
+        ValueType::Array
+    );
     assert_eq!(ValueType::from(&mut Value::Empty), ValueType::Empty);
 
     assert!(!Value::String(String::new()).is_number());
     assert!(Value::Float(0.0).is_number());
     assert!(Value::Int(0).is_number());
     assert!(!Value::Boolean(true).is_number());
     assert!(!Value::Tuple(Vec::new()).is_number());
+    assert!(!Value::Array(Vec::new()).is_number());
     assert!(!Value::Empty.is_number());
 
     assert!(!Value::String(String::new()).is_empty());
     assert!(!Value::Float(0.0).is_empty());
     assert!(!Value::Int(0).is_empty());
     assert!(!Value::Boolean(true).is_empty());
     assert!(!Value::Tuple(Vec::new()).is_empty());
+    assert!(!Value::Array(Vec::new()).is_empty());
     assert!(Value::Empty.is_empty());
 
     assert_eq!(
@@ -1955,6 +2012,12 @@ fn test_value_type() {
             actual: Value::Tuple(Vec::new())
         })
     );
+    assert_eq!(
+        Value::Array(Vec::new()).as_float(),
+        Err(EvalexprError::ExpectedFloat {
+            actual: Value::Array(Vec::new())
+        })
+    );
     assert_eq!(
         Value::Empty.as_float(),
         Err(EvalexprError::ExpectedFloat {
@@ -2059,6 +2122,12 @@ fn test_value_type() {
             actual: Value::Tuple(Vec::new())
         })
     );
+    assert_eq!(
+        Value::Array(Vec::new()).as_empty(),
+        Err(EvalexprError::ExpectedEmpty {
+            actual: Value::Array(Vec::new())
+        })
+    );
     assert_eq!(Value::Empty.as_empty(), Ok(()));
 
     assert_eq!(