storage: add some unit test cases

storage/src/device.rs

@@ -1398,6 +1398,8 @@ pub mod v5 {
 
 #[cfg(test)]
 mod tests {
+    use std::path::PathBuf;
+
     use super::*;
     use crate::test::MockChunkInfo;
 
@@ -1611,4 +1613,32 @@ mod tests {
         assert_eq!(size, iovec.size());
         assert_eq!(chunk_count, iovec.len() as u32);
     }
+
+    #[test]
+    fn test_blob_info_blob_meta_id() {
+        let blob_info = BlobInfo::new(
+            1,
+            "blob_id".to_owned(),
+            0,
+            0,
+            0,
+            1,
+            BlobFeatures::SEPARATE | BlobFeatures::INLINED_FS_META,
+        );
+
+        let root_dir = &std::env::var("CARGO_MANIFEST_DIR").expect("$CARGO_MANIFEST_DIR");
+        let mut source_path = PathBuf::from(root_dir);
+        source_path.push("../tests/texture/blobs/be7d77eeb719f70884758d1aa800ed0fb09d701aaec469964e9d54325f0d5fef");
+
+        assert!(blob_info
+            .set_blob_id_from_meta_path(source_path.as_path())
+            .is_ok());
+
+        let id = blob_info.get_blob_meta_id();
+        assert!(id.is_ok());
+        assert_eq!(
+            id.unwrap(),
+            "be7d77eeb719f70884758d1aa800ed0fb09d701aaec469964e9d54325f0d5fef".to_owned()
+        );
+    }
 }

storage/src/meta/batch.rs

@@ -153,3 +153,62 @@ impl BatchContextGenerator {
         Ok((data, self.contexts.len() as u32))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_batch_inflate_context() {
+        let mut ctx = BatchInflateContext {
+            compressed_offset: 0,
+            compressed_size: 0,
+            uncompressed_batch_size: 0,
+            __reserved1: 0,
+            __reserved2: 0,
+            __reserved3: 0,
+        };
+        ctx.set_compressed_offset(0x10);
+        assert_eq!(ctx.compressed_offset(), 0x10);
+        ctx.set_compressed_size(0x20);
+        assert_eq!(ctx.compressed_size(), 0x20);
+        assert_eq!(ctx.compressed_end(), 0x30);
+        let mut v = [0u8; 40];
+        v[0] = 0x10;
+        v[8] = 0x20;
+        assert_eq!(ctx.as_slice(), v);
+    }
+
+    #[test]
+    fn test_batch_context_generator() {
+        let mut generator = BatchContextGenerator {
+            chunk_data_buf: vec![1u8, 2, 3, 4, 5],
+            contexts: vec![],
+        };
+        assert!(!generator.chunk_data_buf_is_empty());
+        let data = [6u8, 7, 8, 9];
+        generator.append_chunk_data_buf(&data);
+        assert_eq!(
+            generator.chunk_data_buf_len(),
+            generator.chunk_data_buf().len()
+        );
+
+        generator.add_context(0x10, 0x20);
+        assert_eq!(generator.contexts.len(), 1);
+
+        let mut data = vec![0u8; 40];
+        data[0] = 0x10;
+        data[8] = 0x20;
+        data[12] = 9;
+        assert_eq!(generator.to_vec().unwrap(), (data, 1 as u32));
+
+        let ctx = BatchContextGenerator::new(8);
+        assert!(ctx.is_ok());
+        assert_eq!(ctx.unwrap().chunk_data_buf().capacity(), 8);
+
+        assert!(generator.generate_chunk_info(0, 2, true).is_ok());
+
+        generator.clear_chunk_data_buf();
+        assert_eq!(generator.chunk_data_buf_len(), 0);
+    }
+}

storage/src/meta/chunk_info_v2.rs

@@ -306,6 +306,36 @@ mod tests {
         chunk.set_zran_offset(5);
         assert_eq!(chunk.get_zran_index(), 3);
         assert_eq!(chunk.get_zran_offset(), 5);
+        chunk.set_zran(false);
+        assert!(!chunk.is_zran());
+
+        let before = chunk.uncomp_info;
+        chunk.set_compressed(true);
+        chunk.set_compressed(false);
+        assert_eq!(chunk.uncomp_info as u64, before);
+
+        chunk.set_encrypted(true);
+        assert!(chunk.is_encrypted());
+
+        let before = chunk.uncomp_info;
+        chunk.set_batch(true);
+        chunk.set_batch(false);
+        assert_eq!(chunk.uncomp_info as u64, before);
+
+        chunk.set_data(0x10);
+        assert_eq!(chunk.data as u64, 0x10);
+
+        chunk.set_batch(true);
+        chunk.set_batch_index(0x20);
+        assert_eq!(chunk.data as u64, 137438953488);
+
+        chunk.set_uncompressed_offset_in_batch_buf(0x30);
+        assert_eq!(chunk.data as u64, 137438953520);
+
+        assert_eq!(chunk.flags(), 12);
+        assert_eq!(chunk.get_batch_index(), 32);
+        assert_eq!(chunk.get_uncompressed_offset_in_batch_buf(), 48);
+        assert_eq!(chunk.get_data(), 137438953520);
 
         // For testing old format compatibility.
         let chunk = BlobChunkInfoV2Ondisk {
@@ -380,4 +410,33 @@ mod tests {
             .get_chunk_index_nocheck(&state, 0x102000, false)
             .unwrap_err();
     }
+
+    #[test]
+    fn test_chunk_on_disk_validate() {
+        let mut ctx = BlobCompressionContext::default();
+        let mut chunk = BlobChunkInfoV2Ondisk::default();
+        println!("{}", chunk);
+
+        chunk.set_compressed_offset(0x10);
+        chunk.set_compressed_size(0x20);
+        chunk.set_encrypted(false);
+        chunk.set_compressed(false);
+        chunk.set_uncompressed_size(0x30);
+        chunk.set_compressed_size(0x40);
+        chunk.set_zran(true);
+        ctx.compressed_size = 0x100;
+        ctx.uncompressed_size = 0x40;
+        ctx.blob_features = 0;
+        assert!(chunk.validate(&ctx).is_err());
+
+        chunk.set_encrypted(true);
+        assert!(chunk.validate(&ctx).is_err());
+
+        ctx.blob_features = BlobFeatures::ZRAN.bits();
+        chunk.set_zran_index(0);
+        assert!(chunk.validate(&ctx).is_err());
+
+        chunk.set_zran(false);
+        assert!(chunk.validate(&ctx).is_ok());
+    }
 }

storage/src/meta/mod.rs

@@ -1997,6 +1997,7 @@ pub(crate) mod tests {
     use crate::device::BlobFeatures;
     use crate::RAFS_DEFAULT_CHUNK_SIZE;
     use nix::sys::uio;
+    use nydus_utils::digest::{self, DigestHasher};
     use nydus_utils::metrics::BackendMetrics;
     use std::fs::File;
     use std::os::unix::io::AsRawFd;
@@ -2202,4 +2203,110 @@ pub(crate) mod tests {
             .get_chunks_compressed(0x1000000, 0x1, RAFS_DEFAULT_CHUNK_SIZE, false)
             .is_err());
     }
+
+    #[test]
+    fn test_blob_compression_context_header_getters_and_setters() {
+        let mut header = BlobCompressionContextHeader::default();
+
+        assert_eq!(header.features(), 0);
+        header.set_aligned(true);
+        assert!(header.is_4k_aligned());
+        header.set_aligned(false);
+
+        header.set_inlined_fs_meta(true);
+        assert!(header.has_feature(BlobFeatures::INLINED_FS_META));
+        header.set_inlined_fs_meta(false);
+
+        header.set_chunk_info_v2(true);
+        assert!(header.has_feature(BlobFeatures::CHUNK_INFO_V2));
+        header.set_chunk_info_v2(false);
+
+        header.set_ci_zran(true);
+        assert!(header.has_feature(BlobFeatures::ZRAN));
+        header.set_ci_zran(false);
+
+        header.set_separate_blob(true);
+        assert!(header.has_feature(BlobFeatures::SEPARATE));
+        header.set_separate_blob(false);
+
+        header.set_ci_batch(true);
+        assert!(header.has_feature(BlobFeatures::BATCH));
+        header.set_ci_batch(false);
+
+        header.set_inlined_chunk_digest(true);
+        assert!(header.has_feature(BlobFeatures::INLINED_CHUNK_DIGEST));
+        header.set_inlined_chunk_digest(false);
+
+        header.set_has_tar_header(true);
+        assert!(header.has_feature(BlobFeatures::HAS_TAR_HEADER));
+        header.set_has_tar_header(false);
+
+        header.set_has_toc(true);
+        assert!(header.has_feature(BlobFeatures::HAS_TOC));
+        header.set_has_toc(false);
+
+        header.set_cap_tar_toc(true);
+        assert!(header.has_feature(BlobFeatures::CAP_TAR_TOC));
+        header.set_cap_tar_toc(false);
+
+        header.set_tarfs(true);
+        assert!(header.has_feature(BlobFeatures::TARFS));
+        header.set_tarfs(false);
+
+        header.set_encrypted(true);
+        assert!(header.has_feature(BlobFeatures::ENCRYPTED));
+        header.set_encrypted(false);
+
+        assert_eq!(header.features(), 0);
+
+        assert_eq!(header.ci_compressor(), compress::Algorithm::Lz4Block);
+        header.set_ci_compressor(compress::Algorithm::GZip);
+        assert_eq!(header.ci_compressor(), compress::Algorithm::GZip);
+        header.set_ci_compressor(compress::Algorithm::Zstd);
+        assert_eq!(header.ci_compressor(), compress::Algorithm::Zstd);
+
+        let mut hasher = RafsDigest::hasher(digest::Algorithm::Sha256);
+        hasher.digest_update(header.as_bytes());
+        let hash: String = hasher.digest_finalize().into();
+        assert_eq!(
+            hash,
+            String::from("f56a1129d3df9fc7d60b26dbf495a60bda3dfc265f4f37854e4a36b826b660fc")
+        );
+
+        assert_eq!(header.ci_entries(), 0);
+        header.set_ci_entries(1);
+        assert_eq!(header.ci_entries(), 1);
+
+        assert_eq!(header.ci_compressed_offset(), 0);
+        header.set_ci_compressed_offset(1);
+        assert_eq!(header.ci_compressed_offset(), 1);
+
+        assert_eq!(header.ci_compressed_size(), 0);
+        header.set_ci_compressed_size(1);
+        assert_eq!(header.ci_compressed_size(), 1);
+
+        assert_eq!(header.ci_uncompressed_size(), 0);
+        header.set_ci_uncompressed_size(1);
+        assert_eq!(header.ci_uncompressed_size(), 1);
+
+        assert_eq!(header.ci_zran_count(), 0);
+        header.set_ci_zran_count(1);
+        assert_eq!(header.ci_zran_count(), 1);
+
+        assert_eq!(header.ci_zran_offset(), 0);
+        header.set_ci_zran_offset(1);
+        assert_eq!(header.ci_zran_offset(), 1);
+
+        assert_eq!(header.ci_zran_size(), 0);
+        header.set_ci_zran_size(1);
+        assert_eq!(header.ci_zran_size(), 1);
+    }
+
+    #[test]
+    fn test_format_blob_features() {
+        let features = !BlobFeatures::default();
+        let content = format_blob_features(features);
+        assert!(content.contains("aligned"));
+        assert!(content.contains("fs-meta"));
+    }
 }