evalx 0.5.0

use evalx::{eval, Expr, to_value, Value, Error};

#[test]
fn test_negative_number() {
    assert_eq!(eval("-5"), Ok(to_value(-5)));
}

#[test]
fn test_add() {
    assert_eq!(eval("2 + 3"), Ok(to_value(5)));
}

#[test]
fn test_brackets_add() {
    assert_eq!(eval("(2 + 3) + (3 + 5)"), Ok(to_value(13)));
}

#[test]
fn test_brackets_float_add() {
    assert_eq!(eval("(2 + 3.2) + (3 + 5)"), Ok(to_value(13.2)));
}

#[test]
fn test_brackets_float_mul() {
    assert_eq!(eval("(2 + 3.2) * 5"), Ok(to_value(26.0)));
}

#[test]
fn test_mul_with_neg_number() {
    assert_eq!(eval("5*-5"), Ok(to_value(-25)));
}

#[test]
fn test_brackets_sub() {
    assert_eq!(eval("(4 - 3) * 5"), Ok(to_value(5)));
}

#[test]
fn test_useless_brackets() {
    assert_eq!(eval("2 + 3 + (5)"), Ok(to_value(10)));
}

#[test]
fn test_error_brackets_not_with_function() {
    assert_eq!(eval("5 + ()"), Err(Error::BracketNotWithFunction));
}

#[test]
fn test_deep_brackets() {
    assert_eq!(eval("(2 + (3 + 4) + (6 + (6 + 7)) + 5)"), Ok(to_value(33)));
}

#[test]
fn test_brackets_div() {
    assert_eq!(eval("(4 / (2 + 2)) * 5"), Ok(to_value(5.0)));
}

#[test]
fn test_min() {
    assert_eq!(eval("min(30, 5, 245, 20)"), Ok(to_value(5)));
}

#[test]
fn test_min_brackets() {
    assert_eq!(
        eval("(min(30, 5, 245, 20) * 10 + (5 + 5) * 5)"),
        Ok(to_value(100))
    );
}

#[test]
fn test_min_and_mul() {
    assert_eq!(eval("min(30, 5, 245, 20) * 10"), Ok(to_value(50)));
}

#[test]
fn test_max() {
    assert_eq!(eval("max(30, 5, 245, 20)"), Ok(to_value(245)));
}

#[test]
fn test_max_brackets() {
    assert_eq!(
        eval("(max(30, 5, 245, 20) * 10 + (5 + 5) * 5)"),
        Ok(to_value(2500))
    );
}

#[test]
fn test_max_and_mul() {
    assert_eq!(eval("max(30, 5, 245, 20) * 10"), Ok(to_value(2450)));
}

#[test]
fn test_len_array() {
    assert_eq!(eval("len(array(2, 3, 4, 5, 6))"), Ok(to_value(5)));
}

#[test]
fn test_null_and_number() {
    assert_eq!(eval("hos != 0"), Ok(to_value(true)));
    assert_eq!(eval("hos > 0"), Ok(to_value(false)));
}

#[test]
fn test_len_string() {
    assert_eq!(eval("len('Hello world!')"), Ok(to_value(12)));
}

#[test]
fn test_len_object() {
    use std::collections::HashMap;
    let mut object = HashMap::new();
    object.insert("field1", "value1");
    object.insert("field2", "value2");
    object.insert("field3", "value3");
    assert_eq!(
        Expr::new("len(object)").value("object", object).exec(),
        Ok(to_value(3))
    );
}

#[test]
fn test_brackets_1() {
    assert_eq!(eval("(5) + (min(3, 4, 5)) + 20"), Ok(to_value(28)));
}

#[test]
fn test_brackets_2() {
    assert_eq!(eval("(((5) / 5))"), Ok(to_value(1.0)));
}

