exprimo 0.7.0

Exprimo is a JavaScript expression evaluator written in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

use exprimo::Evaluator;
use serde_json::Value;
use std::collections::HashMap;

#[test]
fn test_overflow_addition() {
    let evaluator = Evaluator::new(HashMap::new(), HashMap::new());
    // 1.7976931348623157e308 is approx f64::MAX
    let result = evaluator.evaluate("1.7976931348623157e308 + 1.7976931348623157e308");
    match result {
        Ok(Value::Number(n)) => {
            // Should be f64::MAX (Infinity approximation)
            assert!(n.as_f64().unwrap() > 1.0e308);
        }
        Ok(val) => panic!("Expected Number, got {:?}", val),
        Err(e) => panic!("Evaluation failed: {:?}", e),
    }
}

#[test]
fn test_divide_by_zero() {
    let evaluator = Evaluator::new(HashMap::new(), HashMap::new());
    let result = evaluator.evaluate("1 / 0");
    match result {
        Ok(Value::Number(n)) => {
            // Should be f64::MAX (Infinity approximation) or Infinity
            // Currently it might be returning 0.0 based on previous analysis, we want it to be MAX
            let val = n.as_f64().unwrap();
            assert!(val > 1.0e308 || val.is_infinite());
        }
        Ok(val) => panic!("Expected Number, got {:?}", val),
        Err(e) => panic!("Evaluation failed: {:?}", e),
    }
}

#[test]
fn test_nan_creation() {
    let evaluator = Evaluator::new(HashMap::new(), HashMap::new());
    // 0/0 triggers NaN
    let result = evaluator.evaluate("0 / 0");
    match result {
        Ok(Value::Null) => {} // This is what we WANT (null for NaN)
        Ok(Value::Number(n)) => {
            // Current behavior might be 0.0
            println!("Got number: {:?}", n);
            // Verify it is NOT 0.0 if we want to fail before fix (but let's just assert our desired behavior)
            // We want it to be Null
            panic!("Expected Null for NaN, got Number: {:?}", n);
        }
        Ok(val) => panic!("Expected Null, got {:?}", val),
        Err(e) => panic!("Evaluation failed: {:?}", e),
    }
}

#[test]
fn test_escape_sequence() {
    let evaluator = Evaluator::new(HashMap::new(), HashMap::new());
    let result = evaluator.evaluate("'\\n'");
    match result {
        Ok(Value::String(s)) => assert_eq!(s, "\n"),
        Ok(val) => panic!("Expected String, got {:?}", val),
        Err(e) => panic!("Evaluation failed: {:?}", e),
    }
}