otterbook_core 0.1.3

A high-performance, lock-free price level implementation for limit order books in Rust. This library provides the building blocks for creating efficient trading systems with support for multiple order types and concurrent access patterns.
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

#[cfg(test)]
mod tests {
    use crate::current_time_millis;
    use std::thread;
    use std::time::{Duration, SystemTime, UNIX_EPOCH};
    use tracing::info;

    #[test]
    fn test_current_time_millis_increases() {
        let time1 = current_time_millis();
        // Sleep for a bit to ensure time passes
        thread::sleep(Duration::from_millis(5));
        let time2 = current_time_millis();

        // The second time should be greater than the first
        assert!(time2 > time1, "Time should increase between calls");
    }

    #[test]
    fn test_current_time_millis_is_reasonably_current() {
        // Get current time using both methods
        let time_from_function = current_time_millis();
        let time_direct = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .expect("Time went backwards")
            .as_millis() as u64;

        // The times should be very close to each other
        // Allow a small difference due to execution time between the two calls
        let difference = if time_direct >= time_from_function {
            time_direct - time_from_function
        } else {
            time_from_function - time_direct
        };

        // The difference should be no more than 10ms (this is generous)
        assert!(
            difference <= 10,
            "Time difference should be small, but got {}ms",
            difference
        );
    }

    #[test]
    fn test_current_time_millis_precision() {
        // Call the function twice in quick succession
        let time1 = current_time_millis();
        let time2 = current_time_millis();

        // Check if we have at least millisecond precision
        // This test might be flaky if both calls happen within the same millisecond,
        // but it's unlikely on most modern systems
        // If it fails, it doesn't necessarily indicate a problem
        if time1 == time2 {
            info!("Note: consecutive calls returned same time, which might happen occasionally");
        }

        // Ensure with a sleep that we get different values
        thread::sleep(Duration::from_millis(5));
        let time3 = current_time_millis();
        assert!(time3 > time1, "Time should increase after sleep");
    }

    #[test]
    fn test_current_time_millis_increases_bis() {
        let time1 = current_time_millis();
        // Sleep for a bit to ensure time passes
        thread::sleep(Duration::from_millis(5));
        let time2 = current_time_millis();

        // The second time should be greater than the first
        assert!(time2 > time1, "Time should increase between calls");
    }

    #[test]
    fn test_current_time_millis_is_reasonably_current_bis() {
        // Get current time using both methods
        let time_from_function = current_time_millis();
        let time_direct = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .expect("Time went backwards")
            .as_millis() as u64;

        // The times should be very close to each other
        // Allow a small difference due to execution time between the two calls
        let difference = if time_direct >= time_from_function {
            time_direct - time_from_function
        } else {
            time_from_function - time_direct
        };

        // The difference should be no more than 10ms (this is generous)
        assert!(
            difference <= 10,
            "Time difference should be small, but got {}ms",
            difference
        );
    }

    #[test]
    fn test_current_time_millis_precision_bis() {
        // Call the function twice in quick succession
        let time1 = current_time_millis();
        let time2 = current_time_millis();

        // Check if we have at least millisecond precision
        // This test might be flaky if both calls happen within the same millisecond,
        // but it's unlikely on most modern systems
        // If it fails, it doesn't necessarily indicate a problem
        if time1 == time2 {
            info!("Note: consecutive calls returned same time, which might happen occasionally");
        }

        // Ensure with a sleep that we get different values
        thread::sleep(Duration::from_millis(5));
        let time3 = current_time_millis();
        assert!(time3 > time1, "Time should increase after sleep");
    }
}