use crate::framing::ProtocolPreset;
pub(crate) fn resolve_field<T: Clone>(
explicit: Option<T>,
call_protocol: Option<ProtocolPreset>,
apply_preset: impl Fn(ProtocolPreset) -> T,
conn_default: Option<T>,
conn_protocol: Option<ProtocolPreset>,
) -> Option<T> {
if let Some(explicit) = explicit {
return Some(explicit);
}
if let Some(p) = call_protocol {
return Some(apply_preset(p));
}
if let Some(def) = conn_default {
return Some(def);
}
conn_protocol.map(apply_preset)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::framing::{
preset_rx_framing, preset_rx_parser, preset_tx_framing, LineEnding, ParserConfig,
ParserType, ProtocolPreset, RxFramingConfig, RxFramingMode, TxFramingConfig, TxFramingMode,
TxLineEnding,
};
use crate::match_config::PatternEncoding;
const PROTO: Option<ProtocolPreset> = Some(ProtocolPreset::AtCommand);
fn explicit_tx() -> TxFramingConfig {
TxFramingConfig {
mode: TxFramingMode::Line {
ending: TxLineEnding::Lf,
},
}
}
fn conn_default_tx() -> TxFramingConfig {
TxFramingConfig {
mode: TxFramingMode::Line {
ending: TxLineEnding::Crlf,
},
}
}
fn explicit_rx() -> RxFramingConfig {
RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Lf,
},
max_frames: None,
include_terminators: false,
skip_empty: false,
}
}
fn conn_default_rx() -> RxFramingConfig {
RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Cr,
},
max_frames: None,
include_terminators: false,
skip_empty: false,
}
}
fn conn_default_parser() -> ParserConfig {
ParserConfig {
parser_type: ParserType::Raw,
custom_prompt: None,
validate: false,
}
}
#[test]
fn explicit_beats_call_protocol() {
let explicit = explicit_tx();
let result = resolve_field::<TxFramingConfig>(
Some(explicit.clone()),
PROTO,
preset_tx_framing,
None,
None,
);
assert!(result.is_some());
assert_ne!(result, Some(preset_tx_framing(ProtocolPreset::AtCommand)));
assert_eq!(result, Some(explicit));
}
#[test]
fn call_protocol_beats_conn_default() {
let conn_def = conn_default_tx();
let result = resolve_field::<TxFramingConfig>(
None,
PROTO,
preset_tx_framing,
Some(conn_def.clone()),
None,
);
assert_eq!(result, Some(preset_tx_framing(ProtocolPreset::AtCommand)));
assert_ne!(result, Some(conn_def));
}
#[test]
fn conn_default_beats_conn_protocol() {
let conn_def = conn_default_tx();
let result = resolve_field::<TxFramingConfig>(
None,
None,
preset_tx_framing,
Some(conn_def.clone()),
PROTO,
);
assert_eq!(result, Some(conn_def));
assert_ne!(result, Some(preset_tx_framing(ProtocolPreset::AtCommand)));
}
#[test]
fn conn_protocol_is_fallback() {
let result = resolve_field::<TxFramingConfig>(None, None, preset_tx_framing, None, PROTO);
assert_eq!(result, Some(preset_tx_framing(ProtocolPreset::AtCommand)));
}
#[test]
fn all_none_returns_none() {
let result = resolve_field::<TxFramingConfig>(None, None, preset_tx_framing, None, None);
assert_eq!(result, None);
}
#[test]
fn mixed_gap_fill_rx_framing_explicit_plus_conn_protocol_parser() {
let explicit = explicit_rx();
let rx_framing = resolve_field::<RxFramingConfig>(
Some(explicit.clone()),
None,
preset_rx_framing,
None,
PROTO,
);
assert_eq!(rx_framing, Some(explicit));
assert_ne!(
rx_framing,
Some(preset_rx_framing(ProtocolPreset::AtCommand))
);
let rx_parser = resolve_field::<ParserConfig>(None, None, preset_rx_parser, None, PROTO);
assert_eq!(rx_parser, Some(preset_rx_parser(ProtocolPreset::AtCommand)));
}
#[test]
fn rx_framing_call_protocol_beats_conn_default() {
let conn_def = conn_default_rx();
let result = resolve_field::<RxFramingConfig>(
None,
PROTO,
preset_rx_framing,
Some(conn_def.clone()),
None,
);
assert_eq!(result, Some(preset_rx_framing(ProtocolPreset::AtCommand)));
assert_ne!(result, Some(conn_def.clone()));
}
#[test]
fn parser_call_protocol_beats_conn_default() {
let conn_def = conn_default_parser();
let result = resolve_field::<ParserConfig>(
None,
PROTO,
preset_rx_parser,
Some(conn_def.clone()),
None,
);
assert_eq!(result, Some(preset_rx_parser(ProtocolPreset::AtCommand)));
assert_ne!(result, Some(conn_def.clone()));
}
#[test]
fn slip_preset_explicit_framing_wins_over_preset() {
let explicit = TxFramingConfig {
mode: TxFramingMode::Line {
ending: TxLineEnding::Crlf,
},
};
let result = resolve_field::<TxFramingConfig>(
Some(explicit.clone()),
Some(ProtocolPreset::Slip),
preset_tx_framing,
None,
None,
);
assert_eq!(result, Some(explicit));
assert_ne!(result, Some(preset_tx_framing(ProtocolPreset::Slip)));
}
#[test]
fn json_lines_preset_explicit_framing_wins_over_preset() {
let explicit = RxFramingConfig {
mode: RxFramingMode::Delimiter {
delimiter: ",".into(),
delimiter_encoding: PatternEncoding::Utf8,
},
max_frames: None,
include_terminators: false,
skip_empty: false,
};
let result = resolve_field::<RxFramingConfig>(
Some(explicit.clone()),
Some(ProtocolPreset::JsonLines),
preset_rx_framing,
None,
None,
);
assert_eq!(result, Some(explicit));
assert_ne!(result, Some(preset_rx_framing(ProtocolPreset::JsonLines)));
}
#[test]
fn cobs_preset_explicit_framing_wins_over_preset() {
let explicit = TxFramingConfig {
mode: TxFramingMode::Line {
ending: TxLineEnding::Crlf,
},
};
let result = resolve_field::<TxFramingConfig>(
Some(explicit.clone()),
Some(ProtocolPreset::Cobs),
preset_tx_framing,
None,
None,
);
assert_eq!(result, Some(explicit));
assert_ne!(result, Some(preset_tx_framing(ProtocolPreset::Cobs)));
}
#[test]
fn ndjson_preset_explicit_framing_wins_over_preset() {
let explicit = RxFramingConfig {
mode: RxFramingMode::Delimiter {
delimiter: ",".into(),
delimiter_encoding: PatternEncoding::Utf8,
},
max_frames: None,
include_terminators: false,
skip_empty: false,
};
let result = resolve_field::<RxFramingConfig>(
Some(explicit.clone()),
Some(ProtocolPreset::Ndjson),
preset_rx_framing,
None,
None,
);
assert_eq!(result, Some(explicit));
assert_ne!(result, Some(preset_rx_framing(ProtocolPreset::Ndjson)));
}
#[test]
fn nmea0183_preset_explicit_framing_wins_over_preset() {
let explicit = TxFramingConfig {
mode: TxFramingMode::Line {
ending: TxLineEnding::Crlf,
},
};
let result = resolve_field::<TxFramingConfig>(
Some(explicit.clone()),
Some(ProtocolPreset::Nmea0183),
preset_tx_framing,
None,
None,
);
assert_eq!(result, Some(explicit));
assert_ne!(result, Some(preset_tx_framing(ProtocolPreset::Nmea0183)));
}
#[test]
fn modbus_ascii_preset_explicit_framing_wins_over_preset() {
let explicit = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Crlf,
},
..Default::default()
};
let result = resolve_field::<RxFramingConfig>(
Some(explicit.clone()),
Some(ProtocolPreset::ModbusAscii),
preset_rx_framing,
None,
None,
);
assert_eq!(result, Some(explicit));
assert_ne!(result, Some(preset_rx_framing(ProtocolPreset::ModbusAscii)));
}
#[test]
fn nmea0183_full_four_layer_precedence() {
let explicit = RxFramingConfig {
mode: RxFramingMode::Line {
ending: LineEnding::Lf,
},
..Default::default()
};
let conn_default_nmea = RxFramingConfig {
mode: RxFramingMode::StartEnd {
start: vec!["$".into()],
end: "\r\n".into(),
marker_encoding: PatternEncoding::Utf8,
include_markers: false,
},
..Default::default()
};
let result = resolve_field::<RxFramingConfig>(
Some(explicit.clone()),
Some(ProtocolPreset::Nmea0183),
preset_rx_framing,
Some(conn_default_nmea.clone()),
Some(ProtocolPreset::ModbusAscii),
);
assert_eq!(result, Some(explicit));
assert_ne!(result, Some(preset_rx_framing(ProtocolPreset::Nmea0183)));
let conn_default_delim = RxFramingConfig {
mode: RxFramingMode::Delimiter {
delimiter: ",".into(),
delimiter_encoding: PatternEncoding::Utf8,
},
max_frames: None,
include_terminators: false,
skip_empty: false,
};
let result = resolve_field::<RxFramingConfig>(
None,
None,
preset_rx_framing,
Some(conn_default_delim.clone()),
Some(ProtocolPreset::Nmea0183),
);
assert_eq!(result, Some(conn_default_delim));
assert_ne!(result, Some(preset_rx_framing(ProtocolPreset::Nmea0183)));
}
}