From e06f4e0ae3b25e7c620392cc665aa3e7d81d64c6 Mon Sep 17 00:00:00 2001 From: xieyuschen Date: Thu, 10 Oct 2024 13:36:22 +0800 Subject: [PATCH 1/3] [#213] test more crates under static_config --- .../static_config/messaging_pattern.rs | 73 +++++++++++++++++-- 1 file changed, 65 insertions(+), 8 deletions(-) diff --git a/iceoryx2/src/service/static_config/messaging_pattern.rs b/iceoryx2/src/service/static_config/messaging_pattern.rs index 45192c8a9..da8f3f7cc 100644 --- a/iceoryx2/src/service/static_config/messaging_pattern.rs +++ b/iceoryx2/src/service/static_config/messaging_pattern.rs @@ -42,15 +42,9 @@ impl Display for MessagingPattern { } impl MessagingPattern { + /// checks whether the 2 MessagingPatterns are the same regardless the values inside them. pub(crate) fn is_same_pattern(&self, rhs: &MessagingPattern) -> bool { - match self { - MessagingPattern::PublishSubscribe(_) => { - matches!(rhs, MessagingPattern::PublishSubscribe(_)) - } - MessagingPattern::Event(_) => { - matches!(rhs, MessagingPattern::Event(_)) - } - } + std::mem::discriminant(self) == std::mem::discriminant(rhs) } pub(crate) fn required_amount_of_samples_per_data_segment( @@ -68,3 +62,66 @@ impl MessagingPattern { } } } + +#[cfg(test)] +mod tests { + use iceoryx2_bb_testing::assert_that; + + use super::*; + use crate::service::config; + use crate::service::static_config::event; + use crate::service::static_config::publish_subscribe; + + #[test] + fn test_is_same_pattern() { + let cfg = config::Config::default(); + let p1 = MessagingPattern::PublishSubscribe(publish_subscribe::StaticConfig::new(&cfg)); + let p2 = MessagingPattern::PublishSubscribe(publish_subscribe::StaticConfig::new(&cfg)); + assert_that!(p1.is_same_pattern(&p2), eq true); + assert_that!(p2.is_same_pattern(&p1), eq true); + + let mut new_defaults = config::Defaults { + publish_subscribe: cfg.defaults.publish_subscribe.clone(), + event: cfg.defaults.event.clone(), + }; + new_defaults.event.event_id_max_value -= 1; + new_defaults.publish_subscribe.max_nodes -= 1; + + let cfg2 = config::Config { + defaults: new_defaults, + global: cfg.global.clone(), + }; + + // ensure the cfg and cfg2 are not equal + assert_that!(cfg, ne cfg2); + let p3 = MessagingPattern::PublishSubscribe(publish_subscribe::StaticConfig::new(&cfg2)); + assert_that!(p1.is_same_pattern(&p3), eq true); + assert_that!(p3.is_same_pattern(&p1), eq true); + + let e1 = MessagingPattern::Event(event::StaticConfig::new(&cfg)); + let e2 = MessagingPattern::Event(event::StaticConfig::new(&cfg)); + assert_that!(e1.is_same_pattern(&e2), eq true); + assert_that!(e2.is_same_pattern(&e1), eq true); + + let e3 = MessagingPattern::Event(event::StaticConfig::new(&cfg2)); + assert_that!(e1.is_same_pattern(&e3), eq true); + assert_that!(e2.is_same_pattern(&e3), eq true); + + assert_that!(p1.is_same_pattern(&e1), eq false); + assert_that!(p3.is_same_pattern(&e3), eq false); + } + + #[test] + fn test_required_amount_of_samples_per_data_segment() { + let cfg = config::Config::default(); + let p1 = MessagingPattern::PublishSubscribe(publish_subscribe::StaticConfig::new(&cfg)); + let sut = p1.required_amount_of_samples_per_data_segment(0); + assert_that!(sut, eq 33); + let sut = p1.required_amount_of_samples_per_data_segment(1); + assert_that!(sut, eq 34); + + let e1 = MessagingPattern::Event(event::StaticConfig::new(&cfg)); + let sut = e1.required_amount_of_samples_per_data_segment(1); + assert_that!(sut, eq 0); + } +} From ccec2bc137b1484138b8bbbb8f595b2522cf3f11 Mon Sep 17 00:00:00 2001 From: xieyuschen Date: Wed, 9 Oct 2024 21:52:29 +0800 Subject: [PATCH 2/3] [#213] tests methods of MessageTypeDetails --- .../static_config/message_type_details.rs | 126 ++++++++++++++++++ 1 file changed, 126 insertions(+) diff --git a/iceoryx2/src/service/static_config/message_type_details.rs b/iceoryx2/src/service/static_config/message_type_details.rs index f8dcec693..c994693d5 100644 --- a/iceoryx2/src/service/static_config/message_type_details.rs +++ b/iceoryx2/src/service/static_config/message_type_details.rs @@ -266,4 +266,130 @@ mod tests { let sut = unsafe { *payload_ptr }; assert_that!(sut, eq demo.payload); } + + #[test] + fn test_payload_layout() { + let details = MessageTypeDetails::from::(TypeVariant::FixedSize); + let sut = details.payload_layout(0); + assert_that!(sut.size(), eq 0); + let sut = details.payload_layout(5); + assert_that!(sut.size(), eq 40); + + #[repr(C)] + struct Demo { + _b: bool, + _i16: i16, + _i64: i64, + } + + let details = MessageTypeDetails::from::(TypeVariant::FixedSize); + let sut = details.payload_layout(1); + #[cfg(target_pointer_width = "32")] + let expected = 12; + #[cfg(target_pointer_width = "64")] + let expected = 16; + assert_that!(sut.size(), eq expected); + + #[cfg(target_pointer_width = "32")] + let expected = 36; + #[cfg(target_pointer_width = "64")] + let expected = 48; + let sut = details.payload_layout(3); + assert_that!(sut.size(), eq expected); + } + + #[test] + // test_sample_layout tests the sample layout for combinations of different types. + fn test_sample_layout() { + let details = MessageTypeDetails::from::(TypeVariant::FixedSize); + let sut = details.sample_layout(0); + #[cfg(target_pointer_width = "32")] + let expected = 24; + #[cfg(target_pointer_width = "64")] + let expected = 32; + assert_that!(sut.size(), eq expected); + + let details = MessageTypeDetails::from::(TypeVariant::FixedSize); + let sut = details.sample_layout(2); + #[cfg(target_pointer_width = "32")] + let expected = 40; + #[cfg(target_pointer_width = "64")] + let expected = 48; + assert_that!(sut.size(), eq expected); + + let details = MessageTypeDetails::from::(TypeVariant::FixedSize); + let sut = details.sample_layout(3); + #[cfg(target_pointer_width = "32")] + let expected = 24; + #[cfg(target_pointer_width = "64")] + let expected = 32; + assert_that!(sut.size(), eq expected); + + let details = MessageTypeDetails::from::(TypeVariant::FixedSize); + let sut = details.sample_layout(11); + + #[cfg(target_pointer_width = "32")] + let expected = 28; + #[cfg(target_pointer_width = "64")] + let expected = 32; + assert_that!(sut.size(), eq expected); + + #[repr(C)] + struct Demo { + _b: bool, + _i16: i16, + _i64: i64, + } + + let details = MessageTypeDetails::from::(TypeVariant::FixedSize); + let sut = details.sample_layout(2); + #[cfg(target_pointer_width = "32")] + let expected = 48; + #[cfg(target_pointer_width = "64")] + let expected = 64; + assert_that!(sut.size(), eq expected); + } + + #[test] + fn test_is_compatible_to() { + let left = MessageTypeDetails::from::(TypeVariant::FixedSize); + let right = MessageTypeDetails::from::(TypeVariant::FixedSize); + let sut = left.is_compatible_to(&right); + assert_that!(sut, eq false); + + let left = MessageTypeDetails::from::(TypeVariant::FixedSize); + let right = MessageTypeDetails::from::(TypeVariant::FixedSize); + let sut = left.is_compatible_to(&right); + assert_that!(sut, eq false); + + // right may have a different alignment from left. + // but note that the header alignment must be the same + let right = MessageTypeDetails { + header: TypeDetail { + variant: TypeVariant::FixedSize, + type_name: "i64".to_string(), + size: 8, + alignment: ALIGNMENT, + }, + user_header: TypeDetail { + variant: TypeVariant::FixedSize, + type_name: "i64".to_string(), + size: 8, + alignment: 2 * ALIGNMENT, + }, + payload: TypeDetail { + variant: TypeVariant::FixedSize, + type_name: "i64".to_string(), + size: 8, + alignment: 2 * ALIGNMENT, + }, + }; + // smaller to bigger is allowed. + let sut = left.is_compatible_to(&right); + assert_that!(sut, eq true); + + // bigger to smaller is invalid. + let sut = right.is_compatible_to(&left); + assert_that!(sut, eq false); + } } From 88aba3de8189f71ffa6438ea71bf2f4d3431a5fb Mon Sep 17 00:00:00 2001 From: xieyuschen Date: Thu, 10 Oct 2024 21:29:33 +0800 Subject: [PATCH 3/3] [#213] split the big test_is_compatible_to into small tests --- .../static_config/message_type_details.rs | 38 ++++++++++++++++++- 1 file changed, 37 insertions(+), 1 deletion(-) diff --git a/iceoryx2/src/service/static_config/message_type_details.rs b/iceoryx2/src/service/static_config/message_type_details.rs index c994693d5..3efa1fe9f 100644 --- a/iceoryx2/src/service/static_config/message_type_details.rs +++ b/iceoryx2/src/service/static_config/message_type_details.rs @@ -351,7 +351,7 @@ mod tests { } #[test] - fn test_is_compatible_to() { + fn test_is_compatible_to_failed_when_types_differ() { let left = MessageTypeDetails::from::(TypeVariant::FixedSize); let right = MessageTypeDetails::from::(TypeVariant::FixedSize); let sut = left.is_compatible_to(&right); @@ -361,6 +361,11 @@ mod tests { let right = MessageTypeDetails::from::(TypeVariant::FixedSize); let sut = left.is_compatible_to(&right); assert_that!(sut, eq false); + } + + #[test] + fn test_is_compatible_to_succeed_when_rhs_aligment_is_bigger() { + let left = MessageTypeDetails::from::(TypeVariant::FixedSize); // right may have a different alignment from left. // but note that the header alignment must be the same @@ -392,4 +397,35 @@ mod tests { let sut = right.is_compatible_to(&left); assert_that!(sut, eq false); } + + #[test] + fn test_is_compatible_to_fail_when_rhs_aligment_is_smaller() { + let left = MessageTypeDetails::from::(TypeVariant::FixedSize); + + // right may have a different alignment from left. + // but note that the header alignment must be the same + let right = MessageTypeDetails { + header: TypeDetail { + variant: TypeVariant::FixedSize, + type_name: "i64".to_string(), + size: 8, + alignment: ALIGNMENT, + }, + user_header: TypeDetail { + variant: TypeVariant::FixedSize, + type_name: "i64".to_string(), + size: 8, + alignment: 2 * ALIGNMENT, + }, + payload: TypeDetail { + variant: TypeVariant::FixedSize, + type_name: "i64".to_string(), + size: 8, + alignment: 2 * ALIGNMENT, + }, + }; + // bigger to smaller is invalid. + let sut = right.is_compatible_to(&left); + assert_that!(sut, eq false); + } }