[#213] test: add test cases

* refine some comments to make them more accurate

Author: xieyuschen

iceoryx2/src/service/builder/publish_subscribe.rs

@@ -271,6 +271,7 @@ impl<Payload: Debug + ?Sized, UserHeader: Debug, ServiceType: service::Service>
         }
     }
 
+    // triggers the underlying is_service_available method to check whether the service described in base is available.
     fn is_service_available(
         &mut self,
         error_msg: &str,
@@ -370,6 +371,7 @@ impl<Payload: Debug + ?Sized, UserHeader: Debug, ServiceType: service::Service>
         self
     }
 
+    /// Validates configuration and overrides the invalid setting with meaningful values.
     fn adjust_attributes_to_meaningful_values(&mut self) {
         let origin = format!("{:?}", self);
         let settings = self.base.service_config.publish_subscribe_mut();

iceoryx2/src/service/static_config/message_type_details.rs

@@ -20,9 +20,10 @@ use serde::{Deserialize, Serialize};
 #[derive(Default, Debug, Clone, Eq, Hash, PartialEq, Serialize, Deserialize)]
 pub enum TypeVariant {
     #[default]
-    /// A fixed size type like [`u64`]
+    /// A fixed size type which is determined during compile.
+    /// A structure holds some pointer fields should be clarified as Dynamic.
     FixedSize,
-    /// A dynamic sized type like a slice
+    /// A dynamic sized type like a slice or it contains some pointer fields.
     Dynamic,
 }
 
@@ -33,9 +34,9 @@ pub struct TypeDetail {
     pub variant: TypeVariant,
     /// Contains the output of [`core::any::type_name()`].
     pub type_name: String,
-    /// The size of the underlying type.
+    /// The size of the underlying type calculated by [`core::mem::size_of`].
     pub size: usize,
-    /// The alignment of the underlying type.
+    /// The ABI-required minimum alignment of the underlying type calculated by [`core::mem::align_of`].
     pub alignment: usize,
 }
 
@@ -64,11 +65,11 @@ pub struct MessageTypeDetails {
 }
 
 impl MessageTypeDetails {
-    pub(crate) fn from<Header, UserHeader, Payload>(variant: TypeVariant) -> Self {
+    pub(crate) fn from<Header, UserHeader, Payload>(payload_variant: TypeVariant) -> Self {
         Self {
             header: TypeDetail::__internal_new::<Header>(TypeVariant::FixedSize),
             user_header: TypeDetail::__internal_new::<UserHeader>(TypeVariant::FixedSize),
-            payload: TypeDetail::__internal_new::<Payload>(variant),
+            payload: TypeDetail::__internal_new::<Payload>(payload_variant),
         }
     }
 
@@ -78,6 +79,7 @@ impl MessageTypeDetails {
         payload_start as *const u8
     }
 
+    /// returns pointer of user_header which is the field follows the header field in a structure.
     pub(crate) fn user_header_ptr_from_header(&self, header: *const u8) -> *const u8 {
         let header = header as usize;
         let user_header_start = align(header + self.header.size, self.user_header.alignment);
@@ -120,3 +122,124 @@ impl MessageTypeDetails {
             && self.payload.alignment <= rhs.payload.alignment
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use iceoryx2_bb_testing::assert_that;
+
+    #[test]
+    fn test_from(){
+        struct MyPayload{
+            _a: i32,
+            _b: bool,
+            _c: i64, 
+        }
+
+        let got = MessageTypeDetails::from::<i32,i64,MyPayload>(TypeVariant::FixedSize);
+        let want = MessageTypeDetails{
+            header:  TypeDetail{
+                variant: TypeVariant::FixedSize,
+                type_name: "i32".to_string(),
+                size: 4,
+                alignment: 4,
+            },
+            user_header: TypeDetail{
+                variant: TypeVariant::FixedSize,
+                type_name: "i64".to_string(),
+                size: 8,
+                alignment: 8,
+            },
+            payload: TypeDetail{
+                variant: TypeVariant::FixedSize,
+                type_name: "iceoryx2::service::static_config::message_type_details::tests::test_from::MyPayload".to_string(),
+                size: 16,
+                alignment: 8,
+            },
+        };
+        assert_that!(want, eq got);
+
+        let got = MessageTypeDetails::from::<i32,bool,String>(TypeVariant::Dynamic);
+        let want = MessageTypeDetails{
+            header:  TypeDetail{
+                variant: TypeVariant::FixedSize,
+                type_name: "i32".to_string(),
+                size: 4,
+                alignment: 4,
+            },
+            user_header: TypeDetail{
+                variant: TypeVariant::FixedSize,
+                type_name: "bool".to_string(),
+                size: 1,
+                alignment: 1,
+            },
+            payload: TypeDetail{
+                variant: TypeVariant::Dynamic,
+                type_name: "alloc::string::String".to_string(),
+                size: 24,
+                alignment: 8,
+            },
+        };
+        assert_that!(want, eq got);
+    }   
+
+    #[test]
+    fn test_user_header_ptr_from_header(){
+        let details = MessageTypeDetails::from::<i32,bool,String>(TypeVariant::Dynamic);
+        struct Demo {
+            header: i32,
+            user_header: bool,
+            _payload: String,
+        }
+        
+        let demo = Demo{
+            header: 123,
+            user_header: true,
+            _payload: "test".to_string(),
+        };
+
+        let ptr: *const u8 = &demo.header as *const _ as *const u8;
+        let user_header_ptr = details.user_header_ptr_from_header(ptr);
+        let got: *const bool  = user_header_ptr as *const bool;
+        assert_that!(unsafe { *got } , eq demo.user_header);
+
+        let details = MessageTypeDetails::from::<i64,i32,String>(TypeVariant::Dynamic);
+        struct Demo2 {
+            header: i64,
+            user_header: i32,
+            _payload: String,
+        }
+        
+        let demo = Demo2{
+            header: 123,
+            user_header: 999,
+            _payload: "test".to_string(),
+        };
+
+        let ptr: *const u8 = &demo.header as *const _ as *const u8;
+        let user_header_ptr = details.user_header_ptr_from_header(ptr);
+        let got: *const i32  = user_header_ptr as *const i32;
+        assert_that!(unsafe { *got } , eq demo.user_header);        
+    }
+
+    #[test]
+    fn test_payload_ptr_from_header(){
+        let details = MessageTypeDetails::from::<i32,i32,i32>(TypeVariant::Dynamic);
+        struct Demo {
+            header: i32,
+            _user_header: i32,
+            payload: i32,
+        }
+        
+        let demo = Demo{
+            header: 123,
+            _user_header: 123,
+            payload:9999,
+        };
+
+        let ptr: *const u8 = &demo.header as *const _ as *const u8;
+        let payload_ptr = details.payload_ptr_from_header(ptr) as *const i32;
+        let got = unsafe { *payload_ptr };
+        assert_that!(got, eq demo.payload);
+    }
+}

iceoryx2/tests/service_static_config_tests.rs

@@ -0,0 +1,56 @@
+// Copyright (c) 2024 Contributors to the Eclipse Foundation
+//
+// See the NOTICE file(s) distributed with this work for additional
+// information regarding copyright ownership.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Apache Software License 2.0 which is available at
+// https://www.apache.org/licenses/LICENSE-2.0, or the MIT license
+// which is available at https://opensource.org/licenses/MIT.
+//
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+ #[cfg(test)]
+mod service_static_config_message_type_details {
+    use iceoryx2::service::static_config::message_type_details::{TypeDetail,TypeVariant};
+    use iceoryx2_bb_testing::assert_that;
+
+    #[test]
+    fn test_internal_new(){
+        struct Tmp;
+        let got = TypeDetail::__internal_new::<Tmp>(TypeVariant::FixedSize);
+        let want = TypeDetail{
+            variant: TypeVariant::FixedSize,
+            type_name: "service_static_config_tests::service_static_config_message_type_details::test_internal_new::Tmp".to_string(),
+            size: 0 ,
+            alignment: 1,
+        }; 
+        assert_that!(want, eq got);
+
+        let got = TypeDetail::__internal_new::<i64>(TypeVariant::FixedSize);
+        let want = TypeDetail{
+            variant: TypeVariant::FixedSize,
+            type_name: "i64".to_string(),
+            size: 8,
+            alignment: 8,
+        };
+        assert_that!(want, eq got);
+
+        let got = TypeDetail::__internal_new::<TypeDetail>(TypeVariant::FixedSize);
+        let want = TypeDetail{
+            variant: TypeVariant::FixedSize,
+            type_name: "iceoryx2::service::static_config::message_type_details::TypeDetail".to_string(),
+            size: 48,
+            alignment: 8,
+        };
+
+        assert_that!(want, eq got);
+    }
+    
+
+
+    #[test]
+    fn test_payload_ptr_from_header(){
+
+    }
+}