hamelin_eval 0.10.13

Expression evaluation for Hamelin query language
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use crate::value::Value;
use hamelin_lib::tree::builder::{boolean, double, int, null, string};

use super::test_helpers::TestContext;

#[test]
fn test_eval_int_literal() {
    let ctx = TestContext::new();

    let expr = int(42);
    let result = ctx.eval_expr(&expr);

    assert_eq!(result, Value::Int(42));
}

#[test]
fn test_eval_string_literal() {
    let ctx = TestContext::new();

    let expr = string("hello");
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::String("hello".to_string()));
}

#[test]
fn test_eval_boolean_literal() {
    let ctx = TestContext::new();

    // Test true literal
    let expr = boolean(true);
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::Boolean(true));

    // Test false literal
    let expr = boolean(false);
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::Boolean(false));
}

#[test]
fn test_eval_double_literal() {
    let ctx = TestContext::new();

    let expr = double(3.14159);
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::Double(3.14159));
}

#[test]
fn test_eval_null_literal() {
    let ctx = TestContext::new();

    let expr = null();
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::Null);
    assert!(result.is_null());
}

#[test]
fn test_eval_various_int_literals() {
    let ctx = TestContext::new();

    // Test zero
    let expr = int(0);
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::Int(0));

    // Test negative number
    let expr = int(-42);
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::Int(-42));

    // Test large positive number
    let expr = int(2147483647);
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::Int(2147483647));

    // Test large negative number
    let expr = int(-2147483648);
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::Int(-2147483648));
}

#[test]
fn test_eval_various_double_literals() {
    let ctx = TestContext::new();

    // Test zero as double
    let expr = double(0.0);
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::Double(0.0));

    // Test negative double
    let expr = double(-3.14159);
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::Double(-3.14159));

    // Test very small positive double
    let expr = double(0.000001);
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::Double(0.000001));

    // Test very large double
    let expr = double(1e10);
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::Double(1e10));
}

#[test]
fn test_eval_various_string_literals() {
    let ctx = TestContext::new();

    // Test empty string
    let expr = string("");
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::String("".to_string()));

    // Test string with spaces
    let expr = string("hello world");
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::String("hello world".to_string()));

    // Test string with special characters
    let expr = string("Hello, δΈ–η•Œ! 🌍");
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::String("Hello, δΈ–η•Œ! 🌍".to_string()));

    // Test string with escape sequences (if supported)
    let expr = string("line1\nline2\tindented");
    let result = ctx.eval_expr(&expr);
    assert_eq!(result, Value::String("line1\nline2\tindented".to_string()));
}