From e80fd2080461768316aa0f1458801552e7897aee Mon Sep 17 00:00:00 2001 From: Sebastian Schmidt Date: Tue, 13 Jul 2021 14:28:25 +0300 Subject: [PATCH] Increase test coverage and fix wrong error in shortcut method. --- src/interface/mod.rs | 4 +- src/token/mod.rs | 3 + tests/integration.rs | 305 +++++++++++++++++++++++++++++++++++++++---- 3 files changed, 286 insertions(+), 26 deletions(-) diff --git a/src/interface/mod.rs b/src/interface/mod.rs index 9147d2c..332b704 100644 --- a/src/interface/mod.rs +++ b/src/interface/mod.rs @@ -181,7 +181,7 @@ pub fn eval_number_with_context( match eval_with_context(string, context) { Ok(Value::Float(float)) => Ok(float), Ok(Value::Int(int)) => Ok(int as FloatType), - Ok(value) => Err(EvalexprError::expected_float(value)), + Ok(value) => Err(EvalexprError::expected_number(value)), Err(error) => Err(error), } } @@ -272,7 +272,7 @@ pub fn eval_number_with_context_mut( match eval_with_context_mut(string, context) { Ok(Value::Float(float)) => Ok(float), Ok(Value::Int(int)) => Ok(int as FloatType), - Ok(value) => Err(EvalexprError::expected_float(value)), + Ok(value) => Err(EvalexprError::expected_number(value)), Err(error) => Err(error), } } diff --git a/src/token/mod.rs b/src/token/mod.rs index 0ae8c85..b15ab08 100644 --- a/src/token/mod.rs +++ b/src/token/mod.rs @@ -122,6 +122,7 @@ fn char_to_partial_token(c: char) -> PartialToken { } impl Token { + #[cfg(not(tarpaulin_include))] pub(crate) const fn is_leftsided_value(&self) -> bool { match self { Token::Plus => false, @@ -165,6 +166,7 @@ impl Token { } } + #[cfg(not(tarpaulin_include))] pub(crate) const fn is_rightsided_value(&self) -> bool { match self { Token::Plus => false, @@ -208,6 +210,7 @@ impl Token { } } + #[cfg(not(tarpaulin_include))] pub(crate) fn is_assignment(&self) -> bool { use Token::*; matches!( diff --git a/tests/integration.rs b/tests/integration.rs index adbb7e0..74e0c95 100644 --- a/tests/integration.rs +++ b/tests/integration.rs @@ -412,28 +412,280 @@ fn test_shortcut_functions() { .set_value("string".into(), Value::from("a string")) .unwrap(); - // assert_eq!(eval_string("???")); + assert_eq!(eval_string("\"3.3\""), Ok("3.3".to_owned())); + assert_eq!( + eval_string("3.3"), + Err(EvalexprError::ExpectedString { + actual: Value::Float(3.3) + }) + ); + assert_eq!( + eval_string("3..3"), + Err(EvalexprError::VariableIdentifierNotFound("3..3".to_owned())) + ); assert_eq!( eval_string_with_context("string", &context), + Ok("a string".to_owned()) + ); + assert_eq!( + eval_string_with_context("3.3", &context), + Err(EvalexprError::ExpectedString { + actual: Value::Float(3.3) + }) + ); + assert_eq!( + eval_string_with_context("3..3", &context), + Err(EvalexprError::VariableIdentifierNotFound("3..3".to_owned())) + ); + assert_eq!( + eval_string_with_context_mut("string", &mut context), Ok("a string".to_string()) ); + assert_eq!( + eval_string_with_context_mut("3.3", &mut context), + Err(EvalexprError::ExpectedString { + actual: Value::Float(3.3) + }) + ); + assert_eq!( + eval_string_with_context_mut("3..3", &mut context), + Err(EvalexprError::VariableIdentifierNotFound("3..3".to_owned())) + ); + assert_eq!(eval_float("3.3"), Ok(3.3)); + assert_eq!( + eval_float("33"), + Err(EvalexprError::ExpectedFloat { + actual: Value::Int(33) + }) + ); + assert_eq!( + eval_float("asd()"), + Err(EvalexprError::FunctionIdentifierNotFound("asd".to_owned())) + ); assert_eq!(eval_float_with_context("3.3", &context), Ok(3.3)); + assert_eq!( + eval_float_with_context("33", &context), + Err(EvalexprError::ExpectedFloat { + actual: Value::Int(33) + }) + ); + assert_eq!( + eval_float_with_context("asd)", &context), + Err(EvalexprError::UnmatchedRBrace) + ); + assert_eq!(eval_float_with_context_mut("3.3", &mut context), Ok(3.3)); + assert_eq!( + eval_float_with_context_mut("33", &mut context), + Err(EvalexprError::ExpectedFloat { + actual: Value::Int(33) + }) + ); + assert_eq!( + eval_float_with_context_mut("asd(", &mut context), + Err(EvalexprError::UnmatchedLBrace) + ); + assert_eq!(eval_int("3"), Ok(3)); + assert_eq!( + eval_int("3.3"), + Err(EvalexprError::ExpectedInt { + actual: Value::Float(3.3) + }) + ); + assert_eq!( + eval_int("(,);."), + Err(EvalexprError::VariableIdentifierNotFound(".".to_owned())) + ); assert_eq!(eval_int_with_context("3", &context), Ok(3)); + assert_eq!( + eval_int_with_context("3.3", &context), + Err(EvalexprError::ExpectedInt { + actual: Value::Float(3.3) + }) + ); + assert_eq!( + eval_int_with_context("(,);.", &context), + Err(EvalexprError::VariableIdentifierNotFound(".".to_owned())) + ); + assert_eq!(eval_int_with_context_mut("3", &mut context), Ok(3)); + assert_eq!( + eval_int_with_context_mut("3.3", &mut context), + Err(EvalexprError::ExpectedInt { + actual: Value::Float(3.3) + }) + ); + assert_eq!( + eval_int_with_context_mut("(,);.", &mut context), + Err(EvalexprError::VariableIdentifierNotFound(".".to_owned())) + ); + assert_eq!(eval_number("3"), Ok(3.0)); + assert_eq!( + eval_number("true"), + Err(EvalexprError::ExpectedNumber { + actual: Value::Boolean(true) + }) + ); + assert_eq!( + eval_number("abc"), + Err(EvalexprError::VariableIdentifierNotFound("abc".to_owned())) + ); assert_eq!(eval_number_with_context("3", &context), Ok(3.0)); + assert_eq!( + eval_number_with_context("true", &context), + Err(EvalexprError::ExpectedNumber { + actual: Value::Boolean(true) + }) + ); + assert_eq!( + eval_number_with_context("abc", &context), + Err(EvalexprError::VariableIdentifierNotFound("abc".to_owned())) + ); + assert_eq!(eval_number_with_context_mut("3", &mut context), Ok(3.0)); + assert_eq!( + eval_number_with_context_mut("true", &mut context), + Err(EvalexprError::ExpectedNumber { + actual: Value::Boolean(true) + }) + ); + assert_eq!( + eval_number_with_context_mut("abc", &mut context), + Err(EvalexprError::VariableIdentifierNotFound("abc".to_owned())) + ); + assert_eq!(eval_boolean("true"), Ok(true)); + assert_eq!( + eval_boolean("4"), + Err(EvalexprError::ExpectedBoolean { + actual: Value::Int(4) + }) + ); + assert_eq!( + eval_boolean("trueee"), + Err(EvalexprError::VariableIdentifierNotFound( + "trueee".to_owned() + )) + ); assert_eq!(eval_boolean_with_context("true", &context), Ok(true)); + assert_eq!( + eval_boolean_with_context("4", &context), + Err(EvalexprError::ExpectedBoolean { + actual: Value::Int(4) + }) + ); + assert_eq!( + eval_boolean_with_context("trueee", &context), + Err(EvalexprError::VariableIdentifierNotFound( + "trueee".to_owned() + )) + ); + assert_eq!( + eval_boolean_with_context_mut("true", &mut context), + Ok(true) + ); + assert_eq!( + eval_boolean_with_context_mut("4", &mut context), + Err(EvalexprError::ExpectedBoolean { + actual: Value::Int(4) + }) + ); + assert_eq!( + eval_boolean_with_context_mut("trueee", &mut context), + Err(EvalexprError::VariableIdentifierNotFound( + "trueee".to_owned() + )) + ); + assert_eq!(eval_tuple("3,3"), Ok(vec![Value::Int(3), Value::Int(3)])); + assert_eq!( + eval_tuple("33"), + Err(EvalexprError::ExpectedTuple { + actual: Value::Int(33) + }) + ); + assert_eq!( + eval_tuple("3a3"), + Err(EvalexprError::VariableIdentifierNotFound("3a3".to_owned())) + ); assert_eq!( eval_tuple_with_context("3,3", &context), Ok(vec![Value::Int(3), Value::Int(3)]) ); - assert_eq!(eval_empty(""), Ok(EMPTY_VALUE)); - assert_eq!(eval_empty_with_context("", &context), Ok(EMPTY_VALUE)); + assert_eq!( + eval_tuple_with_context("33", &context), + Err(EvalexprError::ExpectedTuple { + actual: Value::Int(33) + }) + ); + assert_eq!( + eval_tuple_with_context("3a3", &context), + Err(EvalexprError::VariableIdentifierNotFound("3a3".to_owned())) + ); + assert_eq!( + eval_tuple_with_context_mut("3,3", &mut context), + Ok(vec![Value::Int(3), Value::Int(3)]) + ); + assert_eq!( + eval_tuple_with_context_mut("33", &mut context), + Err(EvalexprError::ExpectedTuple { + actual: Value::Int(33) + }) + ); + assert_eq!( + eval_tuple_with_context_mut("3a3", &mut context), + Err(EvalexprError::VariableIdentifierNotFound("3a3".to_owned())) + ); - // assert_eq!(build_operator_tree("???").unwrap().eval_string()); + assert_eq!(eval_empty(""), Ok(EMPTY_VALUE)); + assert_eq!(eval_empty("()"), Ok(EMPTY_VALUE)); + assert_eq!( + eval_empty("(,)"), + Err(EvalexprError::ExpectedEmpty { + actual: Value::Tuple(vec![Value::Empty, Value::Empty]) + }) + ); + assert_eq!( + eval_empty("xaq"), + Err(EvalexprError::VariableIdentifierNotFound("xaq".to_owned())) + ); + assert_eq!(eval_empty_with_context("", &context), Ok(EMPTY_VALUE)); + assert_eq!(eval_empty_with_context("()", &context), Ok(EMPTY_VALUE)); + assert_eq!( + eval_empty_with_context("(,)", &context), + Err(EvalexprError::ExpectedEmpty { + actual: Value::Tuple(vec![Value::Empty, Value::Empty]) + }) + ); + assert_eq!( + eval_empty_with_context("xaq", &context), + Err(EvalexprError::VariableIdentifierNotFound("xaq".to_owned())) + ); + assert_eq!( + eval_empty_with_context_mut("", &mut context), + Ok(EMPTY_VALUE) + ); + assert_eq!( + eval_empty_with_context_mut("()", &mut context), + Ok(EMPTY_VALUE) + ); + assert_eq!( + eval_empty_with_context_mut("(,)", &mut context), + Err(EvalexprError::ExpectedEmpty { + actual: Value::Tuple(vec![Value::Empty, Value::Empty]) + }) + ); + assert_eq!( + eval_empty_with_context_mut("xaq", &mut context), + Err(EvalexprError::VariableIdentifierNotFound("xaq".to_owned())) + ); + + // With detour via build_operator_tree + + assert_eq!( + build_operator_tree("\"???\"").unwrap().eval_string(), + Ok("???".to_owned()) + ); assert_eq!( build_operator_tree("string") .unwrap() @@ -488,26 +740,6 @@ fn test_shortcut_functions() { Ok(EMPTY_VALUE) ); - assert_eq!( - eval_string_with_context_mut("string", &mut context), - Ok("a string".to_string()) - ); - assert_eq!(eval_float_with_context_mut("3.3", &mut context), Ok(3.3)); - assert_eq!(eval_int_with_context_mut("3", &mut context), Ok(3)); - assert_eq!(eval_number_with_context_mut("3", &mut context), Ok(3.0)); - assert_eq!( - eval_boolean_with_context_mut("true", &mut context), - Ok(true) - ); - assert_eq!( - eval_tuple_with_context_mut("3,3", &mut context), - Ok(vec![Value::Int(3), Value::Int(3)]) - ); - assert_eq!( - eval_empty_with_context_mut("", &mut context), - Ok(EMPTY_VALUE) - ); - assert_eq!( build_operator_tree("string") .unwrap() @@ -627,6 +859,14 @@ fn test_strings() { assert_eq!(eval("\"{}\" == \"{}\""), Ok(Value::from(true))); } +#[test] +fn test_string_escaping() { + assert_eq!( + eval("\"\\\"str\\\\ing\\\"\""), + Ok(Value::from("\"str\\ing\"")) + ); +} + #[test] fn test_tuple_definitions() { assert_eq!(eval_empty("()"), Ok(())); @@ -927,3 +1167,20 @@ fn test_error_constructors() { }) ); } + +#[test] +fn test_iterators() { + let tree = build_operator_tree("5 + 3 + fun(4) + var").unwrap(); + let mut iter = tree.iter_identifiers(); + assert_eq!(iter.next(), Some("fun")); + assert_eq!(iter.next(), Some("var")); + assert_eq!(iter.next(), None); + + let mut iter = tree.iter_variable_identifiers(); + assert_eq!(iter.next(), Some("var")); + assert_eq!(iter.next(), None); + + let mut iter = tree.iter_function_identifiers(); + assert_eq!(iter.next(), Some("fun")); + assert_eq!(iter.next(), None); +}