[thin_shrink] add some more test cases

src/shrink/copier.rs

@@ -20,7 +20,7 @@ where
 {
     let mut buf = vec![0; len];
     file.seek(SeekFrom::Start(src_byte))?;
-    file.read_exact(&mut buf[0..])?;
+    file.read_exact(&mut buf)?;
     file.seek(SeekFrom::Start(dest_byte))?;
     file.write_all(&buf)?;
     Ok(())
@@ -55,6 +55,7 @@ pub fn copy(path: &Path, regions: &[Region]) -> Result<()> {
         eprintln!("copying {:?}", r);
         copy_region(&mut input, r)?;
     }
+    input.flush()?;
 
     Ok(())
 }

tests/thin_shrink.rs

@@ -1,4 +1,4 @@
-use anyhow::Result;
+use anyhow::{anyhow, Result};
 use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
 use rand::Rng;
 use std::fs::OpenOptions;
@@ -11,6 +11,7 @@ use thinp::thin::xml::{self, Visit};
 
 //------------------------------------
 
+#[derive(Debug)]
 struct ThinBlock {
     thin_id: u32,
     thin_block: u64,
@@ -33,35 +34,36 @@ impl ThinBlock {
         let mut rr = ThinReadRef {
             data: vec![0; self.block_size],
         };
-        r.seek(SeekFrom::Start(self.data_block * (self.block_size as u64)))?;
+        let byte = self.data_block * (self.block_size as u64) * 512;
-        r.read_exact(&mut rr.data[0..])?;
+        r.seek(SeekFrom::Start(byte))?;
+        r.read_exact(&mut rr.data)?;
         Ok(rr)
     }
 
     fn zero_ref<'a, W: Write + Seek>(&self, w: &'a mut W) -> ThinWriteRef<'a, W> {
         ThinWriteRef {
             file: w,
-            block_byte: self.data_block * (self.block_size as u64),
+            block_byte: self.data_block * (self.block_size as u64) * 512,
             data: vec![0; self.block_size],
         }
     }
 
-    fn write_ref<'a, W>(&self, w: &'a mut W) -> Result<ThinWriteRef<'a, W>>
+    //fn write_ref<'a, W>(&self, w: &'a mut W) -> Result<ThinWriteRef<'a, W>>
-    where
+    //where
-        W: Read + Write + Seek,
+    //W: Read + Write + Seek,
-    {
+    //{
-        let mut data = vec![0; self.block_size];
+    //let mut data = vec![0; self.block_size];
-        w.seek(SeekFrom::Start(self.data_block * (self.block_size as u64)))?;
+    //w.seek(SeekFrom::Start(self.data_block * (self.block_size as u64)))?;
-        w.read_exact(&mut data[0..])?;
+    //w.read_exact(&mut data[0..])?;
-
+    //
-        let wr = ThinWriteRef {
+    //let wr = ThinWriteRef {
-            file: w,
+    //file: w,
-            block_byte: self.data_block * (self.block_size as u64),
+    //block_byte: self.data_block * (self.block_size as u64),
-            data: vec![0; self.block_size],
+    //data: vec![0; self.block_size],
-        };
+    //};
-
+    //
-        Ok(wr)
+    //Ok(wr)
-    }
+    //}
 }
 
 impl<'a, W: Write + Seek> Drop for ThinWriteRef<'a, W> {
@@ -70,7 +72,7 @@ impl<'a, W: Write + Seek> Drop for ThinWriteRef<'a, W> {
         // errors will have to make their way back to the user
         // another way (eg, via a flush() method).
         self.file.seek(SeekFrom::Start(self.block_byte)).unwrap();
-        self.file.write_all(&self.data[0..]).unwrap();
+        self.file.write_all(&self.data).unwrap();
     }
 }
 
@@ -161,34 +163,41 @@ impl Generator {
     }
 
     fn step(&mut self) {
-        self.x = (self.a * self.x) + self.c
+        self.x = self.a.wrapping_mul(self.x).wrapping_add(self.c)
     }
 
