javascript 0.1.13

A JavaScript engine implementation 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
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

use javascript::{Value, evaluate_script};

#[test]
fn bigint_nan_infinite_and_sign_edgecases() {
    // NaN and Infinity comparisons with BigInt should be handled.
    let cases = vec![
        ("1n < NaN", false),
        ("1n > NaN", false),
        ("1n <= NaN", false),
        ("1n >= NaN", false),
        ("1n < Infinity", false),
        ("1n > Infinity", false),
        ("1n < -Infinity", false),
        ("1n > -Infinity", false),
    ];

    for (expr, expected) in cases {
        let res = evaluate_script(expr, None::<&std::path::Path>).expect("eval failed");
        match res {
            Value::Boolean(b) => assert_eq!(b, expected, "{} should be {}", expr, expected),
            other => panic!("Expected boolean for '{}', got {:?}", expr, other),
        }
    }
}

#[test]
fn bigint_relational_le_ge_and_negative_fractional() {
    // <= and >= with integer numbers should compare exactly
    let cases = vec![
        ("5n <= 5", true),
        ("5n >= 5", true),
        ("5.0 <= 5n", true),
        ("5.0 >= 5n", true),
        // negative fractional behaviour: -3n < -2.5 -> true (floor(-2.5) = -3 => -3 <= -3)
        ("-3n < -2.5", true),
        // zero edgecases
        ("0n < -0.0", false),
        ("0n >= -0.0", true),
    ];

    for (expr, expected) in cases {
        let res = evaluate_script(expr, None::<&std::path::Path>).expect("eval failed");
        match res {
            Value::Boolean(b) => assert_eq!(b, expected, "{} should be {}", expr, expected),
            other => panic!("Expected boolean for '{}', got {:?}", expr, other),
        }
    }
}

#[test]
fn bigint_relational_small_fuzz_returns_boolean() {
    // A small deterministic fuzz set — ensure all relational expressions evaluate and return Booleans.
    let bigints = vec![
        "0n",
        "1n",
        "-1n",
        "9007199254740991n",
        "9007199254740993n",
        "123456789123456789123456789n",
        "-123456789123456789123456789n",
    ];
    let numbers = vec![
        "NaN",
        "Infinity",
        "-Infinity",
        "9007199254740991",
        "9007199254740992",
        "9007199254740993",
        "5.0",
        "5.1",
        "-2.5",
        "4.9",
    ];
    let ops = vec!["<", "<=", ">", ">="];

    for bi in &bigints {
        for n in &numbers {
            for op in &ops {
                let expr = format!("{} {} {}", bi, op, n);
                let res = evaluate_script(&expr, None::<&std::path::Path>);
                match res {
                    Ok(Value::Boolean(_)) => {} // good
                    Ok(other) => panic!("Expected boolean for '{}', got {:?}", expr, other),
                    Err(e) => panic!("Evaluation error for '{}': {:?}", expr, e),
                }
            }
        }
    }
}