Increase coverage for snapshot crates

Added some unit tests for the snapshotting functionality.
Added a few more comments in tests and fixed some typos.

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

Author: lauralt

src/snapshot/src/lib.rs

@@ -7,7 +7,7 @@
 //!
 //! The `Snapshot` API manages serialization and deserialization of collections of objects
 //! that implement the `Versionize` trait. Each object is stored in a separate section
-//! that can be save/loaded independently:
+//! that can be saved/loaded independently:
 //!
 //!  |----------------------------|
 //!  |       64 bit magic_id      |
@@ -25,10 +25,10 @@
 //!  |        optional CRC64      |
 //!  |----------------------------|
 //!
-//! Each structure, union or enum is versioned separately and only need to increment their version
+//! Each structure, union or enum is versioned separately and only needs to increment their version
 //! if a field is added or removed. For each state snapshot we define 2 versions:
 //!  - **the format version** which refers to the SnapshotHdr, Section headers, CRC, or the
-//! representation of primitives types (currentl we use serde bincode as a backend). The current
+//! representation of primitives types (currently we use serde bincode as a backend). The current
 //! implementation does not have any logic dependent on it.
 //!  - **the data version** which refers to the state stored in all of the snapshot sections.
 //!
@@ -340,6 +340,80 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_get_format_version_x86() {
+        // Check if `get_format_version()` returns indeed the format
+        // version (the least significant 2 bytes) if the id is valid
+        // (the other bytes == BASE_MAGIC_ID).
+        #[cfg(target_arch = "x86_64")]
+        let good_magic_id = 0x0710_1984_8664_0001u64;
+        #[cfg(target_arch = "aarch64")]
+        let good_magic_id = 0x0710_1984_AAAA_0001u64;
+
+        assert_eq!(get_format_version(good_magic_id).unwrap(), 1u16);
+
+        // Flip a bit to invalidate the arch id.
+        let invalid_magic_id = good_magic_id | (1u64 << 63);
+        assert_eq!(
+            get_format_version(invalid_magic_id).unwrap_err(),
+            Error::InvalidMagic(invalid_magic_id)
+        );
+    }
+
+    #[test]
+    fn test_section_ops() {
+        let vm = VersionMap::new();
+        let state = Test {
+            field0: 0,
+            field1: 1,
+            field2: 2,
+            field3: "test".to_owned(),
+            field4: vec![4, 3, 2, 1],
+            field_x: 0,
+        };
+
+        let mut snapshot_mem = vec![0u8; 1024];
+
+        // Serialize as v1.
+        let mut snapshot = Snapshot::new(vm.clone(), 1);
+        snapshot.write_section("test", &state).unwrap();
+        snapshot.save(&mut snapshot_mem.as_mut_slice()).unwrap();
+
+        let mut sections = &mut snapshot.sections;
+        assert_eq!(sections.len(), 1);
+
+        let section = sections.get_mut("test").unwrap();
+        assert_eq!(section.name, "test");
+        // Data should contain field_x (8 bytes), field0 (8 bytes) and field1 (4 bytes) in this order.
+        // field_x == 1 because of the semantic serializer fn for field3, the semantic serializer fn
+        // for field4 will set field0 to field4.iter().sum() = 10 and field1 == 1 (the original value).
+        assert_eq!(
+            section.data,
+            [1, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
+        );
+
+        let state_1 = Test1 {
+            field_x: 0,
+            field0: 0,
+            field1: 1,
+        };
+
+        snapshot.write_section("test1", &state_1).unwrap();
+        snapshot.save(&mut snapshot_mem.as_mut_slice()).unwrap();
+        sections = &mut snapshot.sections;
+        assert_eq!(sections.len(), 2);
+
+        // Trying to read a section with an invalid name should fail.
+        assert_eq!(
+            snapshot.read_section::<Test>("test2").unwrap_err(),
+            Error::SectionNotFound
+        );
+
+        // Validate that the 2 inserted objects can be deserialized.
+        assert!(snapshot.read_section::<Test>("test").is_ok());
+        assert!(snapshot.read_section::<Test1>("test1").is_ok());
+    }
+
     #[test]
     fn test_struct_semantic_fn() {
         let mut vm = VersionMap::new();
@@ -370,8 +444,14 @@ mod tests {
 
         // The semantic serializer fn for field4 will set field0 to field4.iter().sum() == 10.
         assert_eq!(restored_state.field0, state.field4.iter().sum::<u64>());
+        // The semantic deserializer for field4 will change field's value to vec![field0; 4].
         assert_eq!(restored_state.field4, vec![restored_state.field0; 4]);
+        // The semantic serializer and deserializer for field3 will both increment field_x value.
         assert_eq!(restored_state.field_x, 2);
+        // field1 should have the original value.
+        assert_eq!(restored_state.field1, 1);
+        // field2 should have the default value as this field was added at version 2.
+        assert_eq!(restored_state.field2, 20);
 
         // Serialize as v3.
         let mut snapshot = Snapshot::new(vm.clone(), 3);
@@ -381,10 +461,13 @@ mod tests {
         snapshot = Snapshot::load(&mut snapshot_mem.as_slice(), vm.clone()).unwrap();
         restored_state = snapshot.read_section::<Test>("test").unwrap();
 
-        // The semantic fn for field4 will set field0 to field4.iter().sum() == 10.
+        // We expect only the semantic serializer and deserializer for field4 to be called at version 3.
+        // The semantic serializer will set field0 to field4.iter().sum() == 10.
         assert_eq!(restored_state.field0, state.field4.iter().sum::<u64>());
-        // The semantic deserializer fn will create 4 element vec with all values == field0
+        // The semantic deserializer will create a 4 elements vec with all values == field0.
         assert_eq!(restored_state.field4, vec![restored_state.field0; 4]);
+        // The semantic fn for field3 must not be called at version 3.
+        assert_eq!(restored_state.field_x, 0);
 
         // Serialize as v4.
         let mut snapshot = Snapshot::new(vm.clone(), 4);
@@ -394,7 +477,7 @@ mod tests {
         snapshot = Snapshot::load(&mut snapshot_mem.as_slice(), vm.clone()).unwrap();
         restored_state = snapshot.read_section::<Test>("test").unwrap();
 
-        // The semantic fn must not be called.
+        // The 4 semantic fns must not be called at version 4.
         assert_eq!(restored_state.field0, 0);
         assert_eq!(restored_state.field4, vec![4, 3, 2, 1]);
     }
@@ -419,7 +502,7 @@ mod tests {
         };
 
         let mut snapshot = Snapshot::new(vm.clone(), 4);
-        // The section will succesfully be serialized.
+        // The section will successfully be serialized.
         assert!(snapshot.write_section("test", &state).is_ok());
 
         snapshot = Snapshot::new(vm.clone(), 1);
@@ -452,7 +535,7 @@ mod tests {
         let mut snapshot_mem = vec![0u8; 1024];
 
         let mut snapshot = Snapshot::new(vm.clone(), 2);
-        // The section will succesfully be serialized.
+        // The section will successfully be serialized.
         assert!(snapshot.write_section("test", &state).is_ok());
         assert_eq!(snapshot.save(&mut snapshot_mem.as_mut_slice()), Ok(()));
 
@@ -478,8 +561,9 @@ mod tests {
 
         // Serialize as v1.
         let mut snapshot = Snapshot::new(vm.clone(), 1);
-        // The section will succesfully be serialized.
+        // The section will successfully be serialized.
         assert!(snapshot.write_section("test", &state_1).is_ok());
+        // Saving the snapshot will fail due to the small size of `snapshot_mem` vec.
         assert_eq!(
             snapshot.save(&mut snapshot_mem.as_mut_slice()).unwrap_err(),
             Error::Serialize(
@@ -502,7 +586,7 @@ mod tests {
 
         // Serialize as v1.
         let mut snapshot = Snapshot::new(vm.clone(), 1);
-        // The section will succesfully be serialized.
+        // The section will successfully be serialized.
         snapshot.write_section("test", &state_1).unwrap();
         snapshot
             .save_with_crc64(&mut snapshot_mem.as_mut_slice())
@@ -523,7 +607,7 @@ mod tests {
 
         // Serialize as v1.
         let mut snapshot = Snapshot::new(vm.clone(), 1);
-        // The section will succesfully be serialized.
+        // The section will successfully be serialized.
         snapshot.write_section("test", &state_1).unwrap();
         snapshot
             .save_with_crc64(&mut snapshot_mem.as_mut_slice())
@@ -562,10 +646,12 @@ mod tests {
         let mut snapshot_mem = vec![0u8; 1024];
 
         let mut snapshot = Snapshot::new(vm.clone(), 4);
-        // The section will succesfully be serialized.
+        // The section will successfully be serialized.
         assert!(snapshot.write_section("test", &state).is_ok());
         assert_eq!(snapshot.save(&mut snapshot_mem.as_mut_slice()), Ok(()));
 
+        // Load operation should fail if we don't use the whole `snapshot_mem` resulted from
+        // serialization.
         snapshot_mem.truncate(10);
         let snapshot_load_error =
             Snapshot::load(&mut snapshot_mem.as_slice(), vm.clone()).unwrap_err();
@@ -714,7 +800,6 @@ mod tests {
 
         snapshot = Snapshot::load(&mut snapshot_mem.as_slice(), vm.clone()).unwrap();
         let restored_state = snapshot.read_section::<kvm_pit_config>("test").unwrap();
-        println!("State: {:?}", restored_state);
         // Check if we serialized x correctly, that is if semantic_x() was called.
         assert_eq!(restored_state, state);
     }
@@ -723,7 +808,7 @@ mod tests {
     fn test_basic_add_remove_field() {
         #[rustfmt::skip]
         let basic_add_remove_field_v1: &[u8] = &[
-            0x01, 0x00, 
+            0x01, 0x00,
             #[cfg(target_arch = "aarch64")]
             0xAA, 
             #[cfg(target_arch = "aarch64")]
@@ -742,7 +827,7 @@ mod tests {
         let basic_add_remove_field_v2: &[u8] = &[
             0x01, 0x00,
             #[cfg(target_arch = "aarch64")]
-            0xAA, 
+            0xAA,
             #[cfg(target_arch = "aarch64")]
             0xAA,
             #[cfg(target_arch = "x86_64")]
@@ -758,9 +843,9 @@ mod tests {
 
         #[rustfmt::skip]
         let basic_add_remove_field_v3: &[u8] = &[
-            0x01, 0x00, 
+            0x01, 0x00,
             #[cfg(target_arch = "aarch64")]
-            0xAA, 
+            0xAA,
             #[cfg(target_arch = "aarch64")]
             0xAA,
             #[cfg(target_arch = "x86_64")]
@@ -823,27 +908,24 @@ mod tests {
 
         let mut snapshot = Snapshot::load(&mut snapshot_blob, vm.clone()).unwrap();
         let mut restored_state = snapshot.read_section::<B>("test").unwrap();
-        println!("State: {:?}", restored_state);
         // Check if we serialized x correctly, that is if semantic_x() was called.
         assert_eq!(restored_state.a.x, 1234);
         assert_eq!(restored_state.a.z, stringify!(whatever));
 
         snapshot_blob = basic_add_remove_field_v2;
         snapshot = Snapshot::load(&mut snapshot_blob, vm.clone()).unwrap();
         restored_state = snapshot.read_section::<B>("test").unwrap();
-        println!("State: {:?}", restored_state);
         // Check if x was not serialized, it should be 0.
         assert_eq!(restored_state.a.x, 0);
-        // z field was added in version to, make sure it contains the original value
+        // z field was added in version 2, make sure it contains the original value.
         assert_eq!(restored_state.a.z, stringify!(basic));
 
         snapshot_blob = basic_add_remove_field_v3;
         snapshot = Snapshot::load(&mut snapshot_blob, vm.clone()).unwrap();
         restored_state = snapshot.read_section::<B>("test").unwrap();
-        println!("State: {:?}", restored_state);
         // Check if x was not serialized, it should be 0.
         assert_eq!(restored_state.a.x, 0);
-        // z field was added in version to, make sure it contains the original value
+        // z field was added in version 2, make sure it contains the original value.
         assert_eq!(restored_state.a.z, stringify!(basic));
         assert_eq!(restored_state.a.q, 1234);
     }

src/versionize/src/crc.rs

@@ -78,6 +78,23 @@ where
 mod tests {
     use super::{CRC64Reader, CRC64Writer, Read, Write};
 
+    #[test]
+    fn test_crc_new() {
+        let buf = vec![1; 5];
+        let mut slice = buf.as_slice();
+        let crc_reader = CRC64Reader::new(&mut slice);
+        assert_eq!(crc_reader.crc64, 0);
+        assert_eq!(crc_reader.reader, &[1; 5]);
+        assert_eq!(crc_reader.checksum(), 0);
+
+        let mut buf = vec![0; 5];
+        let mut slice = buf.as_mut_slice();
+        let crc_writer = CRC64Writer::new(&mut slice);
+        assert_eq!(crc_writer.crc64, 0);
+        assert_eq!(crc_writer.writer, &[0; 5]);
+        assert_eq!(crc_writer.checksum(), 0);
+    }
+
     #[test]
     fn test_crc_read() {
         let buf = vec![1, 2, 3, 4, 5];
@@ -87,14 +104,7 @@ mod tests {
         let mut crc_reader = CRC64Reader::new(&mut slice);
         crc_reader.read_to_end(&mut read_buf).unwrap();
         assert_eq!(crc_reader.checksum(), 0xFB04_60DE_0638_3654);
-    }
-
-    #[test]
-    fn test_crc_init() {
-        let buf = vec![1, 2, 3, 4, 5];
-        let mut slice = buf.as_slice();
-        let crc_reader = CRC64Reader::new(&mut slice);
-        assert_eq!(crc_reader.checksum(), 0);
+        assert_eq!(crc_reader.checksum(), crc_reader.crc64);
     }
 
     #[test]
@@ -107,5 +117,6 @@ mod tests {
         crc_writer.write_all(&write_buf.as_slice()).unwrap();
         crc_writer.flush().unwrap();
         assert_eq!(crc_writer.checksum(), 0x29D5_3572_1632_6566);
+        assert_eq!(crc_writer.checksum(), crc_writer.crc64);
     }
 }

src/versionize/src/primitives.rs

@@ -156,7 +156,7 @@ where
             0u8 => Ok(None),
             1u8 => Ok(Some(T::deserialize(reader, version_map, app_version)?)),
             value => Err(Error::Deserialize(format!(
-                "Invalind option value {}",
+                "Invalid option value {}",
                 value
             ))),
         }
@@ -488,17 +488,43 @@ mod tests {
     fn test_ser_de_option() {
         let vm = VersionMap::new();
         let mut snapshot_mem = vec![0u8; 64];
-
-        let store = Some("test".to_owned());
+        let mut store = Some("test".to_owned());
 
         store
             .serialize(&mut snapshot_mem.as_mut_slice(), &vm, 1)
             .unwrap();
-        let restore =
+        let mut restore =
             <Option<String> as Versionize>::deserialize(&mut snapshot_mem.as_slice(), &vm, 1)
                 .unwrap();
+        assert_eq!(store, restore);
 
+        // Check that ser_de also works for `None` variant.
+        store = None;
+        store
+            .serialize(&mut snapshot_mem.as_mut_slice(), &vm, 1)
+            .unwrap();
+        restore = <Option<String> as Versionize>::deserialize(&mut snapshot_mem.as_slice(), &vm, 1)
+            .unwrap();
         assert_eq!(store, restore);
+
+        store = Some("test".to_owned());
+        store
+            .serialize(&mut snapshot_mem.as_mut_slice(), &vm, 1)
+            .unwrap();
+        // Corrupt `snapshot_mem` by changing the most significant bit to a value different than 0 or 1.
+        snapshot_mem[0] = 2;
+        let restore_err =
+            <Option<String> as Versionize>::deserialize(&mut snapshot_mem.as_slice(), &vm, 1)
+                .unwrap_err();
+        assert_eq!(
+            restore_err,
+            Error::Deserialize("Invalid option value 2".to_string())
+        );
+        // Corrupt `snapshot_mem` by changing the most significant bit from 1 (`Some(type)`) to 0 (`None`).
+        snapshot_mem[0] = 0;
+        restore = <Option<String> as Versionize>::deserialize(&mut snapshot_mem.as_slice(), &vm, 1)
+            .unwrap();
+        assert_ne!(store, restore);
     }
 
     #[test]

tests/integration_tests/build/test_coverage.py

@@ -19,7 +19,7 @@
 
 import host_tools.cargo_build as host  # pylint: disable=import-error
 
-COVERAGE_TARGET_PCT = 82.56
+COVERAGE_TARGET_PCT = 82.60
 COVERAGE_MAX_DELTA = 0.05
 
 CARGO_KCOV_REL_PATH = os.path.join(host.CARGO_BUILD_REL_PATH, 'kcov')