sdtn 0.1.4

SpaceArth DTN - A Rust-based implementation of Delay Tolerant Networking (DTN) for resilient communication
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

pub const DEFAULT_VERSION: u8 = 7;
pub const DEFAULT_LIFETIME: u64 = 3600;
pub const DEFAULT_REPORT_TO: &str = "none";
pub const BUNDLES_DIR: &str = "./bundles";
pub const DISPATCHED_DIR: &str = "./bundles/dispatched";

// Bundle subdirectories
pub const BUNDLES_BASIC_DIR: &str = "./bundles/basic";
pub const BUNDLES_ADVANCED_DIR: &str = "./bundles/advanced";
pub const BUNDLES_CUSTOM_ROUTING_DIR: &str = "./bundles/custom_routing";

pub mod ble {
    pub const SERVICE_UUID: &str = "12345678-1234-5678-1234-56789abcdef0";
    pub const WRITE_CHAR_UUID: &str = "12345678-1234-5678-1234-56789abcdef1";
    pub const NOTIFY_CHAR_UUID: &str = "12345678-1234-5678-1234-56789abcdef2";
    pub const ADV_NAME: &str = "spacearth-dtn-ble";
    pub const ACK: &[u8] = b"ACK\n";
}

pub mod tcp {
    pub const ACK: &str = "ACK";
    pub const OK: &str = "OK";
    pub const SUCCESS: &str = "SUCCESS";
    pub const RECEIVED: &str = "RECEIVED";
}

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

    #[test]
    fn test_default_constants() {
        assert_eq!(DEFAULT_VERSION, 7);
        assert_eq!(DEFAULT_LIFETIME, 3600);
        assert_eq!(DEFAULT_REPORT_TO, "none");
        assert_eq!(BUNDLES_DIR, "./bundles");
        assert_eq!(DISPATCHED_DIR, "./bundles/dispatched");
    }

    #[test]
    fn test_ble_constants() {
        assert_eq!(ble::SERVICE_UUID, "12345678-1234-5678-1234-56789abcdef0");
        assert_eq!(ble::WRITE_CHAR_UUID, "12345678-1234-5678-1234-56789abcdef1");
        assert_eq!(
            ble::NOTIFY_CHAR_UUID,
            "12345678-1234-5678-1234-56789abcdef2"
        );
        assert_eq!(ble::ADV_NAME, "spacearth-dtn-ble");
        assert_eq!(ble::ACK, b"ACK\n");
    }

    #[test]
    fn test_tcp_constants() {
        assert_eq!(tcp::ACK, "ACK");
        assert_eq!(tcp::OK, "OK");
        assert_eq!(tcp::SUCCESS, "SUCCESS");
        assert_eq!(tcp::RECEIVED, "RECEIVED");
    }

    #[test]
    fn test_ble_uuid_format() {
        let service_uuid = ble::SERVICE_UUID;

        // Check UUID format (8-4-4-4-12)
        let parts: Vec<&str> = service_uuid.split('-').collect();
        assert_eq!(parts.len(), 5);
        assert_eq!(parts[0].len(), 8);
        assert_eq!(parts[1].len(), 4);
        assert_eq!(parts[2].len(), 4);
        assert_eq!(parts[3].len(), 4);
        assert_eq!(parts[4].len(), 12);

        // Check that UUIDs are different
        assert_ne!(ble::SERVICE_UUID, ble::WRITE_CHAR_UUID);
        assert_ne!(ble::SERVICE_UUID, ble::NOTIFY_CHAR_UUID);
        assert_ne!(ble::WRITE_CHAR_UUID, ble::NOTIFY_CHAR_UUID);
    }

    #[test]
    fn test_ack_bytes() {
        let ack_bytes = ble::ACK;
        assert_eq!(ack_bytes.len(), 4);
        assert_eq!(ack_bytes[0], b'A');
        assert_eq!(ack_bytes[1], b'C');
        assert_eq!(ack_bytes[2], b'K');
        assert_eq!(ack_bytes[3], b'\n');
    }

    #[test]
    fn test_directory_paths() {
        assert!(BUNDLES_DIR.starts_with("./"));
        assert!(DISPATCHED_DIR.starts_with("./bundles/"));
        assert_ne!(BUNDLES_DIR, DISPATCHED_DIR);

        // Test bundle subdirectory paths
        assert_eq!(BUNDLES_BASIC_DIR, "./bundles/basic");
        assert_eq!(BUNDLES_ADVANCED_DIR, "./bundles/advanced");
        assert_eq!(BUNDLES_CUSTOM_ROUTING_DIR, "./bundles/custom_routing");

        // Ensure all paths are different
        assert_ne!(BUNDLES_BASIC_DIR, BUNDLES_ADVANCED_DIR);
        assert_ne!(BUNDLES_BASIC_DIR, BUNDLES_CUSTOM_ROUTING_DIR);
        assert_ne!(BUNDLES_ADVANCED_DIR, BUNDLES_CUSTOM_ROUTING_DIR);
    }

    #[test]
    fn test_tcp_string_constants_not_empty() {
        // Check they are different
        assert_ne!(tcp::ACK, tcp::OK);
        assert_ne!(tcp::ACK, tcp::SUCCESS);
        assert_ne!(tcp::ACK, tcp::RECEIVED);
    }

    #[test]
    fn test_lifetime_is_positive() {
        assert_eq!(DEFAULT_LIFETIME, 60 * 60); // 1 hour in seconds
    }
}