-    fn fill_buffer(&mut self, seed: u64, bytes: &mut [u8]) {
+    fn fill_buffer(&mut self, seed: u64, bytes: &mut [u8]) -> Result<()> {
         self.x = seed;
 
-        assert!(bytes.len() % 8 == 64);
+        assert!(bytes.len() % 8 == 0);
         let nr_words = bytes.len() / 8;
         let mut out = Cursor::new(bytes);
 
         for _ in 0..nr_words {
-            out.write_u64::<LittleEndian>(self.x).unwrap();
+            out.write_u64::<LittleEndian>(self.x)?;
             self.step();
         }
+
+        Ok(())
     }
 
-    fn verify_buffer(&mut self, seed: u64, bytes: &[u8]) {
+    fn verify_buffer(&mut self, seed: u64, bytes: &[u8]) -> Result<bool> {
         self.x = seed;
 
-        assert!(bytes.len() % 8 == 64);
+        assert!(bytes.len() % 8 == 0);
         let nr_words = bytes.len() / 8;
         let mut input = Cursor::new(bytes);
 
         for _ in 0..nr_words {
-            let w = input.read_u64::<LittleEndian>().unwrap();
+            let w = input.read_u64::<LittleEndian>()?;
-            assert_eq!(w, self.x);
+            if w != self.x {
+                eprintln!("{} != {}", w, self.x);
+                return Ok(false);
+            }
             self.step();
         }
+
+        Ok(true)
     }
 }
 
@@ -212,7 +221,7 @@ impl<'a, W: Write + Seek> ThinVisitor for Stamper<'a, W> {
         gen.fill_buffer(
             self.seed ^ (b.thin_id as u64) ^ b.thin_block,
             &mut wr.data[0..],
-        );
+        )?;
         Ok(())
     }
 }
@@ -234,7 +243,9 @@ impl<'a, R: Read + Seek> ThinVisitor for Verifier<'a, R> {
     fn thin_block(&mut self, b: &ThinBlock) -> Result<()> {
         let rr = b.read_ref(self.data_file)?;
         let mut gen = Generator::new();
-        gen.verify_buffer(self.seed ^ (b.thin_id as u64) ^ b.thin_block, &rr.data[0..]);
+        if !gen.verify_buffer(self.seed ^ (b.thin_id as u64) ^ b.thin_block, &rr.data[0..])? {
+            return Err(anyhow!("data verify failed for {:?}", b));
+        }
         Ok(())
     }
 }
@@ -248,10 +259,7 @@ fn mk_path(dir: &Path, file: &str) -> PathBuf {
     p
 }
 
