use crate::checksums::Checksum;
use crate::checksums::Lrc;
use crate::checksums::XorChecksum;
use crate::codec;
use crate::match_config::PatternEncoding;
use crate::util::find_subsequence;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
pub struct RxFramingConfig {
#[serde(flatten)]
pub mode: RxFramingMode,
#[serde(default)]
#[schemars(schema_with = "crate::schema_helpers::option_uint_schema")]
pub max_frames: Option<usize>,
#[serde(default)]
pub include_terminators: bool,
#[serde(default)]
pub skip_empty: bool,
}
impl Default for RxFramingConfig {
fn default() -> Self {
Self {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
max_frames: None,
include_terminators: false,
skip_empty: false,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case", tag = "type")]
pub enum RxFramingMode {
#[serde(rename_all = "snake_case")]
Line {
#[serde(default)]
ending: LineEnding,
},
#[serde(rename_all = "snake_case")]
Delimiter {
delimiter: String,
#[serde(default = "default_encoding")]
delimiter_encoding: PatternEncoding,
},
#[serde(rename_all = "snake_case")]
LengthPrefixed {
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
prefix_size: u8,
#[serde(default)]
endianness: Endianness,
#[serde(default)]
#[schemars(schema_with = "crate::schema_helpers::option_uint_schema")]
initial_offset: Option<usize>,
},
#[serde(rename_all = "snake_case")]
StartEnd {
start: Vec<String>,
end: String,
#[serde(default = "default_encoding")]
marker_encoding: PatternEncoding,
#[serde(default)]
include_markers: bool,
},
#[serde(rename_all = "snake_case")]
Slip,
#[serde(rename_all = "snake_case")]
Cobs,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Default)]
#[serde(rename_all = "snake_case")]
pub enum LineEnding {
#[default]
Auto,
Lf,
Cr,
Crlf,
}
fn default_encoding() -> PatternEncoding {
PatternEncoding::Utf8
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case", tag = "type")]
pub enum ProtocolPreset {
AtCommand,
Slip,
JsonLines,
Cobs,
Ndjson,
Nmea0183,
ModbusAscii,
}
pub fn preset_tx_framing(p: ProtocolPreset) -> TxFramingConfig {
match p {
ProtocolPreset::AtCommand => TxFramingConfig {
mode: TxFramingMode::Line {
ending: TxLineEnding::Cr,
},
},
ProtocolPreset::Slip => TxFramingConfig {
mode: TxFramingMode::Slip,
},
ProtocolPreset::JsonLines | ProtocolPreset::Ndjson => TxFramingConfig {
mode: TxFramingMode::Line {
ending: TxLineEnding::Lf,
},
},
ProtocolPreset::Cobs => TxFramingConfig {
mode: TxFramingMode::Cobs,
},
ProtocolPreset::Nmea0183 => TxFramingConfig {
mode: TxFramingMode::StartEnd {
start: vec!["$".into()],
end: "\r\n".into(),
marker_encoding: PatternEncoding::Utf8,
},
},
ProtocolPreset::ModbusAscii => TxFramingConfig {
mode: TxFramingMode::StartEnd {
start: vec![":".into()],
end: "\r\n".into(),
marker_encoding: PatternEncoding::Utf8,
},
},
}
}
pub fn preset_rx_framing(p: ProtocolPreset) -> RxFramingConfig {
let (mode, skip_empty) = match p {
ProtocolPreset::AtCommand | ProtocolPreset::JsonLines => (
RxFramingMode::Line {
ending: LineEnding::Auto,
},
false,
),
ProtocolPreset::Slip => (RxFramingMode::Slip, false),
ProtocolPreset::Cobs => (RxFramingMode::Cobs, false),
ProtocolPreset::Ndjson => (
RxFramingMode::Line {
ending: LineEnding::Auto,
},
true,
),
ProtocolPreset::Nmea0183 => (
RxFramingMode::StartEnd {
start: vec!["$".into(), "!".into()],
end: "\r\n".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
false,
),
ProtocolPreset::ModbusAscii => (
RxFramingMode::StartEnd {
start: vec![":".into()],
end: "\r\n".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
false,
),
};
RxFramingConfig {
mode,
max_frames: None,
include_terminators: false,
skip_empty,
}
}
pub fn preset_rx_parser(p: ProtocolPreset) -> ParserConfig {
let (parser_type, validate) = match p {
ProtocolPreset::AtCommand => (ParserType::AtCommand, false),
ProtocolPreset::Slip | ProtocolPreset::Cobs => (ParserType::Raw, false),
ProtocolPreset::JsonLines | ProtocolPreset::Ndjson => (ParserType::JsonLines, false),
ProtocolPreset::Nmea0183 => (ParserType::Nmea, true),
ProtocolPreset::ModbusAscii => (ParserType::ModbusAscii, true),
};
ParserConfig {
parser_type,
custom_prompt: None,
validate,
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
pub struct TxFramingConfig {
#[serde(flatten)]
pub mode: TxFramingMode,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case", tag = "type")]
pub enum TxFramingMode {
#[serde(rename_all = "snake_case")]
Line {
ending: TxLineEnding,
},
#[serde(rename_all = "snake_case")]
Delimiter {
delimiter: String,
#[serde(default = "default_encoding")]
delimiter_encoding: PatternEncoding,
},
#[serde(rename_all = "snake_case")]
LengthPrefixed {
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
prefix_size: u8,
#[serde(default)]
endianness: Endianness,
},
#[serde(rename_all = "snake_case")]
StartEnd {
start: Vec<String>,
end: String,
#[serde(default = "default_encoding")]
marker_encoding: PatternEncoding,
},
#[serde(rename_all = "snake_case")]
Slip,
#[serde(rename_all = "snake_case")]
Cobs,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum TxLineEnding {
Lf,
Cr,
Crlf,
}
impl TxFramingMode {
pub fn encode(&self, payload: &[u8]) -> Result<Vec<u8>, String> {
match self {
TxFramingMode::Line { ending } => {
let mut framed = payload.to_vec();
match ending {
TxLineEnding::Lf => framed.push(b'\n'),
TxLineEnding::Cr => framed.push(b'\r'),
TxLineEnding::Crlf => framed.extend_from_slice(b"\r\n"),
}
Ok(framed)
}
TxFramingMode::Delimiter {
delimiter,
delimiter_encoding,
} => {
let delim_bytes = codec::decode((*delimiter_encoding).into(), delimiter)
.map_err(|e| format!("Invalid TX delimiter encoding: {e}"))?;
if delim_bytes.is_empty() {
return Err("TX delimiter must not be empty".into());
}
let mut framed = payload.to_vec();
framed.extend_from_slice(&delim_bytes);
Ok(framed)
}
TxFramingMode::LengthPrefixed {
prefix_size,
endianness,
} => {
if !matches!(prefix_size, 1 | 2 | 4) {
return Err("TX prefix_size must be 1, 2, or 4".into());
}
let len = payload.len();
let mut framed = Vec::with_capacity(*prefix_size as usize + len);
match (prefix_size, endianness) {
(1, _) => {
if len > 255 {
return Err(format!(
"TX payload length {len} exceeds maximum 255 for prefix_size=1"
));
}
framed.push(len as u8);
}
(2, Endianness::Big) => {
if len > 65535 {
return Err(format!(
"TX payload length {len} exceeds maximum 65535 for prefix_size=2"
));
}
framed.extend_from_slice(&(len as u16).to_be_bytes());
}
(2, Endianness::Little) => {
if len > 65535 {
return Err(format!(
"TX payload length {len} exceeds maximum 65535 for prefix_size=2"
));
}
framed.extend_from_slice(&(len as u16).to_le_bytes());
}
(4, Endianness::Big) => {
framed.extend_from_slice(&(len as u32).to_be_bytes());
}
(4, Endianness::Little) => {
framed.extend_from_slice(&(len as u32).to_le_bytes());
}
_ => unreachable!("prefix_size validated above"),
}
framed.extend_from_slice(payload);
Ok(framed)
}
TxFramingMode::StartEnd {
start,
end,
marker_encoding,
} => {
if start.is_empty() {
return Err("TX start markers must not be empty".into());
}
let start_bytes = codec::decode((*marker_encoding).into(), &start[0])
.map_err(|e| format!("Invalid TX start marker encoding: {e}"))?;
let end_bytes = codec::decode((*marker_encoding).into(), end)
.map_err(|e| format!("Invalid TX end marker encoding: {e}"))?;
if start_bytes.is_empty() || end_bytes.is_empty() {
return Err("TX start and end markers must not be empty".into());
}
let mut framed =
Vec::with_capacity(start_bytes.len() + payload.len() + end_bytes.len());
framed.extend_from_slice(&start_bytes);
framed.extend_from_slice(payload);
framed.extend_from_slice(&end_bytes);
Ok(framed)
}
TxFramingMode::Slip => {
let mut framed = vec![SLIP_END];
framed.extend_from_slice(&slip_stuff(payload));
framed.push(SLIP_END);
Ok(framed)
}
TxFramingMode::Cobs => {
let mut framed = vec![0x00];
framed.extend_from_slice(&cobs_stuff(payload));
framed.push(0x00);
Ok(framed)
}
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema, Default)]
#[serde(rename_all = "snake_case")]
pub enum Endianness {
#[default]
Big,
Little,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)]
pub struct ParserConfig {
#[serde(rename = "type")]
pub parser_type: ParserType,
#[serde(default)]
pub custom_prompt: Option<String>,
#[serde(default)]
pub validate: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ParserType {
AtCommand,
JsonLines,
ShellPrompt,
Raw,
Nmea,
ModbusAscii,
}
#[derive(Debug, Clone, Serialize, JsonSchema)]
pub struct Frame {
#[schemars(schema_with = "crate::schema_helpers::byte_array_schema")]
pub data: Vec<u8>,
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
pub index: usize,
pub frame_type: &'static str,
#[serde(skip_serializing_if = "Option::is_none")]
pub parsed: Option<ParsedFrame>,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[serde(tag = "parser", rename_all = "snake_case")]
pub enum ParsedFrame {
AtCommand {
response_type: String,
#[serde(skip_serializing_if = "Option::is_none")]
command: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
status: Option<String>,
fields: Vec<String>,
},
Json(serde_json::Value),
ShellPrompt {
prompt: String,
prompt_type: String,
},
Raw,
Nmea {
talker_id: String,
sentence_type: String,
fields: Vec<String>,
#[serde(skip_serializing_if = "Option::is_none")]
checksum_valid: Option<bool>,
},
ModbusAscii {
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
address: u8,
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
function_code: u8,
#[schemars(schema_with = "crate::schema_helpers::byte_array_schema")]
data: Vec<u8>,
checksum_valid: Option<bool>,
},
}
pub struct FrameDecoder {
buf: Vec<u8>,
mode: DecoderMode,
frame_count: usize,
include_terminators: bool,
skip_empty: bool,
parser: Option<Box<dyn FrameParser>>,
}
enum DecoderMode {
Line(LineState),
Delimiter(Vec<u8>),
LengthPrefixed {
prefix_size: u8,
endianness: Endianness,
remaining_offset: usize,
next_payload_len: Option<usize>,
},
StartEnd {
start: Vec<Vec<u8>>,
end: Vec<u8>,
include_markers: bool,
in_frame: bool,
},
Slip {
state: SlipState,
},
Cobs {
state: CobsState,
},
}
enum LineState {
Lf,
Cr,
Crlf,
AutoLf,
PendingCr(usize),
CrMode,
}
#[derive(Debug, Clone)]
enum SlipState {
BeforeFirstEnd,
InFrame { buf: Vec<u8>, escaped: bool },
}
#[derive(Debug, Clone)]
enum CobsState {
BeforeFirstDelim,
InFrame {
decoded: Vec<u8>,
remaining: u8,
pending_zero: bool,
},
}
trait FrameParser: Send + Sync {
fn parse(&self, data: &[u8]) -> Result<ParsedFrame, FrameDecodeError>;
}
fn slip_decode(
buf_outer: &mut Vec<u8>,
frame_count: &mut usize,
parser: &Option<Box<dyn FrameParser>>,
mode: &mut DecoderMode,
skip_empty: bool,
) -> Result<Vec<Frame>, FrameDecodeError> {
let mut frames = Vec::new();
let state = match mode {
DecoderMode::Slip { ref mut state } => state,
_ => return Ok(frames),
};
loop {
match state {
SlipState::BeforeFirstEnd => {
if let Some(pos) = buf_outer.iter().position(|&b| b == SLIP_END) {
buf_outer.drain(..=pos);
*state = SlipState::InFrame {
buf: Vec::new(),
escaped: false,
};
continue;
}
buf_outer.clear();
return Ok(frames);
}
SlipState::InFrame {
ref mut buf,
ref mut escaped,
} => {
let mut read_pos: usize = 0;
while read_pos < buf_outer.len() {
let b = buf_outer[read_pos];
read_pos += 1;
if *escaped {
match b {
SLIP_ESC_END => {
buf.push(SLIP_END);
*escaped = false;
}
SLIP_ESC_ESC => {
buf.push(SLIP_ESC);
*escaped = false;
}
_ => {
buf_outer.drain(..read_pos);
buf.clear();
*escaped = false;
*state = SlipState::BeforeFirstEnd;
return Err(FrameDecodeError::SlipInvalidEscape(b));
}
}
} else {
match b {
SLIP_END => {
let data = std::mem::take(buf);
if !skip_empty || !is_blank_frame(&data) {
*frame_count += 1;
let parsed = match parser.as_ref().map(|p| p.parse(&data)) {
Some(Ok(pf)) => Some(pf),
Some(Err(e)) => {
buf_outer.drain(..read_pos);
*state = SlipState::BeforeFirstEnd;
return Err(e);
}
None => None,
};
frames.push(Frame {
data,
index: *frame_count - 1,
frame_type: "slip",
parsed,
});
}
}
SLIP_ESC => {
*escaped = true;
}
_ => {
buf.push(b);
}
}
}
}
buf_outer.drain(..read_pos);
return Ok(frames);
}
}
}
}
fn cobs_decode(
buf_outer: &mut Vec<u8>,
frame_count: &mut usize,
parser: &Option<Box<dyn FrameParser>>,
mode: &mut DecoderMode,
skip_empty: bool,
) -> Result<Vec<Frame>, FrameDecodeError> {
let mut frames = Vec::new();
let state = match mode {
DecoderMode::Cobs { ref mut state } => state,
_ => return Ok(frames),
};
loop {
match state {
CobsState::BeforeFirstDelim => {
if let Some(pos) = buf_outer.iter().position(|&b| b == 0x00) {
buf_outer.drain(..=pos);
*state = CobsState::InFrame {
decoded: Vec::new(),
remaining: 0,
pending_zero: false,
};
continue;
}
buf_outer.clear();
return Ok(frames);
}
CobsState::InFrame {
ref mut decoded,
ref mut remaining,
ref mut pending_zero,
} => {
let mut read_pos: usize = 0;
let len = buf_outer.len();
loop {
if *remaining == 0 && *pending_zero {
decoded.push(0x00);
*pending_zero = false;
}
if read_pos >= len {
break;
}
let b = buf_outer[read_pos];
read_pos += 1;
if *remaining > 0 {
decoded.push(b);
*remaining -= 1;
continue;
}
if b == 0x00 {
let mut data = std::mem::take(decoded);
if data.last() == Some(&0x00) {
data.pop();
}
if !skip_empty || !is_blank_frame(&data) {
*frame_count += 1;
let parsed = match parser.as_ref().map(|p| p.parse(&data)) {
Some(Ok(pf)) => Some(pf),
Some(Err(e)) => {
buf_outer.drain(..read_pos);
*decoded = Vec::new();
*remaining = 0;
*pending_zero = false;
*state = CobsState::BeforeFirstDelim;
return Err(e);
}
None => None,
};
frames.push(Frame {
data,
index: *frame_count - 1,
frame_type: "cobs",
parsed,
});
}
*state = CobsState::BeforeFirstDelim;
buf_outer.drain(..read_pos);
break;
}
if b == 0xFF {
*remaining = 254;
*pending_zero = false;
} else {
*remaining = b - 1;
*pending_zero = true;
}
}
if !matches!(state, CobsState::BeforeFirstDelim) {
buf_outer.drain(..read_pos);
return Ok(frames);
}
}
}
}
}
impl FrameDecoder {
pub fn new(
config: &RxFramingConfig,
parser_config: Option<&ParserConfig>,
) -> Result<Self, String> {
let mode = match &config.mode {
RxFramingMode::Line { ending } => {
let state = match ending {
LineEnding::Auto => LineState::AutoLf,
LineEnding::Lf => LineState::Lf,
LineEnding::Cr => LineState::Cr,
LineEnding::Crlf => LineState::Crlf,
};
DecoderMode::Line(state)
}
RxFramingMode::Delimiter {
delimiter,
delimiter_encoding,
} => {
let bytes = codec::decode((*delimiter_encoding).into(), delimiter)
.map_err(|e| format!("Invalid delimiter encoding: {e}"))?;
if bytes.is_empty() {
return Err("Delimiter must not be empty".into());
}
DecoderMode::Delimiter(bytes)
}
RxFramingMode::LengthPrefixed {
prefix_size,
endianness,
initial_offset,
} => {
if !matches!(prefix_size, 1 | 2 | 4) {
return Err("prefix_size must be 1, 2, or 4".into());
}
DecoderMode::LengthPrefixed {
prefix_size: *prefix_size,
endianness: *endianness,
remaining_offset: initial_offset.unwrap_or(0),
next_payload_len: None,
}
}
RxFramingMode::StartEnd {
start,
end,
marker_encoding,
include_markers,
} => {
if start.is_empty() {
return Err("Start markers must not be empty".into());
}
let mut start_bytes_vec: Vec<Vec<u8>> = Vec::with_capacity(start.len());
for s in start {
let sb = codec::decode((*marker_encoding).into(), s)
.map_err(|e| format!("Invalid start marker encoding: {e}"))?;
if sb.is_empty() {
return Err("Start and end markers must not be empty".into());
}
start_bytes_vec.push(sb);
}
let end_bytes = codec::decode((*marker_encoding).into(), end)
.map_err(|e| format!("Invalid end marker encoding: {e}"))?;
if end_bytes.is_empty() {
return Err("Start and end markers must not be empty".into());
}
DecoderMode::StartEnd {
start: start_bytes_vec,
end: end_bytes,
include_markers: *include_markers,
in_frame: false,
}
}
RxFramingMode::Slip => DecoderMode::Slip {
state: SlipState::BeforeFirstEnd,
},
RxFramingMode::Cobs => DecoderMode::Cobs {
state: CobsState::BeforeFirstDelim,
},
};
let parser: Option<Box<dyn FrameParser>> = match parser_config {
Some(pc) => Some(build_parser(pc)?),
None => None,
};
let buf = Vec::new();
Ok(Self {
buf,
mode,
frame_count: 0,
include_terminators: config.include_terminators,
skip_empty: config.skip_empty,
parser,
})
}
pub fn push(&mut self, chunk: &[u8]) -> Result<Vec<Frame>, FrameDecodeError> {
self.buf.extend_from_slice(chunk);
if matches!(self.mode, DecoderMode::Slip { .. }) {
let frames = slip_decode(
&mut self.buf,
&mut self.frame_count,
&self.parser,
&mut self.mode,
self.skip_empty,
)?;
return Ok(frames);
}
if matches!(self.mode, DecoderMode::Cobs { .. }) {
let frames = cobs_decode(
&mut self.buf,
&mut self.frame_count,
&self.parser,
&mut self.mode,
self.skip_empty,
)?;
return Ok(frames);
}
let mut frames = Vec::new();
loop {
let consumed = match &mut self.mode {
DecoderMode::Line(state) => match state {
LineState::Lf => self.match_line_lf(),
LineState::Cr => self.match_line_cr(),
LineState::Crlf => self.match_line_crlf(),
LineState::AutoLf => self.match_auto_lf(),
LineState::PendingCr(_) => self.match_pending_cr(),
LineState::CrMode => self.match_line_cr(),
},
DecoderMode::Delimiter(delim) => {
let d = delim.clone();
let pos = find_subsequence(&self.buf, &d);
pos.map(|p| {
let fb = if self.include_terminators {
self.buf[..p + d.len()].to_vec()
} else {
self.buf[..p].to_vec()
};
self.buf.drain(..p + d.len());
fb
})
}
DecoderMode::LengthPrefixed {
prefix_size,
endianness,
remaining_offset,
next_payload_len,
} => {
if *remaining_offset > 0 {
let drain = (*remaining_offset).min(self.buf.len());
self.buf.drain(..drain);
*remaining_offset -= drain;
}
if next_payload_len.is_none() {
let needed = *prefix_size as usize;
if self.buf.len() < needed {
break;
}
let len =
read_length_prefix(&self.buf[..needed], *prefix_size, *endianness);
*next_payload_len = Some(len);
}
let payload_len = match *next_payload_len {
Some(len) => len,
None => break,
};
let header_len = *prefix_size as usize;
let total_needed = header_len + payload_len;
if self.buf.len() < total_needed {
break;
}
let frame_bytes = if self.include_terminators {
self.buf[..total_needed].to_vec()
} else {
self.buf[header_len..total_needed].to_vec()
};
self.buf.drain(..total_needed);
*next_payload_len = None;
Some(frame_bytes)
}
DecoderMode::StartEnd {
start,
end,
include_markers,
in_frame,
} => {
let start = start.clone();
let end = end.clone();
let include = *include_markers;
if !*in_frame {
let mut best_pos: Option<(usize, usize)> = None; for marker in &start {
if let Some(pos) = find_subsequence(&self.buf, marker) {
match best_pos {
Some((bp, _)) if pos < bp => {
best_pos = Some((pos, marker.len()));
}
None => {
best_pos = Some((pos, marker.len()));
}
_ => {}
}
}
}
if let Some((pos, marker_len)) = best_pos {
self.buf.drain(..pos);
if !include {
self.buf.drain(..marker_len);
}
*in_frame = true;
} else {
let keep = start
.iter()
.map(|m| m.len().saturating_sub(1))
.max()
.unwrap_or(0);
if self.buf.len() > keep {
self.buf.drain(..(self.buf.len() - keep));
}
break;
}
}
if *in_frame {
if let Some(pos) = find_subsequence(&self.buf, &end) {
let frame_bytes = if include {
let fb = self.buf[..pos + end.len()].to_vec();
self.buf.drain(..pos + end.len());
fb
} else {
let fb = self.buf[..pos].to_vec();
self.buf.drain(..pos + end.len());
fb
};
*in_frame = false;
Some(frame_bytes)
} else {
break;
}
} else {
None
}
}
DecoderMode::Slip { .. } => unreachable!("SLIP handled before match"),
DecoderMode::Cobs { .. } => unreachable!("COBS handled before match"),
};
match consumed {
None => break,
Some(frame_bytes) => {
if !self.skip_empty || !is_blank_frame(&frame_bytes) {
self.frame_count += 1;
let parsed = match self.parser.as_ref().map(|p| p.parse(&frame_bytes)) {
Some(Ok(pf)) => Some(pf),
Some(Err(e)) => return Err(e),
None => None,
};
let frame_type = self.frame_type_str();
frames.push(Frame {
data: frame_bytes,
index: self.frame_count - 1,
frame_type,
parsed,
});
}
}
}
}
Ok(frames)
}
fn match_auto_lf(&mut self) -> Option<Vec<u8>> {
if let Some(lf_pos) = self.buf.iter().position(|&b| b == b'\n') {
let end = if !self.include_terminators && lf_pos > 0 && self.buf[lf_pos - 1] == b'\r' {
lf_pos - 1
} else {
lf_pos
};
let fb = if self.include_terminators {
self.buf[..lf_pos + 1].to_vec()
} else {
self.buf[..end].to_vec()
};
self.buf.drain(..lf_pos + 1);
return Some(fb);
}
if let Some(cr_pos) = self.buf.iter().position(|&b| b == b'\r') {
let next_is_lf = self.buf.get(cr_pos + 1) == Some(&b'\n');
if next_is_lf {
let fb = if self.include_terminators {
self.buf[..cr_pos + 2].to_vec()
} else {
self.buf[..cr_pos].to_vec()
};
self.buf.drain(..cr_pos + 2);
return Some(fb);
}
if cr_pos + 1 < self.buf.len() {
let fb = if self.include_terminators {
self.buf[..cr_pos + 1].to_vec()
} else {
self.buf[..cr_pos].to_vec()
};
self.buf.drain(..cr_pos + 1);
if let DecoderMode::Line(ref mut state) = self.mode {
*state = LineState::CrMode;
}
return Some(fb);
}
if let DecoderMode::Line(ref mut state) = self.mode {
*state = LineState::PendingCr(cr_pos);
}
return None;
}
None
}
fn match_pending_cr(&mut self) -> Option<Vec<u8>> {
let cr_pos = match self.mode {
DecoderMode::Line(LineState::PendingCr(pos)) => pos,
_ => {
if let DecoderMode::Line(ref mut state) = self.mode {
*state = LineState::AutoLf;
}
return None;
}
};
if cr_pos + 1 >= self.buf.len() {
return None;
}
let next_byte = self.buf[cr_pos + 1];
if next_byte == b'\n' {
let fb = if self.include_terminators {
self.buf[..cr_pos + 2].to_vec()
} else {
self.buf[..cr_pos].to_vec()
};
self.buf.drain(..cr_pos + 2);
if let DecoderMode::Line(ref mut state) = self.mode {
*state = LineState::AutoLf;
}
return Some(fb);
}
let fb = if self.include_terminators {
self.buf[..cr_pos + 1].to_vec()
} else {
self.buf[..cr_pos].to_vec()
};
self.buf.drain(..cr_pos + 1);
if let DecoderMode::Line(ref mut state) = self.mode {
*state = LineState::CrMode;
}
Some(fb)
}
fn match_line_lf(&mut self) -> Option<Vec<u8>> {
let pos = self.buf.iter().position(|&b| b == b'\n')?;
let fb = if self.include_terminators {
self.buf[..pos + 1].to_vec()
} else {
self.buf[..pos].to_vec()
};
self.buf.drain(..pos + 1);
Some(fb)
}
fn match_line_cr(&mut self) -> Option<Vec<u8>> {
let pos = self.buf.iter().position(|&b| b == b'\r')?;
let fb = if self.include_terminators {
self.buf[..pos + 1].to_vec()
} else {
self.buf[..pos].to_vec()
};
self.buf.drain(..pos + 1);
Some(fb)
}
fn match_line_crlf(&mut self) -> Option<Vec<u8>> {
let pos = find_subsequence(&self.buf, b"\r\n")?;
let fb = if self.include_terminators {
self.buf[..pos + 2].to_vec()
} else {
self.buf[..pos].to_vec()
};
self.buf.drain(..pos + 2);
Some(fb)
}
fn frame_type_str(&self) -> &'static str {
match &self.mode {
DecoderMode::Line(_) => "line",
DecoderMode::Delimiter(_) => "delimiter",
DecoderMode::LengthPrefixed { .. } => "length_prefixed",
DecoderMode::StartEnd { .. } => "start_end",
DecoderMode::Slip { .. } => "slip",
DecoderMode::Cobs { .. } => "cobs",
}
}
pub fn pending_len(&self) -> usize {
self.buf.len()
}
pub fn flush_partial(&mut self) -> Option<Frame> {
if let DecoderMode::Slip {
state: SlipState::InFrame { ref mut buf, .. },
} = self.mode
{
if buf.is_empty() {
return None;
}
let data = std::mem::take(buf);
self.frame_count += 1;
return Some(Frame {
data,
index: self.frame_count - 1,
frame_type: "slip",
parsed: None,
});
}
if let DecoderMode::Cobs {
state: CobsState::InFrame {
ref mut decoded, ..
},
} = self.mode
{
if decoded.is_empty() {
return None;
}
let data = std::mem::take(decoded);
self.frame_count += 1;
return Some(Frame {
data,
index: self.frame_count - 1,
frame_type: "cobs",
parsed: None,
});
}
if self.buf.is_empty() {
return None;
}
let data = std::mem::take(&mut self.buf);
self.frame_count += 1;
Some(Frame {
data,
index: self.frame_count - 1,
frame_type: self.frame_type_str(),
parsed: None,
})
}
}
fn build_parser(config: &ParserConfig) -> Result<Box<dyn FrameParser>, String> {
match config.parser_type {
ParserType::AtCommand => Ok(Box::new(AtCommandParser)),
ParserType::JsonLines => Ok(Box::new(JsonLinesParser)),
ParserType::ShellPrompt => {
let custom = config
.custom_prompt
.as_deref()
.map(|s| {
regex::bytes::Regex::new(s).map_err(|e| format!("Invalid prompt regex: {e}"))
})
.transpose()?;
Ok(Box::new(ShellPromptParser { custom }))
}
ParserType::Raw => Ok(Box::new(RawParser)),
ParserType::Nmea => Ok(Box::new(NmeaParser {
validate: config.validate,
})),
ParserType::ModbusAscii => Ok(Box::new(ModbusAsciiParser {
validate: config.validate,
})),
}
}
struct AtCommandParser;
impl FrameParser for AtCommandParser {
fn parse(&self, data: &[u8]) -> Result<ParsedFrame, FrameDecodeError> {
let text = String::from_utf8_lossy(data);
let trimmed = text.trim();
if trimmed.is_empty() {
return Ok(ParsedFrame::Raw);
}
if let Some(cmd) = trimmed.strip_prefix('+') {
if let Some(colon) = cmd.find(':') {
let cmd_name = cmd[..colon].to_string();
let fields: Vec<String> = cmd[colon + 1..]
.split(',')
.map(|s| s.trim().to_string())
.collect();
return Ok(ParsedFrame::AtCommand {
response_type: "response".into(),
command: Some(cmd_name),
status: None,
fields,
});
}
}
if trimmed == "OK" {
return Ok(ParsedFrame::AtCommand {
response_type: "status".into(),
command: None,
status: Some("OK".into()),
fields: vec![],
});
}
if trimmed == "ERROR" {
return Ok(ParsedFrame::AtCommand {
response_type: "error".into(),
command: None,
status: Some("ERROR".into()),
fields: vec![],
});
}
if trimmed.starts_with("+CME ERROR") || trimmed.starts_with("+CMS ERROR") {
return Ok(ParsedFrame::AtCommand {
response_type: "error".into(),
command: None,
status: Some(trimmed.to_string()),
fields: vec![],
});
}
Ok(ParsedFrame::AtCommand {
response_type: "data".into(),
command: None,
status: None,
fields: vec![trimmed.to_string()],
})
}
}
struct JsonLinesParser;
impl FrameParser for JsonLinesParser {
fn parse(&self, data: &[u8]) -> Result<ParsedFrame, FrameDecodeError> {
match serde_json::from_slice::<serde_json::Value>(data) {
Ok(val) if val.is_object() => Ok(ParsedFrame::Json(val)),
_ => Ok(ParsedFrame::Raw),
}
}
}
struct ShellPromptParser {
custom: Option<regex::bytes::Regex>,
}
impl FrameParser for ShellPromptParser {
fn parse(&self, data: &[u8]) -> Result<ParsedFrame, FrameDecodeError> {
let text = String::from_utf8_lossy(data);
let trimmed = text.trim_end();
if trimmed.is_empty() {
return Ok(ParsedFrame::Raw);
}
if let Some(ref re) = self.custom {
if re.is_match(data) {
return Ok(ParsedFrame::ShellPrompt {
prompt: trimmed.to_string(),
prompt_type: "custom".into(),
});
}
}
if trimmed.ends_with("$ ") || trimmed.ends_with("$") {
return Ok(ParsedFrame::ShellPrompt {
prompt: trimmed.to_string(),
prompt_type: "user".into(),
});
}
if trimmed.ends_with("# ") || trimmed.ends_with("#") {
return Ok(ParsedFrame::ShellPrompt {
prompt: trimmed.to_string(),
prompt_type: "root".into(),
});
}
if trimmed.ends_with("> ") || trimmed.ends_with(">") {
return Ok(ParsedFrame::ShellPrompt {
prompt: trimmed.to_string(),
prompt_type: "generic".into(),
});
}
if let Some(at_pos) = trimmed.rfind('@') {
if let Some(colon_pos) = trimmed[at_pos..].find(':') {
let _user = &trimmed[..at_pos];
let _host = &trimmed[at_pos + 1..at_pos + colon_pos];
let suffix = &trimmed[at_pos + colon_pos + 1..];
if suffix == "$ " || suffix == "$" || suffix == "# " || suffix == "#" {
return Ok(ParsedFrame::ShellPrompt {
prompt: trimmed.to_string(),
prompt_type: if suffix.starts_with('#') {
"root".to_string()
} else {
"user".to_string()
},
});
}
}
}
Ok(ParsedFrame::Raw)
}
}
struct RawParser;
impl FrameParser for RawParser {
fn parse(&self, _data: &[u8]) -> Result<ParsedFrame, FrameDecodeError> {
Ok(ParsedFrame::Raw)
}
}
fn strip_trailing_newline(content: &mut Vec<u8>) {
if content.ends_with(b"\r\n") {
content.truncate(content.len() - 2);
} else if content.ends_with(b"\n") {
content.truncate(content.len() - 1);
}
}
fn strip_leading_if_any(content: &mut Vec<u8>, markers: &[u8]) {
if let Some(&first) = content.first() {
if markers.contains(&first) {
content.remove(0);
}
}
}
struct NmeaParser {
validate: bool,
}
impl FrameParser for NmeaParser {
fn parse(&self, data: &[u8]) -> Result<ParsedFrame, FrameDecodeError> {
let mut content = data.to_vec();
strip_leading_if_any(&mut content, b"$!");
strip_trailing_newline(&mut content);
if !content.contains(&b',') {
return Ok(ParsedFrame::Raw);
}
let (body, checksum_hex) = if let Some(star_pos) = content.iter().position(|&b| b == b'*') {
let body = &content[..star_pos];
let checksum_hex = &content[star_pos + 1..];
(body.to_vec(), Some(checksum_hex.to_vec()))
} else {
(content, None)
};
let checksum_valid = match &checksum_hex {
Some(hex) if hex.len() >= 2 => {
let received_val = match std::str::from_utf8(&hex[..2])
.ok()
.and_then(|s| u8::from_str_radix(s, 16).ok())
{
Some(v) => v,
None => {
if self.validate {
let computed = XorChecksum.compute(&body);
return Err(FrameDecodeError::ChecksumMismatch {
expected: computed,
received: hex.clone(),
});
}
return Ok(ParsedFrame::Nmea {
talker_id: String::new(),
sentence_type: String::new(),
fields: vec![],
checksum_valid: Some(false),
});
}
};
let computed = XorChecksum.compute(&body);
let computed_val = computed[0];
if self.validate {
if computed_val != received_val {
return Err(FrameDecodeError::ChecksumMismatch {
expected: computed,
received: vec![received_val],
});
}
Some(true)
} else {
Some(computed_val == received_val)
}
}
Some(hex) => {
if self.validate {
let computed = XorChecksum.compute(&body);
return Err(FrameDecodeError::ChecksumMismatch {
expected: computed,
received: hex.clone(),
});
}
Some(false)
}
None => None,
};
let body_str = match std::str::from_utf8(&body) {
Ok(s) => s,
Err(_) => return Ok(ParsedFrame::Raw),
};
let (address_part, fields_part) = match body_str.find(',') {
Some(comma_pos) => (
body_str[..comma_pos].to_string(),
body_str[comma_pos + 1..].to_string(),
),
None => (body_str.to_string(), String::new()),
};
let (talker_id, sentence_type) = if address_part.len() >= 5 {
let tid = address_part[..2].to_string();
let stype = address_part[2..].to_string();
(tid, stype)
} else if address_part.len() >= 2 {
let tid = address_part[..2].to_string();
let stype = address_part[2..].to_string();
(tid, stype)
} else {
(address_part, String::new())
};
let fields: Vec<String> = if fields_part.is_empty() {
vec![]
} else {
fields_part.split(',').map(|s| s.to_string()).collect()
};
Ok(ParsedFrame::Nmea {
talker_id,
sentence_type,
fields,
checksum_valid,
})
}
}
struct ModbusAsciiParser {
validate: bool,
}
impl FrameParser for ModbusAsciiParser {
fn parse(&self, data: &[u8]) -> Result<ParsedFrame, FrameDecodeError> {
let mut content = data.to_vec();
strip_leading_if_any(&mut content, b":");
strip_trailing_newline(&mut content);
let body_str = match std::str::from_utf8(&content) {
Ok(s) => s,
Err(_) => return Ok(ParsedFrame::Raw),
};
if body_str.is_empty() || body_str.bytes().any(|b| !b.is_ascii_hexdigit()) {
return Ok(ParsedFrame::Raw);
}
if body_str.len() % 2 != 0 {
return Ok(ParsedFrame::Raw);
}
let decoded: Vec<u8> = (0..body_str.len())
.step_by(2)
.map(|i| u8::from_str_radix(&body_str[i..i + 2], 16).unwrap_or(0))
.collect();
if decoded.len() < 3 {
return Ok(ParsedFrame::Raw);
}
let lrc_received = decoded[decoded.len() - 1];
let pdu = &decoded[..decoded.len() - 1]; let address = pdu[0];
let function_code = pdu[1];
let data = pdu[2..].to_vec();
let computed = Lrc.compute(pdu);
let computed_val = computed[0];
let checksum_valid = if self.validate {
if computed_val != lrc_received {
return Err(FrameDecodeError::ChecksumMismatch {
expected: computed,
received: vec![lrc_received],
});
}
Some(true)
} else {
Some(computed_val == lrc_received)
};
Ok(ParsedFrame::ModbusAscii {
address,
function_code,
data,
checksum_valid,
})
}
}
#[derive(Debug, Clone)]
pub enum FrameDecodeError {
SlipInvalidEscape(u8),
CobsInvalidCode(u8),
ChecksumMismatch {
expected: Vec<u8>,
received: Vec<u8>,
},
}
impl std::fmt::Display for FrameDecodeError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
FrameDecodeError::SlipInvalidEscape(b) => {
write!(f, "SLIP framing error: invalid escape byte 0x{b:02X}")
}
FrameDecodeError::CobsInvalidCode(b) => {
write!(f, "COBS framing error: invalid code byte 0x{b:02X}")
}
FrameDecodeError::ChecksumMismatch { expected, received } => {
let exp = expected
.iter()
.map(|b| format!("{b:02X}"))
.collect::<Vec<_>>()
.join("");
let rcv = received
.iter()
.map(|b| format!("{b:02X}"))
.collect::<Vec<_>>()
.join("");
write!(f, "checksum mismatch: expected {exp}, received {rcv}")
}
}
}
}
impl std::error::Error for FrameDecodeError {}
fn is_blank_frame(data: &[u8]) -> bool {
data.iter().all(|&b| b.is_ascii_whitespace())
}
const SLIP_END: u8 = 0xC0;
const SLIP_ESC: u8 = 0xDB;
const SLIP_ESC_END: u8 = 0xDC;
const SLIP_ESC_ESC: u8 = 0xDD;
fn slip_stuff(payload: &[u8]) -> Vec<u8> {
let mut out = Vec::with_capacity(payload.len() + payload.len() / 10);
for &b in payload {
match b {
SLIP_END => {
out.push(SLIP_ESC);
out.push(SLIP_ESC_END);
}
SLIP_ESC => {
out.push(SLIP_ESC);
out.push(SLIP_ESC_ESC);
}
_ => out.push(b),
}
}
out
}
fn cobs_stuff(payload: &[u8]) -> Vec<u8> {
let mut out: Vec<u8> = Vec::with_capacity(payload.len() + payload.len() / 254 + 2);
let mut code_index: usize = 0;
out.push(0x00); let mut code: u8 = 1;
for &b in payload {
if b == 0x00 {
out[code_index] = code;
code = 1;
code_index = out.len();
out.push(0x00); } else {
out.push(b);
code = code.saturating_add(1);
if code == 0xFF {
out[code_index] = 0xFF;
code = 1;
code_index = out.len();
out.push(0x00); }
}
}
out[code_index] = code;
out
}
fn read_length_prefix(bytes: &[u8], prefix_size: u8, endianness: Endianness) -> usize {
match prefix_size {
1 => bytes[0] as usize,
2 => {
let arr: [u8; 2] = bytes[..2].try_into().unwrap_or([0; 2]);
match endianness {
Endianness::Big => u16::from_be_bytes(arr) as usize,
Endianness::Little => u16::from_le_bytes(arr) as usize,
}
}
4 => {
let arr: [u8; 4] = bytes[..4].try_into().unwrap_or([0; 4]);
match endianness {
Endianness::Big => u32::from_be_bytes(arr) as usize,
Endianness::Little => u32::from_le_bytes(arr) as usize,
}
}
_ => {
0
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn line_decoder_single_line() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"hello\n").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hello");
assert_eq!(frames[0].index, 0);
assert_eq!(frames[0].frame_type, "line");
}
#[test]
fn line_decoder_crlf() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"hello\r\nworld\n").unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(frames[0].data, b"hello");
assert_eq!(frames[1].data, b"world");
}
#[test]
fn line_decoder_partial_across_chunks() {
let config = RxFramingConfig::default();
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"hel").unwrap();
assert!(frames.is_empty());
let frames = dec.push(b"lo\nwor").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hello");
let frames = dec.push(b"ld\n").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"world");
}
#[test]
fn line_decoder_empty_lines() {
let config = RxFramingConfig::default();
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"\n\n\n").unwrap();
assert_eq!(frames.len(), 3);
for f in &frames {
assert!(f.data.is_empty());
}
}
#[test]
fn line_decoder_include_terminators() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
include_terminators: true,
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"hello\r\n").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hello\r\n");
}
#[test]
fn line_decoder_lf_preserves_cr() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Lf,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"hello\r\n").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hello\r");
assert_eq!(frames[0].frame_type, "line");
}
#[test]
fn line_decoder_cr_splits_on_bare_cr() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Cr,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"a\rb\r").unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(frames[0].data, b"a");
assert_eq!(frames[1].data, b"b");
}
#[test]
fn line_decoder_cr_with_include_terminators() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Cr,
},
include_terminators: true,
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"a\r").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"a\r");
}
#[test]
fn line_decoder_crlf_exact_only() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Crlf,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"a\r").unwrap();
assert!(frames.is_empty());
let frames = dec.push(b"\nb").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"a");
}
#[test]
fn line_decoder_crlf_no_split_on_bare_cr() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Crlf,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"a\rb\n").unwrap();
assert_eq!(frames.len(), 0, "bare \\r should not split in crlf mode");
}
#[test]
fn line_decoder_crlf_include_terminators() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Crlf,
},
include_terminators: true,
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"hello\r\n").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hello\r\n");
}
#[test]
fn line_ending_default_is_auto() {
let val = serde_json::json!({"type": "line"});
let mode: RxFramingMode = serde_json::from_value(val).unwrap();
assert!(matches!(
mode,
RxFramingMode::Line {
ending: LineEnding::Auto
}
));
}
fn auto_config() -> RxFramingConfig {
RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
..Default::default()
}
}
fn auto_config_include_terms() -> RxFramingConfig {
RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
include_terminators: true,
..Default::default()
}
}
#[test]
fn auto_does_not_promote_on_crlf() {
let mut dec = FrameDecoder::new(&auto_config(), None).unwrap();
let frames = dec.push(b"a\r\nb\r\n").unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(frames[0].data, b"a");
assert_eq!(frames[1].data, b"b");
let frames = dec.push(b"c\r").unwrap();
assert!(frames.is_empty(), "pending CR after CRLF");
let frames = dec.push(b"d").unwrap();
assert_eq!(frames.len(), 1, "bare CR confirmed on next non-\\n byte");
assert_eq!(frames[0].data, b"c");
let frames = dec.push(b"e\r").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"de");
}
#[test]
fn auto_does_not_promote_on_lf() {
let mut dec = FrameDecoder::new(&auto_config(), None).unwrap();
let frames = dec.push(b"a\nb\n").unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(frames[0].data, b"a");
assert_eq!(frames[1].data, b"b");
}
#[test]
fn auto_promotes_on_next_non_lf_byte() {
let mut dec = FrameDecoder::new(&auto_config(), None).unwrap();
let frames = dec.push(b"line1\r").unwrap();
assert!(frames.is_empty());
let frames = dec.push(b"x").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"line1");
let frames = dec.push(b"more\r").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"xmore");
}
#[test]
fn auto_crlf_after_pending_cr_cancels_promotion() {
let mut dec = FrameDecoder::new(&auto_config(), None).unwrap();
let frames = dec.push(b"a\r").unwrap();
assert!(frames.is_empty());
let frames = dec.push(b"\nb").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"a");
let frames = dec.push(b"c\n").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"bc");
}
#[test]
fn auto_flush_partial_emits_pending_cr() {
let mut dec = FrameDecoder::new(&auto_config(), None).unwrap();
let frames = dec.push(b"tail\r").unwrap();
assert!(frames.is_empty());
let partial = dec.flush_partial().expect("partial frame");
assert_eq!(partial.data, b"tail\r");
assert_eq!(partial.frame_type, "line");
}
#[test]
fn auto_flush_partial_emits_pending_cr_include_terminators() {
let mut dec = FrameDecoder::new(&auto_config_include_terms(), None).unwrap();
let frames = dec.push(b"tail\r").unwrap();
assert!(frames.is_empty());
let partial = dec.flush_partial().expect("partial frame");
assert_eq!(partial.data, b"tail\r");
}
#[test]
fn auto_promotes_and_stays_in_cr_mode() {
let mut dec = FrameDecoder::new(&auto_config(), None).unwrap();
dec.push(b"a\r").unwrap();
dec.push(b"b").unwrap();
let frames = dec.push(b"x\ny\r").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"bx\ny");
}
#[test]
fn auto_promotion_include_terminators() {
let mut dec = FrameDecoder::new(&auto_config_include_terms(), None).unwrap();
let frames = dec.push(b"line1\r").unwrap();
assert!(frames.is_empty());
let frames = dec.push(b"x").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"line1\r");
}
#[test]
fn auto_pending_cr_then_flush_keeps_frame_index_monotonic() {
let mut dec = FrameDecoder::new(&auto_config(), None).unwrap();
let frames = dec.push(b"a\nb\n").unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(frames[0].index, 0);
assert_eq!(frames[1].index, 1);
dec.push(b"c\r").unwrap();
let partial = dec.flush_partial().expect("partial frame");
assert_eq!(partial.index, 2);
}
#[test]
fn preset_tx_framing_returns_line_cr() {
let cfg = preset_tx_framing(ProtocolPreset::AtCommand);
assert!(matches!(
cfg.mode,
TxFramingMode::Line {
ending: TxLineEnding::Cr
}
));
}
#[test]
fn preset_rx_framing_returns_line_auto() {
let cfg = preset_rx_framing(ProtocolPreset::AtCommand);
assert!(matches!(
cfg.mode,
RxFramingMode::Line {
ending: LineEnding::Auto
}
));
}
#[test]
fn preset_rx_parser_returns_at_command() {
let cfg = preset_rx_parser(ProtocolPreset::AtCommand);
assert_eq!(cfg.parser_type, ParserType::AtCommand);
}
fn assert_preset_roundtrip(variant_str: &str, expected: ProtocolPreset) {
let val = serde_json::json!({ "type": variant_str });
let p: ProtocolPreset = serde_json::from_value(val.clone()).unwrap();
assert_eq!(p, expected);
assert_eq!(serde_json::to_value(p).unwrap(), val);
assert!(
serde_json::from_value::<ProtocolPreset>(serde_json::json!(variant_str)).is_err(),
"bare string form {variant_str:?} must be rejected (tagged-object shape required)"
);
}
#[test]
fn protocol_preset_tagged_object_roundtrip() {
assert_preset_roundtrip("at_command", ProtocolPreset::AtCommand);
}
#[test]
fn preset_tx_framing_slip_returns_slip_mode() {
let cfg = preset_tx_framing(ProtocolPreset::Slip);
assert!(matches!(cfg.mode, TxFramingMode::Slip));
}
#[test]
fn preset_tx_framing_json_lines_returns_line_lf() {
let cfg = preset_tx_framing(ProtocolPreset::JsonLines);
assert!(matches!(
cfg.mode,
TxFramingMode::Line {
ending: TxLineEnding::Lf
}
));
}
#[test]
fn preset_rx_framing_slip_returns_slip_mode() {
let cfg = preset_rx_framing(ProtocolPreset::Slip);
assert!(matches!(cfg.mode, RxFramingMode::Slip));
}
#[test]
fn preset_rx_framing_json_lines_returns_line_auto() {
let cfg = preset_rx_framing(ProtocolPreset::JsonLines);
assert!(matches!(
cfg.mode,
RxFramingMode::Line {
ending: LineEnding::Auto
}
));
}
#[test]
fn preset_rx_parser_slip_returns_raw() {
let cfg = preset_rx_parser(ProtocolPreset::Slip);
assert_eq!(cfg.parser_type, ParserType::Raw);
}
#[test]
fn preset_rx_parser_json_lines_returns_json_lines() {
let cfg = preset_rx_parser(ProtocolPreset::JsonLines);
assert_eq!(cfg.parser_type, ParserType::JsonLines);
}
#[test]
fn protocol_preset_slip_tagged_object_roundtrip() {
assert_preset_roundtrip("slip", ProtocolPreset::Slip);
}
#[test]
fn protocol_preset_json_lines_tagged_object_roundtrip() {
assert_preset_roundtrip("json_lines", ProtocolPreset::JsonLines);
}
#[test]
fn slip_preset_equivalent_to_bare_slip_framing() {
let preset_tx = preset_tx_framing(ProtocolPreset::Slip);
let bare_tx = TxFramingConfig {
mode: TxFramingMode::Slip,
};
assert_eq!(preset_tx, bare_tx);
let preset_rx = preset_rx_framing(ProtocolPreset::Slip);
let bare_rx = RxFramingConfig {
mode: RxFramingMode::Slip,
max_frames: None,
include_terminators: false,
skip_empty: false,
};
assert_eq!(preset_rx, bare_rx);
}
#[test]
fn slip_stuff_replaces_end_and_esc() {
let payload = &[SLIP_END, SLIP_ESC, 0x41];
let stuffed = slip_stuff(payload);
assert_eq!(
stuffed,
&[SLIP_ESC, SLIP_ESC_END, SLIP_ESC, SLIP_ESC_ESC, 0x41]
);
}
#[test]
fn tx_slip_encodes_end_end() {
let mode = TxFramingMode::Slip;
let framed = mode.encode(b"hi").unwrap();
assert_eq!(framed, &[SLIP_END, b'h', b'i', SLIP_END]);
}
#[test]
fn tx_slip_stuffs_payload_with_end() {
let mode = TxFramingMode::Slip;
let framed = mode.encode(&[SLIP_END]).unwrap();
assert_eq!(framed, &[SLIP_END, SLIP_ESC, SLIP_ESC_END, SLIP_END]);
}
#[test]
fn tx_slip_stuffs_payload_with_esc() {
let mode = TxFramingMode::Slip;
let framed = mode.encode(&[SLIP_ESC]).unwrap();
assert_eq!(framed, &[SLIP_END, SLIP_ESC, SLIP_ESC_ESC, SLIP_END]);
}
fn slip_rx_config() -> RxFramingConfig {
RxFramingConfig {
mode: RxFramingMode::Slip,
..Default::default()
}
}
#[test]
fn rx_slip_skips_to_first_end() {
let mut dec = FrameDecoder::new(&slip_rx_config(), None).unwrap();
let frames = dec.push(b"junk\xC0hi\xC0").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hi");
}
#[test]
fn rx_slip_decodes_basic_frame() {
let mut dec = FrameDecoder::new(&slip_rx_config(), None).unwrap();
let frames = dec.push(b"\xC0hello\xC0").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hello");
}
#[test]
fn rx_slip_decodes_esc_end() {
let mut dec = FrameDecoder::new(&slip_rx_config(), None).unwrap();
let frames = dec.push(b"\xC0\xDB\xDC\xC0").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"\xC0");
}
#[test]
fn rx_slip_decodes_esc_esc() {
let mut dec = FrameDecoder::new(&slip_rx_config(), None).unwrap();
let frames = dec.push(b"\xC0\xDB\xDD\xC0").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"\xDB");
}
#[test]
fn rx_slip_malformed_escape_returns_err() {
let mut dec = FrameDecoder::new(&slip_rx_config(), None).unwrap();
let result = dec.push(b"\xC0\xDB\x41\xC0");
match result {
Ok(_) => panic!("expected decode error"),
Err(FrameDecodeError::SlipInvalidEscape(b)) => assert_eq!(b, 0x41),
Err(_) => panic!("unexpected error variant"),
}
}
#[test]
fn rx_slip_resyncs_after_malformed_escape() {
let mut dec = FrameDecoder::new(&slip_rx_config(), None).unwrap();
let result = dec.push(b"\xC0\xDB\x41\xC0");
assert!(result.is_err());
let frames = dec.push(b"\xC0ok\xC0").unwrap();
assert_eq!(frames.len(), 2);
assert!(frames[0].data.is_empty());
assert_eq!(frames[1].data, b"ok");
}
#[test]
fn rx_slip_resync_clears_stale_in_progress_buf() {
let mut dec = FrameDecoder::new(&slip_rx_config(), None).unwrap();
let result = dec.push(b"\xC0hello\xDB\x41");
assert!(result.is_err());
let frames = dec.push(b"\xC0world\xC0").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"world");
}
#[test]
fn rx_slip_two_frames_in_one_chunk() {
let mut dec = FrameDecoder::new(&slip_rx_config(), None).unwrap();
let frames = dec.push(b"\xC0aa\xC0bb\xC0").unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(frames[0].data, b"aa");
assert_eq!(frames[1].data, b"bb");
}
#[test]
fn rx_slip_cross_chunk_frame() {
let mut dec = FrameDecoder::new(&slip_rx_config(), None).unwrap();
let frames = dec.push(b"\xC0hel").unwrap();
assert!(frames.is_empty());
let frames = dec.push(b"lo\xC0").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hello");
}
#[test]
fn rx_slip_truncated_escape_holds_pending() {
let mut dec = FrameDecoder::new(&slip_rx_config(), None).unwrap();
let frames = dec.push(b"\xC0\xDB").unwrap();
assert!(frames.is_empty());
let frames = dec.push(b"\xDC\xC0").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"\xC0");
}
#[test]
fn rx_slip_flush_partial_emits_pending() {
let mut dec = FrameDecoder::new(&slip_rx_config(), None).unwrap();
let frames = dec.push(b"\xC0hel").unwrap();
assert!(frames.is_empty());
let partial = dec.flush_partial().expect("partial frame");
assert_eq!(partial.data, b"hel");
assert_eq!(partial.frame_type, "slip");
}
#[test]
fn roundtrip_slip_arbitrary_binary() {
let payload: &[u8] = &[SLIP_END, SLIP_ESC, 0x41, SLIP_ESC, SLIP_ESC_END, SLIP_END];
let mode = TxFramingMode::Slip;
let framed = mode.encode(payload).unwrap();
let mut dec = FrameDecoder::new(&slip_rx_config(), None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn roundtrip_slip_empty_payload() {
let mode = TxFramingMode::Slip;
let framed = mode.encode(b"").unwrap();
assert_eq!(framed, &[SLIP_END, SLIP_END]);
let mut dec = FrameDecoder::new(&slip_rx_config(), None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert!(frames[0].data.is_empty());
}
#[test]
fn rx_slip_decodes_large_payload_preserves_bytes() {
let payload: Vec<u8> = (0..4096).map(|i| (i % 256) as u8).collect();
let stuffed = slip_stuff(&payload);
let mut framed = vec![SLIP_END];
framed.extend_from_slice(&stuffed);
framed.push(SLIP_END);
let mut dec = FrameDecoder::new(&slip_rx_config(), None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1, "expected exactly one frame");
assert_eq!(
frames[0].data, payload,
"decoded payload must match original"
);
assert_eq!(frames[0].frame_type, "slip");
}
#[test]
fn slip_parser_error_propagates_and_resets_state() {
use crate::checksums::XorChecksum;
let bad_body = b"GPGLL,3751.65,N,12226.54,W*00"; let good_body = b"GPGLL,3751.65,N,12226.54,W";
let good_cs = XorChecksum.compute(good_body)[0];
let good_sentence = format!("GPGLL,3751.65,N,12226.54,W*{good_cs:02X}");
let framing = RxFramingConfig {
mode: RxFramingMode::Slip,
..Default::default()
};
let parser = ParserConfig {
parser_type: ParserType::Nmea,
custom_prompt: None,
validate: true,
};
let mut dec = FrameDecoder::new(&framing, Some(&parser)).unwrap();
let mut push1 = vec![SLIP_END];
push1.extend_from_slice(bad_body);
push1.push(SLIP_END);
let result = dec.push(&push1);
assert!(
result.is_err(),
"SLIP+parser must propagate the ChecksumMismatch"
);
let err = result.unwrap_err();
assert!(
matches!(err, FrameDecodeError::ChecksumMismatch { .. }),
"expected ChecksumMismatch, got {err:?}"
);
let mut push2 = vec![SLIP_END];
push2.extend_from_slice(good_sentence.as_bytes());
push2.push(SLIP_END);
let frames = dec.push(&push2).unwrap();
assert_eq!(
frames.len(),
1,
"decoder must recover after the parser error"
);
assert!(
matches!(
&frames[0].parsed,
Some(ParsedFrame::Nmea {
checksum_valid: Some(true),
..
})
),
"expected a clean Nmea frame after recovery, got {:?}",
frames[0].parsed
);
}
#[test]
fn delimiter_decoder_basic() {
let config = RxFramingConfig {
mode: RxFramingMode::Delimiter {
delimiter: "|".into(),
delimiter_encoding: PatternEncoding::Utf8,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"a|b|c|").unwrap();
assert_eq!(frames.len(), 3);
assert_eq!(frames[0].data, b"a");
assert_eq!(frames[1].data, b"b");
assert_eq!(frames[2].data, b"c");
}
#[test]
fn delimiter_decoder_multi_byte() {
let config = RxFramingConfig {
mode: RxFramingMode::Delimiter {
delimiter: "AA".into(),
delimiter_encoding: PatternEncoding::Utf8,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"xAAyAAz").unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(frames[0].data, b"x");
assert_eq!(frames[1].data, b"y");
}
#[test]
fn delimiter_decoder_partial_delimiter() {
let config = RxFramingConfig {
mode: RxFramingMode::Delimiter {
delimiter: "AB".into(),
delimiter_encoding: PatternEncoding::Utf8,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"xA").unwrap();
assert!(frames.is_empty());
let frames = dec.push(b"By").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"x");
}
#[test]
fn length_prefixed_basic() {
let config = RxFramingConfig {
mode: RxFramingMode::LengthPrefixed {
prefix_size: 1,
endianness: Endianness::Big,
initial_offset: None,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"\x05hello\x02wo\x02rb").unwrap();
assert_eq!(frames.len(), 3);
assert_eq!(frames[0].data, b"hello");
assert_eq!(frames[1].data, b"wo");
assert_eq!(frames[2].data, b"rb");
}
#[test]
fn length_prefixed_u16_big_endian() {
let config = RxFramingConfig {
mode: RxFramingMode::LengthPrefixed {
prefix_size: 2,
endianness: Endianness::Big,
initial_offset: None,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let mut buf = vec![0x00, 0x05];
buf.extend_from_slice(b"hello");
let frames = dec.push(&buf).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hello");
}
#[test]
fn start_end_basic() {
let config = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec!["STX".into()],
end: "ETX".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"noiseSTXdataETXjunkSTXmoreETX").unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(frames[0].data, b"data");
assert_eq!(frames[1].data, b"more");
}
#[test]
fn start_end_include_markers() {
let config = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec!["<".into()],
end: ">".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: true,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"<data>").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"<data>");
}
#[test]
fn at_parser_ok() {
let p = AtCommandParser;
let result = p.parse(b"OK").unwrap();
assert!(matches!(
result,
ParsedFrame::AtCommand {
response_type,
status: Some(s),
..
} if response_type == "status" && s == "OK"
));
}
#[test]
fn at_parser_error() {
let p = AtCommandParser;
let result = p.parse(b"ERROR").unwrap();
assert!(matches!(
result,
ParsedFrame::AtCommand {
response_type,
status: Some(s),
..
} if response_type == "error" && s == "ERROR"
));
}
#[test]
fn at_parser_command_response() {
let p = AtCommandParser;
let result = p.parse(b"+CGREG: 0,1").unwrap();
assert!(matches!(
result,
ParsedFrame::AtCommand {
response_type,
command: Some(ref c),
..
} if response_type == "response" && c == "CGREG"
));
}
#[test]
fn json_parser_valid() {
let p = JsonLinesParser;
let result = p.parse(b"{\"key\":\"value\"}").unwrap();
assert!(matches!(result, ParsedFrame::Json(_)));
}
#[test]
fn json_parser_invalid() {
let p = JsonLinesParser;
let result = p.parse(b"not json").unwrap();
assert!(matches!(result, ParsedFrame::Raw));
}
#[test]
fn json_parser_non_object_is_raw() {
let p = JsonLinesParser;
assert!(matches!(p.parse(b"[1,2,3]").unwrap(), ParsedFrame::Raw));
assert!(matches!(p.parse(b"42").unwrap(), ParsedFrame::Raw));
assert!(matches!(p.parse(b"\"hi\"").unwrap(), ParsedFrame::Raw));
assert!(matches!(
p.parse(b"{\"k\":1}").unwrap(),
ParsedFrame::Json(_)
));
}
#[test]
fn shell_prompt_user() {
let p = ShellPromptParser { custom: None };
let result = p.parse(b"$ ").unwrap();
assert!(
matches!(result, ParsedFrame::ShellPrompt { prompt_type, .. } if prompt_type == "user")
);
}
#[test]
fn shell_prompt_root() {
let p = ShellPromptParser { custom: None };
let result = p.parse(b"# ").unwrap();
assert!(
matches!(result, ParsedFrame::ShellPrompt { prompt_type, .. } if prompt_type == "root")
);
}
#[test]
fn shell_prompt_host() {
let p = ShellPromptParser { custom: None };
let result = p.parse(b"root@host:~# ").unwrap();
assert!(
matches!(result, ParsedFrame::ShellPrompt { prompt_type, .. } if prompt_type == "root")
);
}
#[test]
fn combined_line_at_parser() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
..Default::default()
};
let parser = ParserConfig {
parser_type: ParserType::AtCommand,
custom_prompt: None,
validate: false,
};
let mut dec = FrameDecoder::new(&config, Some(&parser)).unwrap();
let frames = dec.push(b"OK\nERROR\n+CGREG: 0,1\n").unwrap();
assert_eq!(frames.len(), 3);
assert!(
matches!(frames[0].parsed, Some(ParsedFrame::AtCommand { ref status, .. }) if status.as_deref() == Some("OK"))
);
assert!(
matches!(frames[1].parsed, Some(ParsedFrame::AtCommand { ref status, .. }) if status.as_deref() == Some("ERROR"))
);
assert!(
matches!(frames[2].parsed, Some(ParsedFrame::AtCommand { ref command, .. }) if command.as_deref() == Some("CGREG"))
);
}
#[test]
fn line_decoder_no_terminator_then_flush() {
let config = RxFramingConfig::default();
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"hello").unwrap();
assert!(frames.is_empty());
assert_eq!(dec.pending_len(), 5);
let partial = dec.flush_partial().expect("partial frame");
assert_eq!(partial.data, b"hello");
assert_eq!(partial.index, 0);
assert_eq!(partial.frame_type, "line");
assert!(partial.parsed.is_none());
}
#[test]
fn delimiter_decoder_empty_rejected() {
let config = RxFramingConfig {
mode: RxFramingMode::Delimiter {
delimiter: "".into(),
delimiter_encoding: PatternEncoding::Utf8,
},
..Default::default()
};
match FrameDecoder::new(&config, None) {
Ok(_) => panic!("empty delimiter should be rejected"),
Err(err) => assert!(err.contains("Delimiter must not be empty"), "got: {err}"),
}
}
#[test]
fn length_prefixed_zero_payload() {
let config = RxFramingConfig {
mode: RxFramingMode::LengthPrefixed {
prefix_size: 1,
endianness: Endianness::Big,
initial_offset: None,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"\x00\x05hello").unwrap();
assert_eq!(frames.len(), 2);
assert!(frames[0].data.is_empty());
assert_eq!(frames[1].data, b"hello");
}
#[test]
fn length_prefixed_incomplete_payload() {
let config = RxFramingConfig {
mode: RxFramingMode::LengthPrefixed {
prefix_size: 1,
endianness: Endianness::Big,
initial_offset: None,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"\x0aABC").unwrap();
assert!(frames.is_empty());
assert!(dec.pending_len() >= 3);
}
#[test]
fn length_prefixed_invalid_prefix_size() {
let config = RxFramingConfig {
mode: RxFramingMode::LengthPrefixed {
prefix_size: 3,
endianness: Endianness::Big,
initial_offset: None,
},
..Default::default()
};
match FrameDecoder::new(&config, None) {
Ok(_) => panic!("prefix_size=3 should be rejected"),
Err(err) => assert!(err.contains("prefix_size must be 1, 2, or 4"), "got: {err}"),
}
}
#[test]
fn length_prefixed_u32_big_endian() {
let config = RxFramingConfig {
mode: RxFramingMode::LengthPrefixed {
prefix_size: 4,
endianness: Endianness::Big,
initial_offset: None,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let mut buf = vec![0x00, 0x00, 0x00, 0x05];
buf.extend_from_slice(b"hello");
let frames = dec.push(&buf).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hello");
}
#[test]
fn length_prefixed_u32_little_endian() {
let config = RxFramingConfig {
mode: RxFramingMode::LengthPrefixed {
prefix_size: 4,
endianness: Endianness::Little,
initial_offset: None,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let mut buf = vec![0x05, 0x00, 0x00, 0x00];
buf.extend_from_slice(b"hello");
let frames = dec.push(&buf).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hello");
}
#[test]
fn start_end_no_start_marker() {
let config = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec!["STX".into()],
end: "ETX".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"noise_without_markers").unwrap();
assert!(frames.is_empty());
assert!(dec.pending_len() <= 2);
}
#[test]
fn start_end_start_no_end_then_flush() {
let config = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec!["<".into()],
end: ">".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"<data_without_end").unwrap();
assert!(frames.is_empty(), "no end marker yet");
let partial = dec.flush_partial().expect("partial frame after flush");
assert_eq!(partial.data, b"data_without_end");
}
#[test]
fn start_end_empty_markers_rejected() {
let config = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec!["".into()],
end: "X".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
..Default::default()
};
match FrameDecoder::new(&config, None) {
Ok(_) => panic!("empty markers should be rejected"),
Err(err) => assert!(
err.contains("Start and end markers must not be empty"),
"got: {err}"
),
}
}
#[test]
fn start_end_start_split_across_chunks() {
let config = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec!["ABC".into()],
end: "X".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"AB").unwrap();
assert!(frames.is_empty());
let frames = dec.push(b"CdX").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"d");
}
#[test]
fn delimiter_invalid_encoding_rejected() {
let config = RxFramingConfig {
mode: RxFramingMode::Delimiter {
delimiter: "!!!".into(),
delimiter_encoding: crate::match_config::PatternEncoding::Base64,
},
..Default::default()
};
match FrameDecoder::new(&config, None) {
Ok(_) => panic!("expected error for invalid delimiter encoding"),
Err(err) => assert!(err.contains("Invalid delimiter encoding"), "got: {err}"),
}
}
#[test]
fn start_end_invalid_encoding_rejected() {
let config = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec!["!!!".into()],
end: "X".into(),
marker_encoding: crate::match_config::PatternEncoding::Base64,
include_markers: false,
},
..Default::default()
};
match FrameDecoder::new(&config, None) {
Ok(_) => panic!("expected error for invalid marker encoding"),
Err(err) => assert!(err.contains("Invalid start marker encoding"), "got: {err}"),
}
}
#[test]
fn at_parser_empty_input() {
let p = AtCommandParser;
let result = p.parse(b"").unwrap();
assert!(matches!(result, ParsedFrame::Raw));
}
#[test]
fn at_parser_cme_error() {
let p = AtCommandParser;
let result = p.parse(b"+CME ERROR: 100").unwrap();
assert!(matches!(
result,
ParsedFrame::AtCommand {
response_type,
command: Some(ref c),
..
} if response_type == "response" && c == "CME ERROR"
));
}
#[test]
fn at_parser_cms_error() {
let p = AtCommandParser;
let result = p.parse(b"+CMS ERROR: 500").unwrap();
assert!(matches!(
result,
ParsedFrame::AtCommand {
response_type,
command: Some(ref c),
..
} if response_type == "response" && c == "CMS ERROR"
));
}
#[test]
fn json_parser_empty_input() {
let p = JsonLinesParser;
let result = p.parse(b"").unwrap();
assert!(matches!(result, ParsedFrame::Raw));
}
#[test]
fn shell_prompt_empty_input() {
let p = ShellPromptParser { custom: None };
let result = p.parse(b"").unwrap();
assert!(matches!(result, ParsedFrame::Raw));
}
#[test]
fn shell_prompt_custom_regex_invalid() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
..Default::default()
};
let parser = ParserConfig {
parser_type: ParserType::ShellPrompt,
custom_prompt: Some("[invalid".to_string()),
validate: false,
};
match FrameDecoder::new(&config, Some(&parser)) {
Ok(_) => panic!("invalid regex should be rejected"),
Err(err) => assert!(err.contains("Invalid prompt regex"), "got: {err}"),
}
}
#[test]
fn shell_prompt_custom_regex_match() {
let p = ShellPromptParser {
custom: Some(regex::bytes::Regex::new("^>>> $").unwrap()),
};
let result = p.parse(b">>> ").unwrap();
assert!(
matches!(result, ParsedFrame::ShellPrompt { prompt_type, .. } if prompt_type == "custom")
);
}
#[test]
fn raw_parser_passthrough() {
let p = RawParser;
let result = p.parse(b"anything").unwrap();
assert!(matches!(result, ParsedFrame::Raw));
}
#[test]
fn max_frames_zero_edge() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
max_frames: Some(0),
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"hello\n").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hello");
}
#[test]
fn length_prefixed_initial_offset() {
let config = RxFramingConfig {
mode: RxFramingMode::LengthPrefixed {
prefix_size: 1,
endianness: Endianness::Big,
initial_offset: Some(4),
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"XXXX\x05hello").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hello");
}
#[test]
fn delimiter_include_terminators() {
let config = RxFramingConfig {
mode: RxFramingMode::Delimiter {
delimiter: "|".into(),
delimiter_encoding: PatternEncoding::Utf8,
},
include_terminators: true,
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"a|b|").unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(frames[0].data, b"a|");
assert_eq!(frames[1].data, b"b|");
}
#[test]
fn flush_partial_empty_buffer() {
let config = RxFramingConfig::default();
let mut dec = FrameDecoder::new(&config, None).unwrap();
assert!(dec.flush_partial().is_none(), "empty buf => no frame");
}
#[test]
fn combined_line_json_parser() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
..Default::default()
};
let parser = ParserConfig {
parser_type: ParserType::JsonLines,
custom_prompt: None,
validate: false,
};
let mut dec = FrameDecoder::new(&config, Some(&parser)).unwrap();
let frames = dec.push(b"{\"a\":1}\n{\"b\":2}\n").unwrap();
assert_eq!(frames.len(), 2);
assert!(matches!(frames[0].parsed, Some(ParsedFrame::Json(_))));
assert!(matches!(frames[1].parsed, Some(ParsedFrame::Json(_))));
}
#[test]
fn delimiter_decoder_empty_segments() {
let config = RxFramingConfig {
mode: RxFramingMode::Delimiter {
delimiter: "|".into(),
delimiter_encoding: PatternEncoding::Utf8,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"||").unwrap();
assert_eq!(frames.len(), 2);
assert!(frames[0].data.is_empty());
assert!(frames[1].data.is_empty());
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"a||b|").unwrap();
assert_eq!(frames.len(), 3);
assert_eq!(frames[0].data, b"a");
assert!(frames[1].data.is_empty());
assert_eq!(frames[2].data, b"b");
}
#[test]
fn length_prefixed_prefix_split_across_chunks() {
let config = RxFramingConfig {
mode: RxFramingMode::LengthPrefixed {
prefix_size: 2,
endianness: Endianness::Big,
initial_offset: None,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"\x00").unwrap();
assert!(frames.is_empty());
let frames = dec.push(b"\x05hello").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hello");
}
#[test]
fn start_end_end_marker_split_across_chunks() {
let config = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec!["STX".into()],
end: "ETX".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"STXdataET").unwrap();
assert!(frames.is_empty(), "end marker ETX not yet complete");
let frames = dec.push(b"X").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"data");
}
#[test]
fn tx_line_lf() {
let mode = TxFramingMode::Line {
ending: TxLineEnding::Lf,
};
let framed = mode.encode(b"AT+CGMI").unwrap();
assert_eq!(framed, b"AT+CGMI\n");
}
#[test]
fn tx_line_cr() {
let mode = TxFramingMode::Line {
ending: TxLineEnding::Cr,
};
let framed = mode.encode(b"AT+CGMI").unwrap();
assert_eq!(framed, b"AT+CGMI\r");
}
#[test]
fn tx_line_crlf() {
let mode = TxFramingMode::Line {
ending: TxLineEnding::Crlf,
};
let framed = mode.encode(b"AT+CGMI").unwrap();
assert_eq!(framed, b"AT+CGMI\r\n");
}
#[test]
fn tx_delimiter_utf8() {
let mode = TxFramingMode::Delimiter {
delimiter: "|".into(),
delimiter_encoding: PatternEncoding::Utf8,
};
let framed = mode.encode(b"data").unwrap();
assert_eq!(framed, b"data|");
}
#[test]
fn tx_delimiter_empty_rejected() {
let mode = TxFramingMode::Delimiter {
delimiter: "".into(),
delimiter_encoding: PatternEncoding::Utf8,
};
match mode.encode(b"data") {
Ok(_) => panic!("empty TX delimiter should be rejected"),
Err(err) => assert!(err.contains("TX delimiter must not be empty"), "got: {err}"),
}
}
#[test]
fn tx_length_prefixed_u8() {
let mode = TxFramingMode::LengthPrefixed {
prefix_size: 1,
endianness: Endianness::Big,
};
let framed = mode.encode(b"hello").unwrap();
assert_eq!(framed, b"\x05hello");
}
#[test]
fn tx_length_prefixed_u16_big() {
let mode = TxFramingMode::LengthPrefixed {
prefix_size: 2,
endianness: Endianness::Big,
};
let framed = mode.encode(b"hello").unwrap();
assert_eq!(&framed[..2], &[0x00, 0x05]);
assert_eq!(&framed[2..], b"hello");
}
#[test]
fn tx_length_prefixed_u16_little() {
let mode = TxFramingMode::LengthPrefixed {
prefix_size: 2,
endianness: Endianness::Little,
};
let framed = mode.encode(b"hello").unwrap();
assert_eq!(&framed[..2], &[0x05, 0x00]);
assert_eq!(&framed[2..], b"hello");
}
#[test]
fn tx_length_prefixed_u32() {
let mode = TxFramingMode::LengthPrefixed {
prefix_size: 4,
endianness: Endianness::Big,
};
let framed = mode.encode(b"hello").unwrap();
assert_eq!(&framed[..4], &[0x00, 0x00, 0x00, 0x05]);
assert_eq!(&framed[4..], b"hello");
}
#[test]
fn tx_length_prefixed_invalid_prefix_size() {
let mode = TxFramingMode::LengthPrefixed {
prefix_size: 3,
endianness: Endianness::Big,
};
match mode.encode(b"data") {
Ok(_) => panic!("prefix_size=3 should be rejected"),
Err(err) => assert!(
err.contains("TX prefix_size must be 1, 2, or 4"),
"got: {err}"
),
}
}
#[test]
fn tx_length_prefixed_u8_overflow() {
let mode = TxFramingMode::LengthPrefixed {
prefix_size: 1,
endianness: Endianness::Big,
};
let payload = vec![0u8; 300];
match mode.encode(&payload) {
Ok(_) => panic!("payload too large for prefix_size=1 should be rejected"),
Err(err) => assert!(err.contains("exceeds maximum 255"), "got: {err}"),
}
}
#[test]
fn tx_length_prefixed_u16_overflow() {
let mode = TxFramingMode::LengthPrefixed {
prefix_size: 2,
endianness: Endianness::Big,
};
let payload = vec![0u8; 65536];
match mode.encode(&payload) {
Ok(_) => panic!("payload too large for prefix_size=2 should be rejected"),
Err(err) => assert!(err.contains("exceeds maximum 65535"), "got: {err}"),
}
}
#[test]
fn tx_start_end() {
let mode = TxFramingMode::StartEnd {
start: vec!["<".into()],
end: ">".into(),
marker_encoding: PatternEncoding::Utf8,
};
let framed = mode.encode(b"data").unwrap();
assert_eq!(framed, b"<data>");
}
#[test]
fn tx_start_end_empty_markers_rejected() {
let mode = TxFramingMode::StartEnd {
start: vec!["".into()],
end: ">".into(),
marker_encoding: PatternEncoding::Utf8,
};
match mode.encode(b"data") {
Ok(_) => panic!("empty markers should be rejected"),
Err(err) => assert!(
err.contains("TX start and end markers must not be empty"),
"got: {err}"
),
}
}
#[test]
fn roundtrip_line_lf() {
let tx = TxFramingMode::Line {
ending: TxLineEnding::Lf,
};
let rx_config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Lf,
},
..Default::default()
};
let payload = b"hello world";
let framed = tx.encode(payload).unwrap();
let mut dec = FrameDecoder::new(&rx_config, None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn roundtrip_line_cr() {
let tx = TxFramingMode::Line {
ending: TxLineEnding::Cr,
};
let rx_config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Cr,
},
..Default::default()
};
let payload = b"hello world";
let framed = tx.encode(payload).unwrap();
let mut dec = FrameDecoder::new(&rx_config, None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn roundtrip_line_crlf() {
let tx = TxFramingMode::Line {
ending: TxLineEnding::Crlf,
};
let rx_config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Crlf,
},
..Default::default()
};
let payload = b"hello world";
let framed = tx.encode(payload).unwrap();
let mut dec = FrameDecoder::new(&rx_config, None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn roundtrip_delimiter() {
let tx = TxFramingMode::Delimiter {
delimiter: "|".into(),
delimiter_encoding: PatternEncoding::Utf8,
};
let rx_config = RxFramingConfig {
mode: RxFramingMode::Delimiter {
delimiter: "|".into(),
delimiter_encoding: PatternEncoding::Utf8,
},
..Default::default()
};
let payload = b"data";
let framed = tx.encode(payload).unwrap();
let mut dec = FrameDecoder::new(&rx_config, None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn roundtrip_length_prefixed_u8() {
let tx = TxFramingMode::LengthPrefixed {
prefix_size: 1,
endianness: Endianness::Big,
};
let rx_config = RxFramingConfig {
mode: RxFramingMode::LengthPrefixed {
prefix_size: 1,
endianness: Endianness::Big,
initial_offset: None,
},
..Default::default()
};
let payload = b"binary data";
let framed = tx.encode(payload).unwrap();
let mut dec = FrameDecoder::new(&rx_config, None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn roundtrip_length_prefixed_u16_be() {
let tx = TxFramingMode::LengthPrefixed {
prefix_size: 2,
endianness: Endianness::Big,
};
let rx_config = RxFramingConfig {
mode: RxFramingMode::LengthPrefixed {
prefix_size: 2,
endianness: Endianness::Big,
initial_offset: None,
},
..Default::default()
};
let payload = b"binary data";
let framed = tx.encode(payload).unwrap();
let mut dec = FrameDecoder::new(&rx_config, None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn roundtrip_start_end() {
let tx = TxFramingMode::StartEnd {
start: vec!["STX".into()],
end: "ETX".into(),
marker_encoding: PatternEncoding::Utf8,
};
let rx_config = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec!["STX".into()],
end: "ETX".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
..Default::default()
};
let payload = b"data";
let framed = tx.encode(payload).unwrap();
let mut dec = FrameDecoder::new(&rx_config, None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn tx_framing_line_crlf_deserialize() {
let json = serde_json::json!({
"type": "line",
"ending": "crlf"
});
let cfg: TxFramingConfig = serde_json::from_value(json).unwrap();
assert!(matches!(
cfg.mode,
TxFramingMode::Line {
ending: TxLineEnding::Crlf
}
));
}
#[test]
fn tx_framing_delimiter_deserialize() {
let json = serde_json::json!({
"type": "delimiter",
"delimiter": "|",
"delimiter_encoding": "utf8"
});
let cfg: TxFramingConfig = serde_json::from_value(json).unwrap();
assert!(matches!(cfg.mode, TxFramingMode::Delimiter { .. }));
}
fn cobs_rx_config() -> RxFramingConfig {
RxFramingConfig {
mode: RxFramingMode::Cobs,
..Default::default()
}
}
#[test]
fn cobs_stuff_preserves_payload_without_delimiter() {
let stuffed = cobs_stuff(&[0x00, 0x41, 0x00]);
assert!(
!stuffed.contains(&0x00),
"encoded block must not contain delimiter"
);
}
#[test]
fn tx_cobs_encodes_block_then_delimiter() {
let mode = TxFramingMode::Cobs;
let framed = mode.encode(b"hi").unwrap();
assert_eq!(framed.first(), Some(&0x00));
assert_eq!(framed.last(), Some(&0x00));
let body = &framed[1..framed.len() - 1];
assert!(!body.contains(&0x00), "body must not contain delimiter");
assert!(
!body.is_empty(),
"body must not be empty for non-empty payload"
);
}
#[test]
fn tx_cobs_stuffs_payload_with_delimiter_byte() {
let mode = TxFramingMode::Cobs;
let framed = mode.encode(&[0x00]).unwrap();
assert_eq!(framed, &[0x00, 0x01, 0x01, 0x00]);
}
#[test]
fn rx_cobs_skips_to_first_delimiter() {
let mut dec = FrameDecoder::new(&cobs_rx_config(), None).unwrap();
let mode = TxFramingMode::Cobs;
let good_frame = mode.encode(b"hi").unwrap();
let mut input = b"junk".to_vec();
input.extend_from_slice(&good_frame);
let frames = dec.push(&input).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hi");
}
#[test]
fn rx_cobs_decodes_basic_frame() {
let mut dec = FrameDecoder::new(&cobs_rx_config(), None).unwrap();
let mode = TxFramingMode::Cobs;
let framed = mode.encode(b"hello").unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hello");
}
#[test]
fn rx_cobs_decodes_delimiter_byte_in_payload() {
let mut dec = FrameDecoder::new(&cobs_rx_config(), None).unwrap();
let mode = TxFramingMode::Cobs;
let framed = mode.encode(&[0x41, 0x00, 0x42]).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, &[0x41, 0x00, 0x42]);
}
#[test]
fn roundtrip_cobs_arbitrary_binary() {
let payload: &[u8] = &[0x00, 0xFF, 0x41, 0x00, 0x00, 0xFF, 0x7E];
let mode = TxFramingMode::Cobs;
let framed = mode.encode(payload).unwrap();
let mut dec = FrameDecoder::new(&cobs_rx_config(), None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn roundtrip_cobs_empty_payload() {
let mode = TxFramingMode::Cobs;
let framed = mode.encode(b"").unwrap();
assert_eq!(framed, &[0x00, 0x01, 0x00]);
let mut dec = FrameDecoder::new(&cobs_rx_config(), None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert!(frames[0].data.is_empty());
}
#[test]
fn roundtrip_cobs_max_overhead() {
let payload = vec![0x00u8; 254];
let mode = TxFramingMode::Cobs;
let framed = mode.encode(&payload).unwrap();
let mut dec = FrameDecoder::new(&cobs_rx_config(), None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn roundtrip_cobs_long_zero_run_300() {
let payload = vec![0u8; 300];
let mode = TxFramingMode::Cobs;
let framed = mode.encode(&payload).unwrap();
let mut dec = FrameDecoder::new(&cobs_rx_config(), None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn rx_cobs_consecutive_delimiters_emit_empty_frame() {
let mut dec = FrameDecoder::new(&cobs_rx_config(), None).unwrap();
let frames = dec.push(b"\x00\x00").unwrap();
assert_eq!(
frames.len(),
1,
"2 consecutive delimiters yield 1 empty frame"
);
assert!(frames[0].data.is_empty());
}
#[test]
fn rx_cobs_handles_between_frame_delimiters() {
let mut dec = FrameDecoder::new(&cobs_rx_config(), None).unwrap();
let frames = dec.push(b"\x00\x00").unwrap();
assert_eq!(frames.len(), 1);
assert!(frames[0].data.is_empty());
let mode = TxFramingMode::Cobs;
let framed = mode.encode(b"ok").unwrap();
let frames = dec.push(&framed).unwrap();
assert!(!frames.is_empty());
assert_eq!(frames.last().unwrap().data, b"ok");
}
#[test]
fn cobs_parser_error_propagates_and_resets_state() {
use crate::checksums::XorChecksum;
let bad_body = b"GPGLL,3751.65,N,12226.54,W*00"; let good_body = b"GPGLL,3751.65,N,12226.54,W";
let good_cs = XorChecksum.compute(good_body)[0];
let good_sentence = format!("GPGLL,3751.65,N,12226.54,W*{good_cs:02X}");
let bad_framed = TxFramingMode::Cobs.encode(bad_body).unwrap();
let good_framed = TxFramingMode::Cobs
.encode(good_sentence.as_bytes())
.unwrap();
let framing = RxFramingConfig {
mode: RxFramingMode::Cobs,
..Default::default()
};
let parser = ParserConfig {
parser_type: ParserType::Nmea,
custom_prompt: None,
validate: true,
};
let mut dec = FrameDecoder::new(&framing, Some(&parser)).unwrap();
let result = dec.push(&bad_framed);
assert!(
result.is_err(),
"COBS+parser must propagate ChecksumMismatch"
);
assert!(
matches!(
result.unwrap_err(),
FrameDecodeError::ChecksumMismatch { .. }
),
"expected ChecksumMismatch"
);
let frames = dec.push(&good_framed).unwrap();
assert_eq!(
frames.len(),
1,
"decoder must recover after the parser error"
);
assert!(
matches!(
&frames[0].parsed,
Some(ParsedFrame::Nmea {
checksum_valid: Some(true),
..
})
),
"expected a clean Nmea frame after recovery, got {:?}",
frames[0].parsed
);
}
#[test]
fn preset_tx_framing_cobs_returns_cobs() {
let cfg = preset_tx_framing(ProtocolPreset::Cobs);
assert!(matches!(cfg.mode, TxFramingMode::Cobs));
}
#[test]
fn preset_rx_framing_cobs_returns_cobs() {
let cfg = preset_rx_framing(ProtocolPreset::Cobs);
assert!(matches!(cfg.mode, RxFramingMode::Cobs));
}
#[test]
fn preset_rx_parser_cobs_returns_raw() {
let cfg = preset_rx_parser(ProtocolPreset::Cobs);
assert_eq!(cfg.parser_type, ParserType::Raw);
}
#[test]
fn protocol_preset_cobs_tagged_object_roundtrip() {
assert_preset_roundtrip("cobs", ProtocolPreset::Cobs);
}
#[test]
fn cobs_preset_equivalent_to_bare_cobs_framing() {
let preset_tx = preset_tx_framing(ProtocolPreset::Cobs);
let bare_tx = TxFramingConfig {
mode: TxFramingMode::Cobs,
};
assert_eq!(preset_tx, bare_tx);
let preset_rx = preset_rx_framing(ProtocolPreset::Cobs);
let bare_rx = RxFramingConfig {
mode: RxFramingMode::Cobs,
max_frames: None,
include_terminators: false,
skip_empty: false,
};
assert_eq!(preset_rx, bare_rx);
}
#[test]
fn roundtrip_cobs_255_ones() {
let payload = vec![1u8; 255];
let mode = TxFramingMode::Cobs;
let framed = mode.encode(&payload).unwrap();
let mut dec = FrameDecoder::new(&cobs_rx_config(), None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn roundtrip_cobs_254_ones_then_zero() {
let mut payload = vec![1u8; 254];
payload.push(0);
let mode = TxFramingMode::Cobs;
let framed = mode.encode(&payload).unwrap();
let mut dec = FrameDecoder::new(&cobs_rx_config(), None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn roundtrip_cobs_255_ones_then_zero() {
let mut payload = vec![1u8; 255];
payload.push(0);
let mode = TxFramingMode::Cobs;
let framed = mode.encode(&payload).unwrap();
let mut dec = FrameDecoder::new(&cobs_rx_config(), None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn roundtrip_cobs_256_ones_then_zero() {
let mut payload = vec![1u8; 256];
payload.push(0);
let mode = TxFramingMode::Cobs;
let framed = mode.encode(&payload).unwrap();
let mut dec = FrameDecoder::new(&cobs_rx_config(), None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn roundtrip_cobs_510_ones_then_zero() {
let mut payload = vec![1u8; 510];
payload.push(0);
let mode = TxFramingMode::Cobs;
let framed = mode.encode(&payload).unwrap();
let mut dec = FrameDecoder::new(&cobs_rx_config(), None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn roundtrip_cobs_alternating_ones_zeros_300() {
let payload: Vec<u8> = (0..300).map(|i| if i % 2 == 0 { 1 } else { 0 }).collect();
let mode = TxFramingMode::Cobs;
let framed = mode.encode(&payload).unwrap();
let mut dec = FrameDecoder::new(&cobs_rx_config(), None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn roundtrip_cobs_all_byte_values_256() {
let payload: Vec<u8> = (0..=255u8).collect();
let mode = TxFramingMode::Cobs;
let framed = mode.encode(&payload).unwrap();
let mut dec = FrameDecoder::new(&cobs_rx_config(), None).unwrap();
let frames = dec.push(&framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, payload);
}
#[test]
fn skip_empty_default_is_false() {
assert!(!RxFramingConfig::default().skip_empty);
}
#[test]
fn skip_empty_drops_empty_line_frames() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
max_frames: None,
include_terminators: false,
skip_empty: true,
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"a\n\nb\n").unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(frames[0].data, b"a");
assert_eq!(frames[1].data, b"b");
let config_off = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
max_frames: None,
include_terminators: false,
skip_empty: false,
};
let mut dec_off = FrameDecoder::new(&config_off, None).unwrap();
let frames_off = dec_off.push(b"a\n\nb\n").unwrap();
assert_eq!(frames_off.len(), 3);
assert_eq!(frames_off[0].data, b"a");
assert!(frames_off[1].data.is_empty());
assert_eq!(frames_off[2].data, b"b");
}
#[test]
fn skip_empty_drops_whitespace_only_frames() {
let input = b"a\n \nb\n";
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
max_frames: None,
include_terminators: false,
skip_empty: true,
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(input).unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(frames[0].data, b"a");
assert_eq!(frames[1].data, b"b");
let config_off = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
max_frames: None,
include_terminators: false,
skip_empty: false,
};
let mut dec_off = FrameDecoder::new(&config_off, None).unwrap();
let frames_off = dec_off.push(input).unwrap();
assert_eq!(frames_off.len(), 3);
assert_eq!(frames_off[0].data, b"a");
assert_eq!(frames_off[1].data, b" ");
assert_eq!(frames_off[2].data, b"b");
}
#[test]
fn skip_empty_drops_leading_and_trailing_blank_lines() {
let input = b"\n{\"k\":1}\n\n{\"k\":2}\n\n";
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
max_frames: None,
include_terminators: false,
skip_empty: true,
};
let parser = ParserConfig {
parser_type: ParserType::JsonLines,
custom_prompt: None,
validate: false,
};
let mut dec = FrameDecoder::new(&config, Some(&parser)).unwrap();
let frames = dec.push(input).unwrap();
assert_eq!(frames.len(), 2);
assert!(matches!(frames[0].parsed, Some(ParsedFrame::Json(_))));
assert!(matches!(frames[1].parsed, Some(ParsedFrame::Json(_))));
}
#[test]
fn skip_empty_does_not_count_skipped_frames_toward_max_frames() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
max_frames: None,
include_terminators: false,
skip_empty: true,
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"\na\n\nb\n").unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(frames[0].data, b"a");
assert_eq!(frames[0].index, 0);
assert_eq!(frames[1].data, b"b");
assert_eq!(frames[1].index, 1);
let config_off = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
max_frames: None,
include_terminators: false,
skip_empty: false,
};
let mut dec_off = FrameDecoder::new(&config_off, None).unwrap();
let frames_off = dec_off.push(b"\na\n\nb\n").unwrap();
assert_eq!(frames_off.len(), 4);
assert!(frames_off[0].data.is_empty());
assert_eq!(frames_off[0].index, 0);
assert_eq!(frames_off[1].data, b"a");
assert_eq!(frames_off[1].index, 1);
assert!(frames_off[2].data.is_empty());
assert_eq!(frames_off[2].index, 2);
assert_eq!(frames_off[3].data, b"b");
assert_eq!(frames_off[3].index, 3);
}
#[test]
fn skip_empty_preserves_frame_index_continuity() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
max_frames: None,
include_terminators: false,
skip_empty: true,
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"a\n\nb\n").unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(frames[0].index, 0);
assert_eq!(frames[1].index, 1);
}
#[test]
fn skip_empty_applies_to_slip() {
let framed: &[u8] = &[SLIP_END, SLIP_END, b'a', SLIP_END];
let config = RxFramingConfig {
mode: RxFramingMode::Slip,
max_frames: None,
include_terminators: false,
skip_empty: true,
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"a");
assert_eq!(frames[0].index, 0);
}
#[test]
fn skip_empty_applies_to_cobs() {
let framed: &[u8] = &[0x00, 0x00, 0x00, 0x02, 0x61, 0x00];
let config = RxFramingConfig {
mode: RxFramingMode::Cobs,
max_frames: None,
include_terminators: false,
skip_empty: true,
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(framed).unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"a");
assert_eq!(frames[0].index, 0);
}
#[test]
fn skip_empty_off_by_default_in_preset_json_lines() {
assert!(!preset_rx_framing(ProtocolPreset::JsonLines).skip_empty);
}
#[test]
fn skip_empty_on_in_preset_ndjson() {
assert!(preset_rx_framing(ProtocolPreset::Ndjson).skip_empty);
}
#[test]
fn preset_tx_framing_ndjson_returns_line_lf() {
let tx = preset_tx_framing(ProtocolPreset::Ndjson);
assert!(matches!(
tx.mode,
TxFramingMode::Line {
ending: TxLineEnding::Lf
}
));
}
#[test]
fn preset_rx_framing_ndjson_returns_line_auto_skip_empty() {
let rx = preset_rx_framing(ProtocolPreset::Ndjson);
assert!(matches!(
rx.mode,
RxFramingMode::Line {
ending: LineEnding::Auto
}
));
assert!(rx.skip_empty);
}
#[test]
fn preset_rx_parser_ndjson_returns_json_lines() {
let parser = preset_rx_parser(ProtocolPreset::Ndjson);
assert!(matches!(parser.parser_type, ParserType::JsonLines));
}
#[test]
fn protocol_preset_ndjson_tagged_object_roundtrip() {
assert_preset_roundtrip("ndjson", ProtocolPreset::Ndjson);
}
#[test]
fn ndjson_preset_equivalent_to_bare_config() {
let preset_tx = preset_tx_framing(ProtocolPreset::Ndjson);
let bare_tx = TxFramingConfig {
mode: TxFramingMode::Line {
ending: TxLineEnding::Lf,
},
};
assert_eq!(preset_tx, bare_tx);
let preset_rx = preset_rx_framing(ProtocolPreset::Ndjson);
let bare_rx = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
max_frames: None,
include_terminators: false,
skip_empty: true,
};
assert_eq!(preset_rx, bare_rx);
let preset_parser = preset_rx_parser(ProtocolPreset::Ndjson);
let bare_parser = ParserConfig {
parser_type: ParserType::JsonLines,
custom_prompt: None,
validate: false,
};
assert_eq!(preset_parser, bare_parser);
}
#[test]
fn flush_partial_does_not_apply_skip_empty() {
let config = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Auto,
},
max_frames: None,
include_terminators: false,
skip_empty: true,
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"b").unwrap();
assert!(frames.is_empty());
let partial = dec.flush_partial();
assert!(partial.is_some());
assert_eq!(partial.unwrap().data, b"b");
}
fn nmea_checksum_body(body: &[u8]) -> String {
let cs = XorChecksum.compute(body);
format!("{:02X}", cs[0])
}
#[test]
fn nmea_parser_valid_gga_sentence() {
let body = b"GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,";
let cs_hex = nmea_checksum_body(body);
let sentence =
format!("GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*{cs_hex}");
let p = NmeaParser { validate: true };
let result = p.parse(sentence.as_bytes()).unwrap();
match result {
ParsedFrame::Nmea {
talker_id,
sentence_type,
fields,
checksum_valid,
} => {
assert_eq!(talker_id, "GP");
assert_eq!(sentence_type, "GGA");
assert_eq!(
fields,
vec![
"123519",
"4807.038",
"N",
"01131.000",
"E",
"1",
"08",
"0.9",
"545.4",
"M",
"46.9",
"M",
"",
""
]
);
assert_eq!(checksum_valid, Some(true));
}
other => panic!("expected Nmea frame, got {other:?}"),
}
}
#[test]
fn nmea_parser_valid_gll_sentence() {
let sentence = b"GPGLL,3751.65,N,12226.54,W*7E";
let p = NmeaParser { validate: true };
let result = p.parse(sentence).unwrap();
match result {
ParsedFrame::Nmea {
talker_id,
sentence_type,
fields,
checksum_valid,
} => {
assert_eq!(talker_id, "GP");
assert_eq!(sentence_type, "GLL");
assert_eq!(fields, vec!["3751.65", "N", "12226.54", "W"]);
assert_eq!(checksum_valid, Some(true));
}
other => panic!("expected Nmea frame, got {other:?}"),
}
}
#[test]
fn nmea_parser_ais_sentence_starts_with_bang() {
let body = b"AIVDM,1,1,,B,15M67FC000G?ufbE`H9P<In,0";
let cs_hex = nmea_checksum_body(body);
let sentence = format!("AIVDM,1,1,,B,15M67FC000G?ufbE`H9P<In,0*{cs_hex}");
let p = NmeaParser { validate: true };
let result = p.parse(sentence.as_bytes()).unwrap();
match result {
ParsedFrame::Nmea {
talker_id,
sentence_type,
checksum_valid,
..
} => {
assert_eq!(talker_id, "AI");
assert_eq!(sentence_type, "VDM");
assert_eq!(checksum_valid, Some(true));
}
other => panic!("expected Nmea frame, got {other:?}"),
}
}
#[test]
fn nmea_parser_bad_checksum_returns_error_when_validate_true() {
let sentence = b"GPGLL,3751.65,N,12226.54,W*00";
let p = NmeaParser { validate: true };
let result = p.parse(sentence);
match result {
Err(FrameDecodeError::ChecksumMismatch { expected, received }) => {
assert_eq!(expected, vec![0x7E]);
assert_eq!(received, vec![0x00]);
}
other => panic!("expected ChecksumMismatch error, got {other:?}"),
}
}
#[test]
fn nmea_parser_bad_checksum_returns_some_false_when_validate_false() {
let sentence = b"GPGLL,3751.65,N,12226.54,W*00";
let p = NmeaParser { validate: false };
let result = p.parse(sentence).unwrap();
match result {
ParsedFrame::Nmea { checksum_valid, .. } => {
assert_eq!(checksum_valid, Some(false));
}
other => panic!("expected Nmea frame, got {other:?}"),
}
}
#[test]
fn nmea_parser_no_checksum_accepted() {
let sentence = b"GPGLL,3751.65,N,12226.54,W";
let p = NmeaParser { validate: true };
let result = p.parse(sentence).unwrap();
match result {
ParsedFrame::Nmea { checksum_valid, .. } => {
assert_eq!(checksum_valid, None);
}
other => panic!("expected Nmea frame, got {other:?}"),
}
let p2 = NmeaParser { validate: false };
let result2 = p2.parse(sentence).unwrap();
match result2 {
ParsedFrame::Nmea { checksum_valid, .. } => {
assert_eq!(checksum_valid, None);
}
other => panic!("expected Nmea frame, got {other:?}"),
}
}
#[test]
fn nmea_parser_non_nmea_frame_returns_raw() {
let p = NmeaParser { validate: true };
let result = p.parse(b"hello world").unwrap();
assert!(matches!(result, ParsedFrame::Raw));
let result2 = p.parse(b"AT+CGMI").unwrap();
assert!(matches!(result2, ParsedFrame::Raw));
}
#[test]
fn nmea_parser_invalid_utf8_body_returns_raw() {
let parser = build_parser(&ParserConfig {
parser_type: ParserType::Nmea,
custom_prompt: None,
validate: false,
})
.unwrap();
let body: &[u8] = b"GPGLL,\xFF,";
let result = parser.parse(body).unwrap();
assert!(
matches!(result, ParsedFrame::Raw),
"invalid UTF-8 → Raw, got {result:?}"
);
}
#[test]
fn nmea_parser_strips_leading_start_char_if_present() {
let body = b"GPGLL,3751.65,N,12226.54,W";
let cs_hex = nmea_checksum_body(body);
let sentence = format!("$GPGLL,3751.65,N,12226.54,W*{cs_hex}");
let p = NmeaParser { validate: true };
let result = p.parse(sentence.as_bytes()).unwrap();
match result {
ParsedFrame::Nmea {
talker_id,
sentence_type,
checksum_valid,
..
} => {
assert_eq!(talker_id, "GP");
assert_eq!(sentence_type, "GLL");
assert_eq!(checksum_valid, Some(true));
}
other => panic!("expected Nmea frame, got {other:?}"),
}
}
#[test]
fn nmea_parser_strips_trailing_crlf_if_present() {
let body = b"GPGLL,3751.65,N,12226.54,W";
let cs_hex = nmea_checksum_body(body);
let sentence = format!("GPGLL,3751.65,N,12226.54,W*{cs_hex}\r\n");
let p = NmeaParser { validate: true };
let result = p.parse(sentence.as_bytes()).unwrap();
match result {
ParsedFrame::Nmea {
talker_id,
sentence_type,
checksum_valid,
..
} => {
assert_eq!(talker_id, "GP");
assert_eq!(sentence_type, "GLL");
assert_eq!(checksum_valid, Some(true));
}
other => panic!("expected Nmea frame, got {other:?}"),
}
}
#[test]
fn nmea_parser_proprietary_sentence() {
let body = b"PGRMZ,2010,f,3";
let cs_hex = nmea_checksum_body(body);
let sentence = format!("PGRMZ,2010,f,3*{cs_hex}");
let p = NmeaParser { validate: true };
let result = p.parse(sentence.as_bytes()).unwrap();
match result {
ParsedFrame::Nmea {
talker_id,
sentence_type,
fields,
checksum_valid,
} => {
assert_eq!(talker_id, "PG");
assert_eq!(sentence_type, "RMZ");
assert_eq!(fields, vec!["2010", "f", "3"]);
assert_eq!(checksum_valid, Some(true));
}
other => panic!("expected Nmea frame, got {other:?}"),
}
}
#[test]
fn start_end_matches_either_of_multiple_start_markers() {
let config = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec!["$".into(), "!".into()],
end: "\r\n".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"junk$hi\r\n").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hi");
let frames = dec.push(b"junk!ok\r\n").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"ok");
}
#[test]
fn start_end_tx_uses_first_marker() {
let mode = TxFramingMode::StartEnd {
start: vec!["<".into(), ">".into()],
end: "|".into(),
marker_encoding: PatternEncoding::Utf8,
};
let framed = mode.encode(b"hi").unwrap();
assert_eq!(framed, b"<hi|");
}
#[test]
fn start_end_empty_start_vec_rejected_at_construction() {
let config = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec![],
end: "X".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
..Default::default()
};
match FrameDecoder::new(&config, None) {
Ok(_) => panic!("empty start vec should be rejected"),
Err(err) => assert!(
err.contains("Start markers must not be empty"),
"got: {err}"
),
}
}
#[test]
fn start_end_existing_single_marker_still_works() {
let config = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec!["STX".into()],
end: "ETX".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"noiseSTXdataETXjunkSTXmoreETX").unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(frames[0].data, b"data");
assert_eq!(frames[1].data, b"more");
}
#[test]
fn preset_tx_framing_nmea0183_returns_start_end_dollar() {
let tx = preset_tx_framing(ProtocolPreset::Nmea0183);
assert!(matches!(
tx.mode,
TxFramingMode::StartEnd {
start,
end,
marker_encoding: PatternEncoding::Utf8,
} if start == vec!["$".to_string()] && end == "\r\n"
));
}
#[test]
fn preset_rx_framing_nmea0183_returns_start_end_dollar_bang() {
let rx = preset_rx_framing(ProtocolPreset::Nmea0183);
match &rx.mode {
RxFramingMode::StartEnd {
start,
end,
marker_encoding,
include_markers,
} => {
assert_eq!(start, &vec!["$".to_string(), "!".to_string()]);
assert_eq!(end, "\r\n");
assert_eq!(*marker_encoding, PatternEncoding::Utf8);
assert!(!include_markers);
}
other => panic!("expected StartEnd, got {other:?}"),
}
}
#[test]
fn preset_rx_parser_nmea0183_returns_nmea_validate_true() {
let parser = preset_rx_parser(ProtocolPreset::Nmea0183);
assert!(matches!(parser.parser_type, ParserType::Nmea));
assert!(parser.validate);
}
#[test]
fn protocol_preset_nmea0183_tagged_object_roundtrip() {
assert_preset_roundtrip("nmea0183", ProtocolPreset::Nmea0183);
}
#[test]
fn nmea0183_preset_equivalent_to_bare_config() {
let preset_tx = preset_tx_framing(ProtocolPreset::Nmea0183);
let bare_tx = TxFramingConfig {
mode: TxFramingMode::StartEnd {
start: vec!["$".into()],
end: "\r\n".into(),
marker_encoding: PatternEncoding::Utf8,
},
};
assert_eq!(preset_tx, bare_tx);
let preset_rx = preset_rx_framing(ProtocolPreset::Nmea0183);
let bare_rx = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec!["$".into(), "!".into()],
end: "\r\n".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
max_frames: None,
include_terminators: false,
skip_empty: false,
};
assert_eq!(preset_rx, bare_rx);
let preset_parser = preset_rx_parser(ProtocolPreset::Nmea0183);
let bare_parser = ParserConfig {
parser_type: ParserType::Nmea,
custom_prompt: None,
validate: true,
};
assert_eq!(preset_parser, bare_parser);
}
#[test]
fn nmea_checksum_failure_surfaces_as_framing_error_via_push() {
let rx_config = preset_rx_framing(ProtocolPreset::Nmea0183);
let parser_config = preset_rx_parser(ProtocolPreset::Nmea0183);
let mut dec = FrameDecoder::new(&rx_config, Some(&parser_config)).unwrap();
let result = dec.push(b"$GPGLL,3751.65,N,12226.54,W*00\r\n");
match result {
Err(FrameDecodeError::ChecksumMismatch { expected, received }) => {
assert_eq!(expected, vec![0x7E]);
assert_eq!(received, vec![0x00]);
}
other => panic!("expected ChecksumMismatch error, got {other:?}"),
}
}
#[test]
fn nmea_valid_sentence_decodes_to_frame_with_parsed_nmea() {
let rx_config = preset_rx_framing(ProtocolPreset::Nmea0183);
let parser_config = preset_rx_parser(ProtocolPreset::Nmea0183);
let mut dec = FrameDecoder::new(&rx_config, Some(&parser_config)).unwrap();
let frames = dec.push(b"$GPGLL,3751.65,N,12226.54,W*7E\r\n").unwrap();
assert_eq!(frames.len(), 1);
match &frames[0].parsed {
Some(ParsedFrame::Nmea {
talker_id,
sentence_type,
fields,
checksum_valid,
}) => {
assert_eq!(talker_id, "GP");
assert_eq!(sentence_type, "GLL");
assert_eq!(
fields,
&vec![
"3751.65".to_string(),
"N".to_string(),
"12226.54".to_string(),
"W".to_string()
]
);
assert_eq!(*checksum_valid, Some(true));
}
other => panic!("expected Nmea parsed frame, got {other:?}"),
}
}
fn modbus_lrc(pdu: &[u8]) -> String {
let cs = Lrc.compute(pdu);
format!("{:02X}", cs[0])
}
fn modbus_body(hex_pdu: &str) -> String {
let pdu_bytes: Vec<u8> = (0..hex_pdu.len())
.step_by(2)
.map(|i| u8::from_str_radix(&hex_pdu[i..i + 2], 16).unwrap())
.collect();
let lrc_hex = modbus_lrc(&pdu_bytes);
format!("{hex_pdu}{lrc_hex}")
}
#[test]
fn modbus_ascii_parser_valid_read_holding_registers() {
let body = modbus_body("010300000001");
let p = ModbusAsciiParser { validate: true };
let result = p.parse(body.as_bytes()).unwrap();
match result {
ParsedFrame::ModbusAscii {
address,
function_code,
data,
checksum_valid,
} => {
assert_eq!(address, 1);
assert_eq!(function_code, 3);
assert_eq!(data, vec![0, 0, 0, 1]);
assert_eq!(checksum_valid, Some(true));
}
other => panic!("expected ModbusAscii frame, got {other:?}"),
}
}
#[test]
fn modbus_ascii_parser_valid_write_single_register() {
let pdu = [0x01u8, 0x06, 0x00, 0x0A, 0x00, 0x01];
let lrc_hex = modbus_lrc(&pdu);
let body = format!("0106000A0001{lrc_hex}");
let p = ModbusAsciiParser { validate: true };
let result = p.parse(body.as_bytes()).unwrap();
match result {
ParsedFrame::ModbusAscii {
address,
function_code,
data,
checksum_valid,
} => {
assert_eq!(address, 1);
assert_eq!(function_code, 6);
assert_eq!(data, vec![0x00, 0x0A, 0x00, 0x01]);
assert_eq!(checksum_valid, Some(true));
}
other => panic!("expected ModbusAscii frame, got {other:?}"),
}
}
#[test]
fn modbus_ascii_parser_exception_response() {
let pdu = [0x01u8, 0x83, 0x02];
let lrc_hex = modbus_lrc(&pdu);
let body = format!("018302{lrc_hex}");
let p = ModbusAsciiParser { validate: true };
let result = p.parse(body.as_bytes()).unwrap();
match result {
ParsedFrame::ModbusAscii {
address,
function_code,
data,
checksum_valid,
} => {
assert_eq!(address, 1);
assert_eq!(function_code, 131); assert_eq!(data, vec![2]);
assert_eq!(checksum_valid, Some(true));
}
other => panic!("expected ModbusAscii frame, got {other:?}"),
}
}
#[test]
fn modbus_ascii_parser_broadcast_address_zero() {
let pdu = [0x00u8, 0x03, 0x00, 0x00, 0x00, 0x01];
let lrc_hex = modbus_lrc(&pdu);
let body = format!("000300000001{lrc_hex}");
let p = ModbusAsciiParser { validate: true };
let result = p.parse(body.as_bytes()).unwrap();
match result {
ParsedFrame::ModbusAscii {
address,
function_code,
..
} => {
assert_eq!(address, 0);
assert_eq!(function_code, 3);
}
other => panic!("expected ModbusAscii frame, got {other:?}"),
}
}
#[test]
fn modbus_ascii_parser_bad_lrc_returns_error_when_validate_true() {
let body = b"01030000000100";
let p = ModbusAsciiParser { validate: true };
let result = p.parse(body);
match result {
Err(FrameDecodeError::ChecksumMismatch { expected, received }) => {
assert_eq!(expected, vec![0xFB]);
assert_eq!(received, vec![0x00]);
}
other => panic!("expected ChecksumMismatch error, got {other:?}"),
}
}
#[test]
fn modbus_ascii_parser_bad_lrc_returns_some_false_when_validate_false() {
let body = b"01030000000100";
let p = ModbusAsciiParser { validate: false };
let result = p.parse(body).unwrap();
match result {
ParsedFrame::ModbusAscii {
address: 1,
function_code: 3,
checksum_valid: Some(false),
..
} => {}
other => panic!("expected ModbusAscii with checksum_valid: false, got {other:?}"),
}
}
#[test]
fn modbus_ascii_parser_lowercase_hex_accepted() {
let body = b"010300000001fb";
let p = ModbusAsciiParser { validate: true };
let result = p.parse(body).unwrap();
match result {
ParsedFrame::ModbusAscii {
address: 1,
function_code: 3,
checksum_valid: Some(true),
..
} => {}
other => panic!("expected valid ModbusAscii, got {other:?}"),
}
}
#[test]
fn modbus_ascii_parser_non_hex_returns_raw() {
let p = ModbusAsciiParser { validate: true };
let result = p.parse(b"hello world").unwrap();
assert!(matches!(result, ParsedFrame::Raw));
}
#[test]
fn modbus_ascii_parser_odd_length_returns_raw() {
let p = ModbusAsciiParser { validate: true };
let result = p.parse(b"010").unwrap();
assert!(matches!(result, ParsedFrame::Raw));
}
#[test]
fn modbus_ascii_parser_too_short_returns_raw() {
let p = ModbusAsciiParser { validate: true };
let result = p.parse(b"01").unwrap();
assert!(matches!(result, ParsedFrame::Raw));
}
#[test]
fn modbus_ascii_parser_strips_leading_colon_and_trailing_crlf() {
let pdu = [0x01u8, 0x03, 0x00, 0x00, 0x00, 0x01];
let lrc_hex = modbus_lrc(&pdu);
let frame = format!(":010300000001{lrc_hex}\r\n");
let p = ModbusAsciiParser { validate: true };
let result = p.parse(frame.as_bytes()).unwrap();
match result {
ParsedFrame::ModbusAscii {
address: 1,
function_code: 3,
checksum_valid: Some(true),
..
} => {}
other => panic!("expected valid ModbusAscii, got {other:?}"),
}
}
#[test]
fn modbus_ascii_parser_empty_body_returns_raw() {
let p = ModbusAsciiParser { validate: true };
let result = p.parse(b"").unwrap();
assert!(matches!(result, ParsedFrame::Raw));
}
#[test]
fn modbus_ascii_parser_minimal_frame_3_bytes() {
let body = b"01FF00";
let p = ModbusAsciiParser { validate: true };
let result = p.parse(body).unwrap();
match result {
ParsedFrame::ModbusAscii {
address: 1,
function_code: 255,
data,
checksum_valid: Some(true),
} if data.is_empty() => {}
other => panic!("expected minimal ModbusAscii frame, got {other:?}"),
}
}
#[test]
fn modbus_ascii_checksum_failure_surfaces_as_framing_error_via_push() {
let rx_config = preset_rx_framing(ProtocolPreset::ModbusAscii);
let parser_config = preset_rx_parser(ProtocolPreset::ModbusAscii);
let mut dec = FrameDecoder::new(&rx_config, Some(&parser_config)).unwrap();
let result = dec.push(b":01030000000100\r\n");
match result {
Err(FrameDecodeError::ChecksumMismatch { expected, received }) => {
assert_eq!(expected, vec![0xFB]);
assert_eq!(received, vec![0x00]);
}
other => panic!("expected ChecksumMismatch error, got {other:?}"),
}
}
#[test]
fn modbus_ascii_valid_frame_decodes_to_frame_with_parsed_modbus_ascii() {
let rx_config = preset_rx_framing(ProtocolPreset::ModbusAscii);
let parser_config = preset_rx_parser(ProtocolPreset::ModbusAscii);
let mut dec = FrameDecoder::new(&rx_config, Some(&parser_config)).unwrap();
let frames = dec.push(b":010300000001FB\r\n").unwrap();
assert_eq!(frames.len(), 1);
match &frames[0].parsed {
Some(ParsedFrame::ModbusAscii {
address: 1,
function_code: 3,
data,
checksum_valid: Some(true),
}) => {
assert_eq!(data, &vec![0, 0, 0, 1]);
}
other => panic!("expected ModbusAscii parsed frame, got {other:?}"),
}
}
#[test]
fn preset_tx_framing_modbus_ascii_returns_start_end_colon() {
let tx = preset_tx_framing(ProtocolPreset::ModbusAscii);
assert!(matches!(
tx.mode,
TxFramingMode::StartEnd {
start,
end,
marker_encoding: PatternEncoding::Utf8,
} if start == vec![":".to_string()] && end == "\r\n"
));
}
#[test]
fn preset_rx_framing_modbus_ascii_returns_start_end_colon_crlf() {
let rx = preset_rx_framing(ProtocolPreset::ModbusAscii);
match &rx.mode {
RxFramingMode::StartEnd {
start,
end,
marker_encoding,
include_markers,
} => {
assert_eq!(start, &vec![":".to_string()]);
assert_eq!(end, "\r\n");
assert_eq!(*marker_encoding, PatternEncoding::Utf8);
assert!(!include_markers);
}
other => panic!("expected StartEnd, got {other:?}"),
}
}
#[test]
fn preset_rx_parser_modbus_ascii_returns_modbus_ascii_validate_true() {
let parser = preset_rx_parser(ProtocolPreset::ModbusAscii);
assert!(matches!(parser.parser_type, ParserType::ModbusAscii));
assert!(parser.validate);
}
#[test]
fn protocol_preset_modbus_ascii_tagged_object_roundtrip() {
assert_preset_roundtrip("modbus_ascii", ProtocolPreset::ModbusAscii);
}
#[test]
fn modbus_ascii_preset_equivalent_to_bare_config() {
let preset_tx = preset_tx_framing(ProtocolPreset::ModbusAscii);
let bare_tx = TxFramingConfig {
mode: TxFramingMode::StartEnd {
start: vec![":".into()],
end: "\r\n".into(),
marker_encoding: PatternEncoding::Utf8,
},
};
assert_eq!(preset_tx, bare_tx);
let preset_rx = preset_rx_framing(ProtocolPreset::ModbusAscii);
let bare_rx = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec![":".into()],
end: "\r\n".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
max_frames: None,
include_terminators: false,
skip_empty: false,
};
assert_eq!(preset_rx, bare_rx);
let preset_parser = preset_rx_parser(ProtocolPreset::ModbusAscii);
let bare_parser = ParserConfig {
parser_type: ParserType::ModbusAscii,
custom_prompt: None,
validate: true,
};
assert_eq!(preset_parser, bare_parser);
}
#[test]
fn skip_empty_applies_to_delimiter() {
let config_on = RxFramingConfig {
mode: RxFramingMode::Delimiter {
delimiter: "|".into(),
delimiter_encoding: PatternEncoding::Utf8,
},
max_frames: None,
include_terminators: false,
skip_empty: true,
};
let mut dec = FrameDecoder::new(&config_on, None).unwrap();
let frames = dec.push(b"a||b|").unwrap();
assert_eq!(frames.len(), 2);
assert_eq!(frames[0].data, b"a");
assert_eq!(frames[1].data, b"b");
let config_off = RxFramingConfig {
mode: RxFramingMode::Delimiter {
delimiter: "|".into(),
delimiter_encoding: PatternEncoding::Utf8,
},
max_frames: None,
include_terminators: false,
skip_empty: false,
};
let mut dec_off = FrameDecoder::new(&config_off, None).unwrap();
let frames_off = dec_off.push(b"a||b|").unwrap();
assert_eq!(frames_off.len(), 3);
assert_eq!(frames_off[0].data, b"a");
assert!(frames_off[1].data.is_empty());
assert_eq!(frames_off[2].data, b"b");
}
#[test]
fn skip_empty_applies_to_start_end() {
let config_on = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec!["$".into()],
end: "\r\n".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
max_frames: None,
include_terminators: false,
skip_empty: true,
};
let mut dec = FrameDecoder::new(&config_on, None).unwrap();
let frames = dec.push(b"$\r\n$hi\r\n").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"hi");
let config_off = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec!["$".into()],
end: "\r\n".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
max_frames: None,
include_terminators: false,
skip_empty: false,
};
let mut dec_off = FrameDecoder::new(&config_off, None).unwrap();
let frames_off = dec_off.push(b"$\r\n$hi\r\n").unwrap();
assert_eq!(frames_off.len(), 2);
assert!(frames_off[0].data.is_empty());
assert_eq!(frames_off[1].data, b"hi");
}
#[test]
fn start_end_picks_earliest_of_overlapping_markers() {
let config = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec!["$G".into(), "$GPGGA".into()],
end: "\r\n".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
..Default::default()
};
let mut dec = FrameDecoder::new(&config, None).unwrap();
let frames = dec.push(b"$GPGGA,x\r\n").unwrap();
assert_eq!(frames.len(), 1);
assert_eq!(frames[0].data, b"PGGA,x");
}
#[test]
fn nmea_parser_multi_fragment_ais_first_sentence() {
use crate::checksums::XorChecksum;
let checksum_body = b"AIVDM,2,1,3,B,55?MbV02;H0000,0";
let computed = XorChecksum.compute(checksum_body);
assert_eq!(computed, [0x22], "AIS sentence checksum is 0x22, not 0x5C");
let sentence = b"!AIVDM,2,1,3,B,55?MbV02;H0000,0*22";
let p = NmeaParser { validate: true };
let result = p.parse(sentence).unwrap();
match result {
ParsedFrame::Nmea {
talker_id,
sentence_type,
fields,
checksum_valid,
} => {
assert_eq!(talker_id, "AI");
assert_eq!(sentence_type, "VDM");
assert_eq!(fields, vec!["2", "1", "3", "B", "55?MbV02;H0000", "0"]);
assert_eq!(checksum_valid, Some(true));
}
other => panic!("expected Nmea frame, got {other:?}"),
}
}
#[test]
fn nmea_parser_preserves_whitespace_in_fields() {
use crate::checksums::XorChecksum;
let body_without_star = b"GPVTG, 48.7 ,T,,,N,,K,N";
let cs = XorChecksum.compute(body_without_star);
let cs_hex = format!("{:02X}", cs[0]);
let sentence = format!(
"${}*{}",
std::str::from_utf8(body_without_star).unwrap(),
cs_hex
);
let p = NmeaParser { validate: true };
let result = p.parse(sentence.as_bytes()).unwrap();
match result {
ParsedFrame::Nmea {
talker_id,
sentence_type,
fields,
checksum_valid,
} => {
assert_eq!(talker_id, "GP");
assert_eq!(sentence_type, "VTG");
assert_eq!(fields[0], " 48.7 ");
assert_eq!(checksum_valid, Some(true));
}
other => panic!("expected Nmea frame, got {other:?}"),
}
}
#[test]
fn modbus_ascii_parser_max_adu_length() {
use crate::checksums::Lrc;
let address = 0x01u8;
let function = 0x03u8;
let data: Vec<u8> = (0..253u8).collect();
let mut pdu = vec![address, function];
pdu.extend_from_slice(&data);
let lrc = Lrc.compute(&pdu);
let lrc_byte = lrc[0];
let mut all_bytes = pdu.clone();
all_bytes.push(lrc_byte);
let hex_body: String = all_bytes.iter().map(|b| format!("{b:02X}")).collect();
let frame = format!(":{hex_body}\r\n");
let rx_config = preset_rx_framing(ProtocolPreset::ModbusAscii);
let parser_config = preset_rx_parser(ProtocolPreset::ModbusAscii);
let mut dec = FrameDecoder::new(&rx_config, Some(&parser_config)).unwrap();
let frames = dec.push(frame.as_bytes()).unwrap();
assert_eq!(frames.len(), 1);
match &frames[0].parsed {
Some(ParsedFrame::ModbusAscii {
address: a,
function_code: fc,
data: d,
checksum_valid: Some(true),
}) => {
assert_eq!(*a, 1);
assert_eq!(*fc, 3);
assert_eq!(d.len(), 253);
}
other => panic!("expected ModbusAscii parsed frame, got {other:?}"),
}
}
#[test]
fn modbus_ascii_parser_non_ascii_body_returns_raw() {
let p = ModbusAsciiParser { validate: true };
let body1 = b"01\xC3\xA900";
let result1 = p.parse(body1).unwrap();
assert!(
matches!(result1, ParsedFrame::Raw),
"non-ASCII valid-UTF-8 body should return Raw, got {result1:?}"
);
let body2 = b"01\xFF00";
let result2 = p.parse(body2).unwrap();
assert!(
matches!(result2, ParsedFrame::Raw),
"invalid-UTF-8 body should return Raw, got {result2:?}"
);
let pdu = [0x01u8, 0x03, 0x00, 0x00, 0x00, 0x01];
let lrc_hex = {
let cs = Lrc.compute(&pdu);
format!("{:02X}", cs[0])
};
let body_valid = format!("010300000001{lrc_hex}");
let result_valid = p.parse(body_valid.as_bytes()).unwrap();
assert!(
matches!(result_valid, ParsedFrame::ModbusAscii { .. }),
"valid hex body should parse to ModbusAscii, got {result_valid:?}"
);
}
}