libautomotive 0.1.2

A Rust library for automotive systems and protocols
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

use super::PhysicalLayer;
use crate::error::{AutomotiveError, Result};
use crate::types::{Config, Frame};
use std::sync::Arc;
use std::sync::Mutex;

/// Mock frame handler function type
pub type MockFrameHandler = Box<dyn Fn(&Frame) -> Result<Frame> + Send + Sync>;

#[derive(Debug, Default)]
pub struct MockConfig {
    pub timeout_ms: u32,
}

impl Config for MockConfig {
    fn validate(&self) -> Result<()> {
        Ok(())
    }
}

/// Mock physical layer for testing
pub struct MockPhysical {
    config: MockConfig,
    frame_handler: Option<MockFrameHandler>,
    is_open: bool,
    last_frame: Arc<Mutex<Option<Frame>>>,
}

impl MockPhysical {
    /// Creates a new mock physical layer with a custom frame handler
    pub fn new(frame_handler: Option<MockFrameHandler>) -> Self {
        Self {
            config: MockConfig::default(),
            frame_handler,
            is_open: false,
            last_frame: Arc::new(Mutex::new(None)),
        }
    }

    /// Creates a new mock physical layer with an echo handler
    pub fn new_echo() -> Self {
        Self::new(Some(Box::new(|frame: &Frame| Ok(frame.clone()))))
    }

    /// Creates a new mock physical layer that simulates errors
    pub fn new_error() -> Self {
        Self::new(Some(Box::new(|_: &Frame| {
            Err(AutomotiveError::NotInitialized)
        })))
    }

    /// Sets a new frame handler
    pub fn set_frame_handler(&mut self, handler: Option<MockFrameHandler>) {
        self.frame_handler = handler;
    }
}

impl PhysicalLayer for MockPhysical {
    type Config = MockConfig;

    fn new(config: Self::Config) -> Result<Self> {
        Ok(Self {
            config,
            frame_handler: None,
            is_open: false,
            last_frame: Arc::new(Mutex::new(None)),
        })
    }

    fn open(&mut self) -> Result<()> {
        self.is_open = true;
        Ok(())
    }

    fn close(&mut self) -> Result<()> {
        self.is_open = false;
        Ok(())
    }

    fn send_frame(&mut self, frame: &Frame) -> Result<()> {
        if !self.is_open {
            return Err(AutomotiveError::NotInitialized);
        }

        // Store the frame for receive_frame to use
        if let Ok(mut last_frame) = self.last_frame.lock() {
            *last_frame = Some(frame.clone());
        }
        Ok(())
    }

    fn receive_frame(&mut self) -> Result<Frame> {
        if !self.is_open {
            return Err(AutomotiveError::NotInitialized);
        }

        if let Some(handler) = &self.frame_handler {
            let last_frame = self.last_frame.lock().unwrap();
            if let Some(frame) = last_frame.as_ref() {
                // Create a response frame based on the last sent frame
                let response = handler(frame)?;
                return Ok(response);
            }

            // If no frame was sent, create a default single frame response
            let default_frame = Frame {
                id: 0x7E8,
                data: vec![0x00, 0x00], // Single frame with 0 length
                timestamp: 0,
                is_extended: false,
                is_fd: false,
            };
            return handler(&default_frame);
        }
        Err(AutomotiveError::NotInitialized)
    }

    fn set_timeout(&mut self, timeout_ms: u32) -> Result<()> {
        if !self.is_open {
            return Err(AutomotiveError::NotInitialized);
        }
        self.config.timeout_ms = timeout_ms;
        Ok(())
    }
}