Add more integration tests

Added tests for Vec, struct, union, enum, FamStructWrapper and
combinations of them for testing `Versionize` functionality.

Signed-off-by: Laura Loghin <[email protected]>

Author: lauralt

coverage_config_aarch64.json

@@ -1 +1 @@
-{"coverage_score": 91.8, "exclude_path": "", "crate_features": ""}
+{"coverage_score": 92.2, "exclude_path": "", "crate_features": ""}

coverage_config_x86_64.json

@@ -1 +1 @@
-{"coverage_score": 92.8, "exclude_path": "", "crate_features": ""}
+{"coverage_score": 93.0, "exclude_path": "", "crate_features": ""}

src/lib.rs

@@ -116,6 +116,6 @@ mod tests {
         format!("{:?}{}", Io(0), Io(0));
         format!("{:?}{}", Serialize(str.clone()), Serialize(str.clone()));
         format!("{:?}{}", Deserialize(str.clone()), Deserialize(str.clone()));
-        format!("{:?}{}", Semantic(str.clone()), Semantic(str.clone()));
+        format!("{:?}{}", Semantic(str.clone()), Semantic(str));
     }
 }

src/primitives.rs

@@ -418,30 +418,8 @@ impl<T: Versionize, U: Versionize> Versionize for (T, U) {
 
 #[cfg(test)]
 mod tests {
-    #![allow(non_upper_case_globals)]
-    #![allow(non_camel_case_types)]
-    #![allow(non_snake_case)]
     use super::*;
     use super::{VersionMap, Versionize, VersionizeResult};
-    use vmm_sys_util::generate_fam_struct_impl;
-
-    #[repr(C)]
-    #[derive(Default, Debug, Versionize)]
-    struct Message {
-        pub len: u32,
-        pub padding: u32,
-        pub value: u32,
-        #[version(start = 2, default_fn = "default_extra_value")]
-        pub extra_value: u16,
-        pub entries: __IncompleteArrayField<u32>,
-    }
-
-    impl Message {
-        fn default_extra_value(_source_version: u16) -> u16 {
-            321
-        }
-    }
-    generate_fam_struct_impl!(Message, u32, entries, u32, len, 100);
 
     // Generate primitive tests using this macro.
     macro_rules! primitive_int_test {
@@ -492,53 +470,6 @@ mod tests {
         assert_eq!(store, restore);
     }
 
-    #[repr(u32)]
-    #[derive(Debug, Versionize, PartialEq, Clone)]
-    pub enum TestState {
-        Zero,
-        One(u32, String),
-        #[version(start = 2, default_fn = "test_state_default_one")]
-        Two(u32),
-        #[version(start = 3, default_fn = "test_state_default_two")]
-        Three(u32),
-    }
-
-    impl Default for TestState {
-        fn default() -> Self {
-            Self::One(1, "Default".to_owned())
-        }
-    }
-
-    impl TestState {
-        fn test_state_default_one(
-            &self,
-            target_version: u16,
-        ) -> Result<TestState, VersionizeError> {
-            match target_version {
-                2 => Ok(TestState::Two(2)),
-                1 => Ok(TestState::Zero),
-                i => Err(VersionizeError::Serialize(format!(
-                    "Unknown target version: {}",
-                    i
-                ))),
-            }
-        }
-
-        fn test_state_default_two(
-            &self,
-            target_version: u16,
-        ) -> Result<TestState, VersionizeError> {
-            match target_version {
-                2 => Ok(TestState::Two(2)),
-                1 => Ok(TestState::One(1, "Test".to_owned())),
-                i => Err(VersionizeError::Serialize(format!(
-                    "Unknown target version: {}",
-                    i
-                ))),
-            }
-        }
-    }
-
     #[derive(Debug, serde_derive::Deserialize, PartialEq, serde_derive::Serialize, Versionize)]
     enum CompatibleEnum {
         A,
@@ -642,60 +573,6 @@ mod tests {
         assert_eq!(test_struct, restored_state);
     }
 
-    #[test]
-    fn test_enum_basic() {
-        let mut snapshot_mem = vec![0u8; 64];
-        let mut vm = VersionMap::new();
-        vm.new_version()
-            .set_type_version(TestState::type_id(), 2)
-            .new_version()
-            .set_type_version(TestState::type_id(), 3);
-
-        // Test trivial case.
-        let state = TestState::One(1337, "a string".to_owned());
-        state
-            .serialize(&mut snapshot_mem.as_mut_slice(), &vm, 1)
-            .unwrap();
-        let restored_state =
-            <TestState as Versionize>::deserialize(&mut snapshot_mem.as_slice(), &vm, 1).unwrap();
-        assert_eq!(state, restored_state);
-    }
-
-    #[test]
-    fn test_enum_rollback() {
-        let mut snapshot_mem = vec![0u8; 64];
-        let mut vm = VersionMap::new();
-        vm.new_version()
-            .set_type_version(TestState::type_id(), 2)
-            .new_version()
-            .set_type_version(TestState::type_id(), 3);
-
-        // Test `default_fn` for serialization of enum variants that don't exist in previous versions.
-        let state = TestState::Three(1337);
-        state
-            .serialize(&mut snapshot_mem.as_mut_slice(), &vm, 2)
-            .unwrap();
-        let restored_state =
-            <TestState as Versionize>::deserialize(&mut snapshot_mem.as_slice(), &vm, 2).unwrap();
-        assert_eq!(restored_state, TestState::Two(2));
-
-        let state = TestState::Three(1337);
-        state
-            .serialize(&mut snapshot_mem.as_mut_slice(), &vm, 1)
-            .unwrap();
-        let restored_state =
-            <TestState as Versionize>::deserialize(&mut snapshot_mem.as_slice(), &vm, 1).unwrap();
-        assert_eq!(restored_state, TestState::One(1, "Test".to_owned()));
-
-        let state = TestState::Two(1234);
-        state
-            .serialize(&mut snapshot_mem.as_mut_slice(), &vm, 1)
-            .unwrap();
-        let restored_state =
-            <TestState as Versionize>::deserialize(&mut snapshot_mem.as_slice(), &vm, 1).unwrap();
-        assert_eq!(restored_state, TestState::Zero);
-    }
-
     #[test]
     fn test_ser_de_bool() {
         let vm = VersionMap::new();
@@ -824,178 +701,6 @@ mod tests {
         assert_eq!(store, restore);
     }
 
-    #[test]
-    fn test_ser_de_vec_version() {
-        type MessageFamStructWrapper = FamStructWrapper<Message>;
-        let vm = VersionMap::new();
-        let mut f = MessageFamStructWrapper::new(0);
-        f.as_mut_fam_struct().padding = 123;
-        f.as_mut_fam_struct().extra_value = 321;
-
-        f.push(10).unwrap();
-        f.push(20).unwrap();
-
-        let mut snapshot_mem = vec![0u8; 512];
-        let mut store = Vec::new();
-        store.push(f.clone());
-        store.push(f.clone());
-
-        store
-            .serialize(&mut snapshot_mem.as_mut_slice(), &vm, 1)
-            .unwrap();
-        let restore = <Vec<MessageFamStructWrapper> as Versionize>::deserialize(
-            &mut snapshot_mem.as_slice(),
-            &vm,
-            1,
-        )
-        .unwrap();
-        let eq = store == restore;
-        // This is important to test separately as we rely on the default_fn to
-        // override the u16 default value.
-        assert_eq!(321, restore[0].as_fam_struct_ref().extra_value);
-        assert!(eq);
-    }
-
-    #[repr(C)]
-    #[derive(Default)]
-    pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
-    impl<T> __IncompleteArrayField<T> {
-        #[inline]
-        pub fn new() -> Self {
-            __IncompleteArrayField(::std::marker::PhantomData, [])
-        }
-        #[inline]
-        pub unsafe fn as_ptr(&self) -> *const T {
-            self as *const __IncompleteArrayField<T> as *const T
-        }
-        #[inline]
-        pub unsafe fn as_mut_ptr(&mut self) -> *mut T {
-            self as *mut __IncompleteArrayField<T> as *mut T
-        }
-        #[inline]
-        pub unsafe fn as_slice(&self, len: usize) -> &[T] {
-            ::std::slice::from_raw_parts(self.as_ptr(), len)
-        }
-        #[inline]
-        pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
-            ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-        }
-    }
-
-    impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
-        fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-            fmt.write_str("__IncompleteArrayField")
-        }
-    }
-    impl<T> ::std::clone::Clone for __IncompleteArrayField<T> {
-        #[inline]
-        fn clone(&self) -> Self {
-            Self::new()
-        }
-    }
-
-    impl<T> Versionize for __IncompleteArrayField<T> {
-        #[inline]
-        fn serialize<W: std::io::Write>(
-            &self,
-            _writer: &mut W,
-            _version_map: &VersionMap,
-            _app_version: u16,
-        ) -> Result<(), VersionizeError> {
-            Ok(())
-        }
-
-        #[inline]
-        fn deserialize<R: std::io::Read>(
-            _reader: &mut R,
-            _version_map: &VersionMap,
-            _app_version: u16,
-        ) -> Result<Self, VersionizeError> {
-            Ok(Self::new())
-        }
-
-        // Not used.
-        fn version() -> u16 {
-            1
-        }
-    }
-
-    #[test]
-    fn test_famstruct() {
-        type MessageFamStructWrapper = FamStructWrapper<Message>;
-
-        let vm = VersionMap::new();
-        let mut f = MessageFamStructWrapper::new(0);
-        f.as_mut_fam_struct().padding = 123;
-        f.as_mut_fam_struct().extra_value = 321;
-
-        f.push(10).unwrap();
-        f.push(20).unwrap();
-
-        let mut snapshot_mem = vec![0u8; 64];
-        f.serialize(&mut snapshot_mem.as_mut_slice(), &vm, 1)
-            .unwrap();
-        let restored_state =
-            MessageFamStructWrapper::deserialize(&mut snapshot_mem.as_slice(), &vm, 1).unwrap();
-
-        let original_values = f.as_slice();
-        let restored_values = restored_state.as_slice();
-
-        assert_eq!(
-            f.as_fam_struct_ref().padding,
-            restored_state.as_fam_struct_ref().padding
-        );
-        assert_eq!(original_values, restored_values);
-        assert_eq!(
-            f.as_fam_struct_ref().extra_value,
-            restored_state.as_fam_struct_ref().extra_value
-        );
-    }
-
-    #[test]
-    fn test_famstruct_ser_error() {
-        type MessageFamStructWrapper = FamStructWrapper<Message>;
-
-        let vm = VersionMap::new();
-        let mut f = MessageFamStructWrapper::new(0);
-        f.as_mut_fam_struct().padding = 123;
-        f.as_mut_fam_struct().extra_value = 321;
-
-        f.push(10).unwrap();
-        f.push(20).unwrap();
-
-        let mut snapshot_mem = vec![0u8; 16];
-
-        assert!(f
-            .serialize(&mut snapshot_mem.as_mut_slice(), &vm, 1)
-            .is_err());
-    }
-    #[test]
-    fn test_famstruct_version() {
-        type MessageFamStructWrapper = FamStructWrapper<Message>;
-
-        let vm = VersionMap::new();
-        let mut f = MessageFamStructWrapper::new(0);
-        f.as_mut_fam_struct().padding = 123;
-        f.push(10).unwrap();
-        f.push(20).unwrap();
-
-        let mut snapshot_mem = vec![0u8; 64];
-        f.serialize(&mut snapshot_mem.as_mut_slice(), &vm, 1)
-            .unwrap();
-        let restored_state =
-            MessageFamStructWrapper::deserialize(&mut snapshot_mem.as_slice(), &vm, 1).unwrap();
-
-        let original_values = f.as_slice();
-        let restored_values = restored_state.as_slice();
-
-        assert_eq!(
-            f.as_fam_struct_ref().padding,
-            restored_state.as_fam_struct_ref().padding
-        );
-        assert_eq!(original_values, restored_values);
-    }
-
     #[test]
     fn test_vec_limit() {
         // We need extra 8 bytes for vector len.