-fn generate_xml<G>(path: &Path, g: &mut G) -> Result<()>
+fn generate_xml(path: &Path, g: &mut dyn Scenario) -> Result<()> {
-where
-    G: XmlGenerator,
-{
     let xml_out = OpenOptions::new()
         .read(false)
         .write(true)
@@ -260,7 +268,7 @@ where
         .open(path)?;
     let mut w = xml::XmlWriter::new(xml_out);
 
-    g.generate(&mut w)
+    g.generate_xml(&mut w)
 }
 
 fn create_data_file(data_path: &Path, xml_path: &Path) -> Result<()> {
@@ -296,50 +304,135 @@ fn verify(xml_path: &Path, data_path: &Path, seed: u64) -> Result<()> {
     thin_visit(xml, &mut verifier)
 }
 
-//------------------------------------
+trait Scenario {
-
+    fn generate_xml(&mut self, v: &mut dyn xml::MetadataVisitor) -> Result<()>;
-trait XmlGenerator {
+    fn get_new_nr_blocks(&self) -> u64;
-    fn generate(&mut self, v: &mut dyn xml::MetadataVisitor) -> Result<()>;
 }
 
-struct EmptyPoolG {}
+fn test_shrink(scenario: &mut dyn Scenario) -> Result<()> {
-
-impl XmlGenerator for EmptyPoolG {
-    fn generate(&mut self, v: &mut dyn xml::MetadataVisitor) -> Result<()> {
-        v.superblock_b(&xml::Superblock {
-            uuid: "".to_string(),
-            time: 0,
-            transaction: 0,
-            flags: None,
-            version: None,
-            data_block_size: 64,
-            nr_data_blocks: 1024,
-            metadata_snap: None,
-        })?;
-        v.superblock_e()?;
-        Ok(())
-    }
-}
-
-#[test]
-fn shrink_empty_pool() -> Result<()> {
     let dir = tempdir()?;
     let xml_before = mk_path(dir.path(), "before.xml");
     let xml_after = mk_path(dir.path(), "after.xml");
-    let data_path = mk_path(dir.path(), "bin");
+    let data_path = mk_path(dir.path(), "metadata.bin");
 
-    let mut gen = EmptyPoolG {};
+    generate_xml(&xml_before, scenario)?;
-    generate_xml(&xml_before, &mut gen)?;
     create_data_file(&data_path, &xml_before)?;
 
     let mut rng = rand::thread_rng();
     let seed = rng.gen::<u64>();
 
     stamp(&xml_before, &data_path, seed)?;
-
+    
-    let new_nr_blocks = 10;
+    let new_nr_blocks = scenario.get_new_nr_blocks();
     thinp::shrink::toplevel::shrink(&xml_before, &xml_after, &data_path, new_nr_blocks, true)?;
 
     verify(&xml_after, &data_path, seed)?;
     Ok(())
 }
+
+//------------------------------------
+
+fn common_sb(nr_blocks: u64) -> xml::Superblock {
+    xml::Superblock {
+        uuid: "".to_string(),
+        time: 0,
+        transaction: 0,
+        flags: None,
+        version: None,
+        data_block_size: 32,
+        nr_data_blocks: nr_blocks,
+        metadata_snap: None,
+    }
+}
+
+struct EmptyPoolS {}
+
+impl Scenario for EmptyPoolS {
+    fn generate_xml(&mut self, v: &mut dyn xml::MetadataVisitor) -> Result<()> {
+        v.superblock_b(&common_sb(1024))?;
+        v.superblock_e()?;
+        Ok(())
+    }
+
+    fn get_new_nr_blocks(&self) -> u64 {
+        512
+    }
+}
+
+#[test]
+fn shrink_empty_pool() -> Result<()> {
+    let mut s = EmptyPoolS {};
+    test_shrink(&mut s)
+}
+
+//------------------------------------
+
+struct SingleThinS {
+    offset: u64,
+    len: u64,
+    old_nr_data_blocks: u64,
+    new_nr_data_blocks: u64,
+}
+
+impl SingleThinS {
+    fn new(offset: u64, len: u64, old_nr_data_blocks: u64, new_nr_data_blocks: u64) -> Self {
+        SingleThinS {
+            offset,
+            len,
+            old_nr_data_blocks,
+            new_nr_data_blocks,
+        }
+    }
+}
+
+impl Scenario for SingleThinS {
+    fn generate_xml(&mut self, v: &mut dyn xml::MetadataVisitor) -> Result<()> {
+        v.superblock_b(&common_sb(self.old_nr_data_blocks))?;
+        v.device_b(&xml::Device {
+            dev_id: 0,
+            mapped_blocks: self.len,
+            transaction: 0,
+            creation_time: 0,
+            snap_time: 0,
+        })?;
+        v.map(&xml::Map {
+            thin_begin: 0,
+            data_begin: self.offset,
+            time: 0,
+            len: self.len,
+        })?;
+        v.device_e()?;
+        v.superblock_e()?;
+        Ok(())
+    }
+
+    fn get_new_nr_blocks(&self) -> u64 {
+        self.new_nr_data_blocks
+    }
+}
+
+#[test]
+fn shrink_single_no_move_1() -> Result<()> {
+    let mut s = SingleThinS::new(0, 1024, 2048, 1280);
+    test_shrink(&mut s)
+}
+
+#[test]
+fn shrink_single_no_move_2() -> Result<()> {
+    let mut s = SingleThinS::new(100, 1024, 2048, 1280);
+    test_shrink(&mut s)
+}
+
+#[test]
+fn shrink_single_no_move_3() -> Result<()> {
+    let mut s = SingleThinS::new(1024, 1024, 2048, 2048);
+    test_shrink(&mut s)
+}
+
+#[test]
+fn shrink_single_partial_move() -> Result<()> {
+    let mut s = SingleThinS::new(1024, 1024, 2048, 1280);
+    test_shrink(&mut s)
+}
+
+//------------------------------------