[eclipse-iceoryx#213]: tests methods of MessageTypeDetails

* test sample_layout as if the layout is represented by a struct * test is_compatible_to
xieyuschen · Oct 9, 2024 · 8f9bd4a · 8f9bd4a
1 parent cff32dc
commit 8f9bd4a
Showing 1 changed file with 141 additions and 0 deletions.
diff --git a/iceoryx2/src/service/static_config/message_type_details.rs b/iceoryx2/src/service/static_config/message_type_details.rs
@@ -266,4 +266,145 @@ mod tests {
         let sut = unsafe { *payload_ptr };
         assert_that!(sut, eq demo.payload);
     }
+
+    #[test]
+    // test_sample_layout tests the sample layout of different types calculated by sample_layout,
+    // as if it's the same with a declared structure inserted some aligment fields.
+    fn test_sample_layout() {
+        #[repr(C)]
+        struct WithoutPayload {
+            header: i64,
+            _user_header: i64,
+            _aligment: i64, // _aligment is used to refer the boundary inserted during sample_layout
+            _aligment2: i64,
+        }
+        let details = MessageTypeDetails::from::<i64, i64, i64>(TypeVariant::FixedSize);
+        let sut = details.sample_layout(0);
+        let expected = Layout::new::<WithoutPayload>();
+        assert_that!(sut, eq expected);
+
+        #[repr(C)]
+        struct Demo {
+            header: i64,
+            _user_header: i64,
+            _aligment: i8,
+            payload: i64,
+            _aligment2: i8,
+        }
+        let details = MessageTypeDetails::from::<i64, i64, i64>(TypeVariant::FixedSize);
+        let sut = details.sample_layout(1);
+        let expected = Layout::new::<Demo>();
+        assert_that!(sut, eq expected);
+
+        #[repr(C)]
+        struct Demos {
+            header: i64,
+            _user_header: i64,
+            _aligment: i8,
+            payload: [i64; 2],
+            _aligment2: i8,
+        }
+        let details = MessageTypeDetails::from::<i64, i64, i64>(TypeVariant::FixedSize);
+        let sut = details.sample_layout(2);
+        let expected = Layout::new::<Demos>();
+        assert_that!(sut, eq expected);
+
+        #[repr(C)]
+        struct Demo2 {
+            header: i64,
+            _user_header: i32,
+            _aligment: i8,
+            payload: i16,
+            _aligment2: i8,
+        }
+        let details = MessageTypeDetails::from::<i64, i32, i16>(TypeVariant::FixedSize);
+        let sut = details.sample_layout(1);
+        let expected = Layout::new::<Demo2>();
+        assert_that!(sut, eq expected);
+    }
+
+    #[test]
+    fn test_payload_layout() {
+        #[repr(C)]
+        struct Demo {
+            header: i64,
+            _user_header: i64,
+            _aligment: i8, // _aligment is used to refer the boundary inserted during sample_layout
+            payload: i64,
+            _aligment2: i8,
+        }
+        let details = MessageTypeDetails::from::<i64, i64, i64>(TypeVariant::FixedSize);
+        let sut = details.sample_layout(1);
+        let expected = Layout::new::<Demo>();
+        assert_that!(sut, eq expected);
+
+        #[repr(C)]
+        struct Demos {
+            header: i64,
+            _user_header: i64,
+            _aligment: i8,
+            payload: [i64; 2],
+            _aligment2: i8,
+        }
+        let details = MessageTypeDetails::from::<i64, i64, i64>(TypeVariant::FixedSize);
+        let sut = details.sample_layout(2);
+        let expected = Layout::new::<Demos>();
+        assert_that!(sut, eq expected);
+
+        #[repr(C)]
+        struct Demo2 {
+            header: i64,
+            _user_header: i32,
+            _aligment: i8,
+            payload: i16,
+            _aligment2: i8,
+        }
+        let details = MessageTypeDetails::from::<i64, i32, i16>(TypeVariant::FixedSize);
+        let sut = details.sample_layout(1);
+        let expected = Layout::new::<Demo2>();
+        assert_that!(sut, eq expected);
+    }
+
+    #[test]
+    fn test_is_compatible_to() {
+        let left = MessageTypeDetails::from::<i64, i64, i8>(TypeVariant::FixedSize);
+        let right = MessageTypeDetails::from::<i64, i64, u8>(TypeVariant::FixedSize);
+        let sut = left.is_compatible_to(&right);
+        assert_that!(sut, eq false);
+
+        let left = MessageTypeDetails::from::<i64, i64, i64>(TypeVariant::FixedSize);
+        let right = MessageTypeDetails::from::<i64, i64, i32>(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);
+    }
 }