#[test]
fn test_string_add() {
    assert_eq!(eval(r#""Hello"+", world!""#), Ok(to_value("Hello, world!")));
}

#[test]
fn test_equal() {
    assert_eq!(eval("1 == 1"), Ok(to_value(true)));
}

#[test]
fn test_not_equal() {
    assert_eq!(eval("1 != 2"), Ok(to_value(true)));
}

#[test]
fn test_multiple_equal() {
    assert_eq!(eval("(1 == 2) == (2 == 3)"), Ok(to_value(true)));
}

#[test]
fn test_multiple_not_equal() {
    assert_eq!(eval("(1 != 2) == (2 != 3)"), Ok(to_value(true)));
}

#[test]
fn test_greater_than() {
    assert_eq!(eval("1 > 2"), Ok(to_value(false)));
    assert_eq!(eval("2 > 1"), Ok(to_value(true)));
}

#[test]
fn test_less_than() {
    assert_eq!(eval("2 < 1"), Ok(to_value(false)));
    assert_eq!(eval("1 < 2"), Ok(to_value(true)));
}

#[test]
fn test_greater_and_less() {
    assert_eq!(eval("(2 > 1) == (1 < 2)"), Ok(to_value(true)));
}

#[test]
fn test_ge() {
    assert_eq!(eval("2 >= 1"), Ok(to_value(true)));
    assert_eq!(eval("2 >= 2"), Ok(to_value(true)));
    assert_eq!(eval("2 >= 3"), Ok(to_value(false)));
}

#[test]
fn test_le() {
    assert_eq!(eval("2 <= 1"), Ok(to_value(false)));
    assert_eq!(eval("2 <= 2"), Ok(to_value(true)));
    assert_eq!(eval("2 <= 3"), Ok(to_value(true)));
}

#[test]
fn test_quotes() {
    assert_eq!(eval(r#""1><2" + "3<>4""#), Ok(to_value("1><23<>4")));
    assert_eq!(eval(r#""1==2" + "3--4""#), Ok(to_value("1==23--4")));
    assert_eq!(eval(r#""1!=2" + "3>>4""#), Ok(to_value("1!=23>>4")));
    assert_eq!(eval(r#""><1!=2" + "3>>4""#), Ok(to_value("><1!=23>>4")));
}

#[test]
fn test_single_quote() {
    assert_eq!(eval(r#"'1><2' + '3<>4'"#), Ok(to_value("1><23<>4")));
    assert_eq!(eval(r#"'1==2' + '3--4'"#), Ok(to_value("1==23--4")));
    assert_eq!(eval(r#"'1!=2' + '3>>4'"#), Ok(to_value("1!=23>>4")));
    assert_eq!(eval(r#"'!=1<>2' + '3>>4'"#), Ok(to_value("!=1<>23>>4")));
}

#[test]
fn test_single_and_double_quote() {
    assert_eq!(
        eval(r#"' """" ' + ' """" '"#),
        Ok(to_value(r#" """"  """" "#))
    );
}

#[test]
fn test_double_and_single_quote() {
    assert_eq!(
        eval(r#"" '''' " + " '''' ""#),
        Ok(to_value(r#" ''''  '''' "#))
    );
}

#[test]
fn test_array() {
    assert_eq!(eval("array(1, 2, 3, 4)"), Ok(to_value(vec![1, 2, 3, 4])));
}

#[test]
fn test_range() {
    assert_eq!(eval("0..5"), Ok(to_value(vec![0, 1, 2, 3, 4])));
}

#[test]
fn test_range_and_min() {
    assert_eq!(eval("min(0..5)"), Ok(to_value(0)));
}

#[test]
fn test_rem_1() {
    assert_eq!(eval("2 % 2"), Ok(to_value(0)));
}

#[test]
fn test_rem_2() {
    assert_eq!(eval("5 % 56 % 5"), Ok(to_value(0)));
}

#[test]
fn test_rem_3() {
    assert_eq!(eval("5.5 % 23"), Ok(to_value(5.5)));
}

#[test]
fn test_rem_4() {
    assert_eq!(eval("23 % 5.5"), Ok(to_value(1.0)));
}

#[test]
fn test_and_1() {
    assert_eq!(eval("3 > 2 && 2 > 1"), Ok(to_value(true)));
}

#[test]
fn test_and_2() {
    assert_eq!(eval("3 == 2 && 2 == 1"), Ok(to_value(false)));
}

#[test]
fn test_and_3() {
    assert_eq!(eval("3 > 2 && 2 == 1"), Ok(to_value(false)));
}

#[test]
fn test_or_1() {
    assert_eq!(eval("3 > 2 || 2 > 1"), Ok(to_value(true)));
}

#[test]
fn test_or_2() {
    assert_eq!(eval("3 < 2 || 2 < 1"), Ok(to_value(false)));
}

#[test]
fn test_or_3() {
    assert_eq!(eval("3 > 2 || 2 < 1"), Ok(to_value(true)));
}

#[test]
fn test_or_4() {
    assert_eq!(eval("3 < 2 || 2 > 1"), Ok(to_value(true)));
}

#[test]
fn test_not() {
    assert_eq!(eval("!false"), Ok(to_value(true)));
    assert_eq!(eval("!true"), Ok(to_value(false)));
    assert_eq!(eval("!(1 != 2)"), Ok(to_value(false)));
    assert_eq!(eval("!(1 == 2)"), Ok(to_value(true)));
    assert_eq!(eval("!(1 == 2) == true"), Ok(to_value(true)));
}

#[test]
fn test_not_and_brackets() {
    assert_eq!(eval("(!(1 == 2)) == true"), Ok(to_value(true)));
}

#[test]
fn test_object_access() {
    use std::collections::HashMap;
    let mut object = HashMap::new();
    object.insert("foo", "Foo, hello world!");
    object.insert("bar", "Bar, hello world!");
    assert_eq!(
        Expr::new("object.foo == 'Foo, hello world!'")
            .value("object", object)
            .exec(),
        Ok(to_value(true))
    );
}

#[test]
fn test_object_dynamic_access() {
    use std::collections::HashMap;
    let mut object = HashMap::new();
    object.insert("foo", "Foo, hello world!");
    object.insert("bar", "Bar, hello world!");
    assert_eq!(
        Expr::new("object['foo'] == 'Foo, hello world!'")
            .value("object", object)
            .exec(),
        Ok(to_value(true))
    );
}

#[test]
fn test_object_dynamic_access_2() {
    use std::collections::HashMap;
    let mut object = HashMap::new();
    object.insert("foo", "Foo, hello world!");
    object.insert("bar", "Bar, hello world!");
    assert_eq!(
        Expr::new("object[foo] == 'Foo, hello world!'")
            .value("object", object)
            .value("foo", "foo")
            .exec(),
        Ok(to_value(true))
    );
}

#[test]
fn test_path() {
    assert_eq!(Expr::new("array[2-2].foo[2-2]").exec(), Ok(Value::Null));
}

#[test]
fn test_array_access() {
    let array = vec!["hello", "world", "!"];
    assert_eq!(
        Expr::new(
            "array[1-1] == 'hello' && array[1] == 'world' && array[2] == '!'",
        )
        .value("array", array)
        .exec(),
        Ok(to_value(true))
    );
}

#[test]
fn test_builtin_is_empty() {
    assert_eq!(
        Expr::new("is_empty(array)")
            .value("array", Vec::<String>::new())
            .exec(),
        Ok(to_value(true))
    );
}

#[test]
fn test_builtin_min() {
    assert_eq!(
        Expr::new("min(array)")
            .value("array", vec![23, 34, 45, 2])
            .exec(),
        Ok(to_value(2))
    );
}

#[test]
fn test_custom_function() {
    assert_eq!(
        Expr::new("output()")
            .function(
                "output",
                |_| Ok(to_value("This is custom function's output")),
            )
            .exec(),
        Ok(to_value("This is custom function's output"))
    );
}

#[test]
fn test_error_start_with_non_value_operator() {
    assert_eq!(
        Expr::new("+ + 5").compile().map(|_| ()).unwrap_err(),
        Error::StartWithNonValueOperator
    );
}

#[test]
fn test_error_duplicate_operator() {
    assert_eq!(
        Expr::new("5 + + 5").compile().map(|_| ()).unwrap_err(),
        Error::DuplicateOperatorNode
    );
}

#[test]
fn test_error_duplicate_value() {
    assert_eq!(
        Expr::new("2 + 6 5").compile().map(|_| ()).unwrap_err(),
        Error::DuplicateValueNode
    );
}

#[test]
fn test_error_unpaired_brackets() {
    assert_eq!(
        Expr::new("(2 + 3)) * 5").compile().map(|_| ()).unwrap_err(),
        Error::UnpairedBrackets
    );
}

#[test]
fn test_error_comma() {
    assert_eq!(
        Expr::new(", 2 + 5").compile().map(|_| ()).unwrap_err(),
        Error::CommaNotWithFunction
    );
}

// Additional combined tests for unary !
#[test]
fn logical_ops_unary_combinations() {
    // Basic combinations
    assert_eq!(eval("true || !false"), Ok(to_value(true)));
    assert_eq!(eval("false && !true"), Ok(to_value(false)));
    assert_eq!(eval("!true || false"), Ok(to_value(false)));
    assert_eq!(eval("!false && true"), Ok(to_value(true)));

    // Multiple negations
    assert_eq!(eval("!!true"), Ok(to_value(true)));
    assert_eq!(eval("!!!false"), Ok(to_value(true)));
    assert_eq!(eval("!!(1==1)"), Ok(to_value(true)));

    // Parentheses and mixing
    assert_eq!(eval("(true && !false) || false"), Ok(to_value(true)));
    assert_eq!(eval("1 == 1 && !(2 == 3)"), Ok(to_value(true)));

    // Without/with spaces directly at operators
    assert_eq!(eval("true&&!!false"), Ok(to_value(false)));
    assert_eq!(eval("true&& ! false"), Ok(to_value(true)));

    // Interaction with null
    assert_eq!(eval("!null"), Ok(to_value(true)));
    assert_eq!(eval("true && !null"), Ok(to_value(true)));
    assert_eq!(eval("false || !null"), Ok(to_value(true)));
}