jstime_core 0.66.0

Another JS Runtime
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

use jstime_core as jstime;

mod common;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_settimeout() {
        let result = common::get_type_of("globalThis.setTimeout");
        assert_eq!(result.unwrap(), "function");
    }

    #[test]
    fn test_setinterval() {
        let result = common::get_type_of("globalThis.setInterval");
        assert_eq!(result.unwrap(), "function");
    }

    #[test]
    fn test_cleartimeout() {
        let result = common::get_type_of("globalThis.clearTimeout");
        assert_eq!(result.unwrap(), "function");
    }

    #[test]
    fn test_clearinterval() {
        let result = common::get_type_of("globalThis.clearInterval");
        assert_eq!(result.unwrap(), "function");
    }

    #[test]
    fn test_settimeout_execution() {
        let _setup_guard = common::setup();
        let options = jstime::Options::default();
        let mut jstime = jstime::JSTime::new(options);
        // Set up the variable
        jstime
            .run_script("globalThis.timerResult = 'initial';", "jstime")
            .unwrap();
        // Queue the timeout
        jstime
            .run_script(
                "setTimeout(() => { globalThis.timerResult = 'timeout executed'; }, 10);",
                "jstime",
            )
            .unwrap();
        // Check the result after event loop completes
        let result = jstime.run_script("globalThis.timerResult;", "jstime");
        assert_eq!(result.unwrap(), "timeout executed");
    }

    #[test]
    fn test_setinterval_with_clear() {
        let _setup_guard = common::setup();
        let options = jstime::Options::default();
        let mut jstime = jstime::JSTime::new(options);
        let script = r#"
            globalThis.count = 0;
            const id = setInterval(() => {
                globalThis.count++;
                if (globalThis.count >= 3) {
                    clearInterval(id);
                }
            }, 10);
        "#;
        jstime.run_script(script, "jstime").unwrap();
        // Check count after intervals execute
        let result = jstime.run_script("globalThis.count;", "jstime");
        assert_eq!(result.unwrap(), "3");
    }

    #[test]
    fn test_multiple_timeouts() {
        let _setup_guard = common::setup();
        let options = jstime::Options::default();
        let mut jstime = jstime::JSTime::new(options);
        let script = r#"
            globalThis.results = [];
            setTimeout(() => { globalThis.results.push(1); }, 50);
            setTimeout(() => { globalThis.results.push(2); }, 20);
            setTimeout(() => { globalThis.results.push(3); }, 10);
        "#;
        jstime.run_script(script, "jstime").unwrap();
        // Check results after timeouts execute
        let result = jstime.run_script("globalThis.results.join(',');", "jstime");
        assert_eq!(result.unwrap(), "3,2,1");
    }

    #[test]
    fn test_many_concurrent_timers() {
        let _setup_guard = common::setup();
        let options = jstime::Options::default();
        let mut jstime = jstime::JSTime::new(options);
        // Create 12 timers (more than SmallVec[8] inline capacity) to test heap spillover
        let script = r#"
            globalThis.timerCount = 0;
            for (let i = 0; i < 12; i++) {
                setTimeout(() => { globalThis.timerCount++; }, 10);
            }
        "#;
        jstime.run_script(script, "jstime").unwrap();
        // Check that all timers executed
        let result = jstime.run_script("globalThis.timerCount;", "jstime");
        assert_eq!(result.unwrap(), "12");
    }
}