#![allow(clippy::unwrap_used, clippy::expect_used, clippy::indexing_slicing)]
use dbc_parse::{AttributeObject, AttributeValue, ByteOrder, CanId, Dbc, MultiplexingInfo};
#[test]
fn motohawk_structure() {
let dbc = Dbc::parse(include_str!("files/motohawk.dbc")).unwrap();
assert_eq!(dbc.version.as_deref(), Some("1.0"));
assert_eq!(
dbc.nodes
.iter()
.map(|node| node.name.as_str())
.collect::<Vec<_>>(),
vec!["PCM1", "FOO"]
);
assert_eq!(dbc.messages.len(), 1);
let message = &dbc.messages[0];
assert_eq!(message.id, CanId::Standard(496));
assert_eq!(message.name, "ExampleMessage");
assert_eq!(message.dlc, 8);
assert_eq!(message.sender, "PCM1");
assert_eq!(message.signals.len(), 3);
assert_eq!(
message
.signals
.iter()
.map(|s| s.name.as_str())
.collect::<Vec<_>>(),
vec!["Temperature", "AverageRadius", "Enable"]
);
let temperature = &message.signals[0];
assert_eq!(temperature.byte_order, ByteOrder::Motorola);
assert!(temperature.is_signed);
assert!((temperature.scale - 0.01).abs() < 1e-12);
assert!((temperature.offset - 250.0).abs() < 1e-12);
assert!((temperature.min - 229.52).abs() < 1e-9);
assert!((temperature.max - 270.47).abs() < 1e-9);
assert_eq!(temperature.unit, "degK");
assert_eq!(
temperature.receivers,
vec!["PCM1".to_string(), "FOO".to_string()]
);
assert_eq!(temperature.multiplexing_info, MultiplexingInfo::None);
let average_radius = &message.signals[1];
assert_eq!(average_radius.scale, 0.1);
assert_eq!(average_radius.receivers, vec!["Vector__XXX".to_string()]);
assert_eq!(dbc.attributes, &[] as &[dbc_parse::Attribute]);
let table = dbc
.value_tables
.iter()
.find(|table| table.signal == "Enable")
.unwrap();
assert_eq!(table.message_id, Some(496));
assert_eq!(
table.entries,
vec![(0, "Disabled".to_string()), (1, "Enabled".to_string())]
);
}
#[test]
fn multiplex_structure() {
let dbc = Dbc::parse(include_str!("files/multiplex.dbc")).unwrap();
assert_eq!(dbc.messages.len(), 1);
let message = &dbc.messages[0];
assert_eq!(message.id, CanId::Extended(0x0012_3456));
assert_eq!(message.name, "Message1");
assert_eq!(message.sender, "Vector__XXX");
assert_eq!(message.signals.len(), 12);
let switch = message
.signals
.iter()
.find(|signal| signal.name == "Multiplexor")
.unwrap();
assert_eq!(switch.multiplexing_info, MultiplexingInfo::Multiplexor);
assert_eq!(switch.start_bit, 2);
assert_eq!(switch.bit_length, 6);
assert_eq!(switch.byte_order, ByteOrder::Intel);
let bit_l = message
.signals
.iter()
.find(|signal| signal.name == "BIT_L")
.unwrap();
assert_eq!(bit_l.multiplexing_info, MultiplexingInfo::Value(8));
let bit_k = message
.signals
.iter()
.find(|signal| signal.name == "BIT_K")
.unwrap();
assert_eq!(bit_k.multiplexing_info, MultiplexingInfo::Value(24));
assert_eq!(dbc.extended_multiplexing.len(), 4);
for mux in &dbc.extended_multiplexing {
assert_eq!(mux.message_id, 0x0012_3456);
assert_eq!(mux.selector, "Multiplexor");
assert_eq!(mux.ranges, vec![(8, 8), (16, 16), (24, 24)]);
}
assert!(dbc
.extended_multiplexing
.iter()
.any(|mux| mux.signal == "BIT_L"));
assert_eq!(dbc.attributes.len(), 3);
let bus_type = dbc
.attributes
.iter()
.find(|attribute| attribute.name == "BusType")
.unwrap();
assert_eq!(bus_type.object, AttributeObject::Database);
assert_eq!(bus_type.value, AttributeValue::Str("CAN".to_string()));
let frame_format = dbc
.attributes
.iter()
.find(|attribute| attribute.name == "VFrameFormat")
.unwrap();
assert_eq!(frame_format.object, AttributeObject::Message(0x0012_3456));
assert_eq!(frame_format.value, AttributeValue::Int(3));
}
#[test]
fn multiplexed_unpack_selects_the_group() {
let dbc = Dbc::parse(include_str!("files/multiplex.dbc")).unwrap();
let message = &dbc.messages[0];
let payload = [0x20, 0x00, 0x08, 0x01, 0, 0, 0, 0];
let values = message.unpack(&payload);
assert_eq!(values.len(), 5, "m8 group + switch, not the m24 signals");
let by_name = |name: &str| {
values
.iter()
.find(|(signal, _)| signal.name == name)
.map(|(_, value)| *value)
};
assert_eq!(by_name("Multiplexor"), Some(8.0));
assert_eq!(by_name("BIT_C"), Some(1.0));
assert_eq!(by_name("BIT_L"), Some(1.0));
assert_eq!(by_name("BIT_K"), None, "m24 group must not appear at 8");
let payload = [24 << 2, 0, 0, 0x10, 0x42, 0, 0, 0];
let values = message.unpack(&payload);
assert_eq!(
values.len(),
8,
"7 m24 signals + switch, not the m8 signals"
);
let by_name = |name: &str| {
values
.iter()
.find(|(signal, _)| signal.name == name)
.map(|(_, value)| *value)
};
assert_eq!(by_name("Multiplexor"), Some(24.0));
assert_eq!(by_name("BIT_K"), Some(1.0));
assert_eq!(by_name("BIT_B"), Some(1.0));
assert_eq!(by_name("BIT_H"), Some(1.0));
assert_eq!(by_name("BIT_L"), None, "m8 group must not appear at 24");
let payload = [16 << 2, 0, 0, 0x01, 0, 0, 0, 0];
let values = message.unpack(&payload);
assert_eq!(values.len(), 1);
assert_eq!(values[0].0.name, "Multiplexor");
assert_eq!(values[0].1, 16.0);
}
#[test]
fn syntax_errors_report_lines() {
let source = "VERSION \"x\"\n\nBO_ nope Bad: 8 X\n";
let err = Dbc::parse(source).unwrap_err();
assert_eq!(
err,
dbc_parse::DbcError::Syntax {
line: 3,
message: "invalid message id: \"nope\"".to_string()
}
);
}
#[test]
fn multiplex_token_variants() {
let dbc = Dbc::parse(
"BO_ 5 M: 8 N\n SG_ sw M : 0|8@1+ (1,0) [0|0] \"\" N\n SG_ x m3M : 8|8@1+ (1,0) [0|0] \"\" N\n",
)
.unwrap();
let x = dbc.messages[0]
.signals
.iter()
.find(|signal| signal.name == "x")
.unwrap();
assert_eq!(x.multiplexing_info, MultiplexingInfo::Value(3));
}
#[test]
fn error_display_covers_every_variant() {
use dbc_parse::DbcError;
let cases: Vec<(DbcError, &str)> = vec![
(
DbcError::Syntax {
line: 7,
message: "boom".to_string(),
},
"DBC syntax error at line 7: boom",
),
(
DbcError::InvalidId {
raw: 0x8000,
max: 0x7FF,
},
"DBC message id 0x8000 exceeds its width limit 0x7FF",
),
(
DbcError::ValueOutOfRange {
value: 300.0,
min: 0.0,
max: 255.0,
},
"physical value 300 outside the declared range [0|255]",
),
(
DbcError::RawOutOfRange {
raw: -1.0,
bit_length: 8,
},
"raw value -1 does not fit a 8-bit signal",
),
(
DbcError::BufferTooShort { need: 4, have: 2 },
"buffer of 2 bytes is too short: need 4",
),
];
for (error, expected) in cases {
assert_eq!(error.to_string(), expected);
assert_ne!(format!("{error:?}"), "");
}
}