All test passing. Using absolute offset to read positions.

src/positions/mod.rs

@@ -37,9 +37,9 @@ const LONG_SKIP_INTERVAL: u64 = (LONG_SKIP_IN_BLOCKS * COMPRESSION_BLOCK_SIZE) a
 #[cfg(test)]
 pub mod tests {
 
-    use super::{PositionReader, PositionSerializer};
+    use super::PositionSerializer;
     use crate::directory::ReadOnlySource;
-    use crate::positions::reader::PositionReaderAbsolute;
+    use crate::positions::reader::PositionReader;
     use std::iter;
 
     fn create_stream_buffer(vals: &[u32]) -> (ReadOnlySource, ReadOnlySource) {
@@ -66,22 +66,6 @@ pub mod tests {
         assert_eq!(skip.len(), 12);
         assert_eq!(stream.len(), 1168);
         let mut position_reader = PositionReader::new(stream, skip, 0u64);
-        for &n in &[1, 10, 127, 128, 130, 312] {
-            let mut v = vec![0u32; n];
-            position_reader.read(&mut v[..n]);
-            for i in 0..n {
-                assert_eq!(v[i], i as u32);
-            }
-        }
-    }
-
-    #[test]
-    fn test_position_absolute_read() {
-        let v: Vec<u32> = (0..1000).collect();
-        let (stream, skip) = create_stream_buffer(&v[..]);
-        assert_eq!(skip.len(), 12);
-        assert_eq!(stream.len(), 1168);
-        let mut position_reader = PositionReaderAbsolute::new(stream, skip, 0u64);
         for &n in &[1, 10, 127, 128, 130, 312] {
             let mut v = vec![0u32; n];
             position_reader.read(0, &mut v[..]);
@@ -92,12 +76,12 @@ pub mod tests {
     }
 
     #[test]
-    fn test_position_absolute_read_with_offset() {
+    fn test_position_read_with_offset() {
         let v: Vec<u32> = (0..1000).collect();
         let (stream, skip) = create_stream_buffer(&v[..]);
         assert_eq!(skip.len(), 12);
         assert_eq!(stream.len(), 1168);
-        let mut position_reader = PositionReaderAbsolute::new(stream, skip, 0u64);
+        let mut position_reader = PositionReader::new(stream, skip, 0u64);
         for &offset in &[1u64, 10u64, 127u64, 128u64, 130u64, 312u64] {
             for &len in &[1, 10, 130, 500] {
                 let mut v = vec![0u32; len];
@@ -119,50 +103,69 @@ pub mod tests {
         let mut position_reader = PositionReader::new(stream, skip, 0u64);
         let mut buf = [0u32; 7];
         let mut c = 0;
+
+        let mut offset = 0;
         for _ in 0..100 {
-            position_reader.read(&mut buf);
-            position_reader.read(&mut buf);
-            position_reader.skip(4);
-            position_reader.skip(3);
+            position_reader.read(offset, &mut buf);
+            position_reader.read(offset, &mut buf);
+            offset += 7;
             for &el in &buf {
                 assert_eq!(c, el);
                 c += 1;
             }
         }
     }
 
-
-
     #[test]
-    fn test_position_absolute_reread_anchor_different_than_block() {
+    fn test_position_reread_anchor_different_than_block() {
         let v: Vec<u32> = (0..2_000_000).collect();
         let (stream, skip) = create_stream_buffer(&v[..]);
         assert_eq!(skip.len(), 15_749);
         assert_eq!(stream.len(), 4_987_872);
-       let mut position_reader =
-           PositionReaderAbsolute::new(stream.clone(), skip.clone(), 0);
-       let mut buf = [0u32; 256];
-       position_reader.read(128, &mut buf);
-        for  i in 0..256 {
+        let mut position_reader = PositionReader::new(stream.clone(), skip.clone(), 0);
+        let mut buf = [0u32; 256];
+        position_reader.read(128, &mut buf);
+        for i in 0..256 {
             assert_eq!(buf[i], (128 + i) as u32);
         }
-       position_reader.read(128, &mut buf);
-        for  i in 0..256 {
+        position_reader.read(128, &mut buf);
+        for i in 0..256 {
             assert_eq!(buf[i], (128 + i) as u32);
         }
     }
 
     #[test]
     #[should_panic(expected = "offset arguments should be increasing.")]
-    fn test_position_absolute_panic_if_called_previous_anchor() {
+    fn test_position_panic_if_called_previous_anchor() {
         let v: Vec<u32> = (0..2_000_000).collect();
         let (stream, skip) = create_stream_buffer(&v[..]);
         assert_eq!(skip.len(), 15_749);
         assert_eq!(stream.len(), 4_987_872);
         let mut buf = [0u32; 1];
-        let mut position_reader =
-            PositionReaderAbsolute::new(stream.clone(), skip.clone(), 200_000);
-        position_reader.read(10, &mut buf);
+        let mut position_reader = PositionReader::new(stream.clone(), skip.clone(), 200_000);
+        position_reader.read(230, &mut buf);
+        position_reader.read(9, &mut buf);
+    }
+
+    #[test]
+    fn test_positions_bug() {
+        let mut v: Vec<u32> = vec![];
+        for i in 1..200 {
+            for j in 0..i {
+                v.push(j);
+            }
+        }
+        let (stream, skip) = create_stream_buffer(&v[..]);
+        let mut buf = Vec::new();
+        let mut position_reader = PositionReader::new(stream.clone(), skip.clone(), 0);
+        let mut offset = 0;
+        for i in 1..24 {
+            buf.resize(i, 0);
+            position_reader.read(offset, &mut buf[..]);
+            offset += i as u64;
+            let r: Vec<u32> = (0..i).map(|el| el as u32).collect();
+            assert_eq!(buf, &r[..]);
+        }
     }
 
     #[test]
@@ -174,7 +177,7 @@ pub mod tests {
         assert_eq!(stream.len(), 1_000_000);
         let mut position_reader = PositionReader::new(stream, skip, 128 * 1024);
         let mut buf = [0u32; 1];
-        position_reader.read(&mut buf);
+        position_reader.read(0, &mut buf);
         assert_eq!(buf[0], CONST_VAL);
     }
 
@@ -193,7 +196,7 @@ pub mod tests {
         ] {
             let mut position_reader = PositionReader::new(stream.clone(), skip.clone(), offset);
             let mut buf = [0u32; 1];
-            position_reader.read(&mut buf);
+            position_reader.read(0, &mut buf);
             assert_eq!(buf[0], offset as u32);
         }
     }