Fixing sequential test.

darleybarreto

Jul 25, 2021, 4:53 PM

K6L5F26WJMIYPP3Y3CBBUYMAK7C5SVR7NYFNU45NGU5NMDCSJJIQC

Dependencies

• [2] HA3ODU4G Fixing compilation
• [3] SZHL3TSD Fixing tests
• [4] HEFGMMUM Start oxidizing 1/N
• [5] IH334Q5A Reboot
• [6] HELRYMZK Manual bindings (Windows and Clang aren't very good friends), and getting rid of anyhow
• [7] IB4L4N5M Fixing the lifetimes for `Seekable`

Change contents

• replacement in src/lib.rs at line 23
  [4.400]→[4.400:489](∅→∅)
  − const MAX_FRAME_DECOMPR_SIZE: u32 = 16;

  − const MAGIC_SKIPPABLE_START: usize = 0x184D2A50;
  [4.400]

  [4.489]
  + const MAX_FRAME_DECOMPR_SIZE: usize = 0x80000000;

  + const MAGIC_SKIPPABLE_START: u32 = 0x184D2A50;
• replacement in src/lib.rs at line 27
  [4.570]→[4.570:619](∅→∅)
  − const SEEKABLE_MAGIC_NUMBER: usize = 0x8F92EAB1;
  [4.570]

  [4.619]
  + const SEEKABLE_MAGIC_NUMBER: u32 = 0x8F92EAB1;
• replacement in src/lib.rs at line 61
  [4.1111]→[4.1111:1136](∅→∅)
  − max_frame_size: u32,
  [4.1111]

  [4.1136]
  + max_frame_size: usize,
• edit in src/lib.rs at line 96
  [4.242190]→[4.242190:242200](∅→∅)
  − Null,
• replacement in src/lib.rs at line 99
  [4.1694]→[4.1694:1719](∅→∅)
  − Other(&'static str),
  [4.1694]

  [4.242248]
  + Null,

  + FIndexTooLarge(usize, usize),

  + Generic,

  + InvalidConversion,

  + FParamUnsupported(usize, usize),

  + PrefixUnknown(u32),

  + Corruption(&'static str),

  + DSizeTooSmall(usize, usize),
• replacement in src/lib.rs at line 112
  [4.242377]→[4.242377:242425](∅→∅),[4.242425]→[4.118:162](∅→∅),[4.162]→[4.242425:242508](∅→∅),[4.242425]→[4.242425:242508](∅→∅)
  − Error::Null => write!(fmt, "Null"),

  − Error::Io(ref e) => e.fmt(fmt),

  − Error::CouldNotOpenFile(ref f) => write!(fmt, "Could not open {}", f),
  [4.242377]

  [4.242508]
  + Error::CouldNotOpenFile(ref f) => write!(fmt, "Could not open file {}.", f),
• replacement in src/lib.rs at line 115
  [4.242613]→[4.242613:242662](∅→∅)
  − write!(fmt, "ZSTD({:?})", error)
  [4.242613]

  [4.242662]
  + write!(fmt, "ZSTD({:?}).", error)
• replacement in src/lib.rs at line 117
  [4.242677]→[4.1810:1867](∅→∅)
  − Error::Other(ref s) => write!(fmt, "{}", s),
  [4.242677]

  [4.242677]
  + Error::Io(ref e) => e.fmt(fmt),

  + Error::Null => write!(fmt, "Null."),

  + Error::FIndexTooLarge(a, b) => write!(

  + fmt,

  + "Frame index too large. Expected at most {}, found {}.",

  + a, b

  + ),

  + Error::Generic => write!(fmt, "Generic error from ZSTD."),

  + Error::InvalidConversion => write!(fmt, "Invalid slice to convert from bytes to u32."),

  + Error::FParamUnsupported(a, b) => write!(

  + fmt,

  + "Frame parameter not supported. Expected at most {}, found {}.",

  + a, b

  + ),

  + Error::PrefixUnknown(p) => write!(fmt, "Prefix unknown {}", p),

  + Error::Corruption(ref s) => write!(fmt, "Corruption detected {}.", s),

  + Error::DSizeTooSmall(a, b) => write!(

  + fmt,

  + "Destination size too small. Expected at least {}, found {}.",

  + b, a

  + ),
• replacement in src/lib.rs at line 202
  [4.2665]→[4.2665:2798](∅→∅)
  − Ok(u32::from_ne_bytes(buff.try_into().map_err(|_| {

  − Error::Other("Invalid slice to convert from bytes to u32")

  − })?))
  [4.2665]

  [4.245043]
  + Ok(u32::from_ne_bytes(

  + buff.try_into().map_err(|_| Error::InvalidConversion)?,

  + ))
• replacement in src/lib.rs at line 209
  [4.245280]→[4.2827:2898](∅→∅)
  − pub fn new(level: usize, frame_size: u32) -> Result<Self, Error> {
  [4.245280]

  [4.2898]
  + pub fn new(level: usize, frame_size: usize) -> Result<Self, Error> {
• replacement in src/lib.rs at line 217
  [4.3082]→[2.0:59](∅→∅)
  − Err(Error::Other("FrameParameterUnsupported"))
  [4.3082]

  [4.3149]
  + Err(Error::FParamUnsupported(frame_size, MAX_FRAME_DECOMPR_SIZE))
• replacement in src/lib.rs at line 225
  [4.3322]→[4.3322:3456](∅→∅),[4.3456]→[4.245644:245707](∅→∅),[4.245644]→[4.245644:245707](∅→∅)
  − let result = unsafe { ZSTD_initCStream(cstream, level as c_int) };

  −

  − if unsafe { ZSTD_isError(result) } != 0 {

  − return Err(Error::ZSTD(result));

  − }
  [4.3322]

  [4.3457]
  + unsafe {

  + let result = ZSTD_initCStream(cstream, level as c_int);

  + if ZSTD_isError(result) != 0 {

  + return Err(Error::ZSTD(result));

  + }

  + };
• replacement in src/lib.rs at line 256
  [4.4168]→[4.4168:4257](∅→∅)
  − let len = cmp::min(input.len() as u32, self.max_frame_size - self.frame_d_size);
  [4.4168]

  [4.4257]
  + let len = cmp::min(

  + input.len(),

  + self.max_frame_size - self.frame_d_size as usize,

  + );
• replacement in src/lib.rs at line 263
  [4.4349]→[4.4349:4390](∅→∅)
  − size: input.len() as size_t,
  [4.4349]

  [4.4390]
  + size: len,
• replacement in src/lib.rs at line 283
  [4.4961]→[4.4961:5068](∅→∅)
  − if self.max_frame_size == self.frame_d_size {

  − let ret = self.end_stream(&mut output)?;
  [4.4961]

  [4.5068]
  + if self.max_frame_size == self.frame_d_size as usize {

  + let ret = self.end_frame(&mut output)?;
• replacement in src/lib.rs at line 294
  [4.5240]→[4.5240:5322](∅→∅)
  − fn end_frame(&mut self, mut output: ZSTD_outBuffer) -> Result<usize, Error> {
  [4.5240]

  [4.5322]
  + fn end_frame(&mut self, output: &mut ZSTD_outBuffer) -> Result<usize, Error> {
• replacement in src/lib.rs at line 296
  [4.5361]→[4.5361:5435](∅→∅)
  − let ret = unsafe { ZSTD_endStream(self.cstream.p, &mut output) };
  [4.5361]

  [4.5435]
  + let ret = unsafe { ZSTD_endStream(self.cstream.p, output) };
• replacement in src/lib.rs at line 326
  [4.246902]→[4.6052:6140](∅→∅)
  − pub fn end_stream(&mut self, output: &mut ZSTD_outBuffer) -> Result<usize, Error> {
  [4.246902]

  [4.6140]
  + pub fn end_stream(&mut self, output: &mut [u8]) -> Result<usize, Error> {

  + let mut output_ = ZSTD_outBuffer {

  + dst: output.as_mut_ptr() as *mut c_void,

  + size: output.len() as size_t,

  + pos: 0,

  + };

  +
• replacement in src/lib.rs at line 334
  [4.6204]→[4.6204:6258](∅→∅)
  − let end_frame = self.end_frame(*output)?;
  [4.6204]

  [4.6258]
  + let end_frame = self.end_frame(&mut output_)?;
• replacement in src/lib.rs at line 338
  [4.6368]→[4.6368:6407](∅→∅)
  − } else if end_frame != 0 {
  [4.6368]

  [4.6407]
  + }

  +

  + if end_frame != 0 {
• replacement in src/lib.rs at line 346
  [4.6521]→[2.60:107](∅→∅)
  − self.framelog.write_seek_table(output)
  [4.6521]

  [4.247408]
  + let result = self.framelog.write_seek_table(&mut output_)?;

  +

  + if unsafe { ZSTD_isError(result) } != 0 {

  + return Err(Error::ZSTD(result));

  + }

  +

  + Ok(output_.pos as usize)
• replacement in src/lib.rs at line 372
  [4.247876]→[4.247876:247925](∅→∅)
  − unsafe { ZSTD_CStreamInSize() as usize }
  [4.247876]

  [4.247925]
  + unsafe { ZSTD_CStreamInSize() }
• replacement in src/lib.rs at line 376
  [4.247965]→[4.247965:248015](∅→∅)
  − unsafe { ZSTD_CStreamOutSize() as usize }
  [4.247965]

  [4.248015]
  + unsafe { ZSTD_CStreamOutSize() }
• replacement in src/lib.rs at line 440
  [4.8080]→[4.8080:8244](∅→∅)
  − let result = unsafe { ZSTD_endStream(self.p, &mut output) };

  − if unsafe { ZSTD_isError(result) } != 0 {

  − return Err(Error::ZSTD(result));
  [4.8080]

  [4.250812]
  +

  + unsafe {

  + let result = ZSTD_endStream(self.p, &mut output);

  + if ZSTD_isError(result) != 0 {

  + return Err(Error::ZSTD(result));

  + }
• edit in src/lib.rs at line 447
  [4.250822]

  [4.8245]
  +
• replacement in src/lib.rs at line 497
  [4.8667]→[4.8667:8756](∅→∅)
  − let _result = unsafe { ZSTD_decompressStream(self.p, &mut output, &mut input) };
  [4.8667]

  [4.8756]
  +

  + unsafe {

  + let _result = ZSTD_decompressStream(self.p, &mut output, &mut input);

  +

  + if ZSTD_isError(_result) != 0 {

  + return Err(Error::ZSTD(_result));

  + }

  + }

  +
• edit in src/lib.rs at line 511
  [4.207]

  [4.207]
  + pub fn init(source: R) -> Result<Self, Error> {

  + let mut seekable = Self::make_seekable(source, ptr::null_mut());

  + seekable.init_advanced()?;

  + Ok(seekable)

  + }

  +
• replacement in src/lib.rs at line 543
  [4.356]→[2.182:229](∅→∅)
  − handle.read_exact(&mut self.in_buff)?;
  [4.356]

  [4.9766]
  + handle.read(&mut self.in_buff)?;
• replacement in src/lib.rs at line 545
  [4.9767]→[4.9767:9904](∅→∅)
  − if slice_to_num(&self.in_buff[5..9])? as usize != SEEKABLE_MAGIC_NUMBER {

  − return Err(Error::Other("PrefixUnknown"));
  [4.9767]

  [4.9904]
  + let prefix = slice_to_num(&self.in_buff[5..9])?;

  + if prefix != SEEKABLE_MAGIC_NUMBER {

  + return Err(Error::PrefixUnknown(prefix));
• replacement in src/lib.rs at line 551
  [4.9976]→[4.9976:10084](∅→∅)
  − if ((checksum_flag >> 2) & 0x1f) == 0 {

  − return Err(Error::Other("CorruptionDetected"));
  [4.9976]

  [4.252727]
  + if ((checksum_flag >> 2) & 0x1f) != 0 {

  + return Err(Error::Corruption("when looking the checksum flag"));
• replacement in src/lib.rs at line 566
  [4.412]→[2.296:343](∅→∅)
  − handle.read_exact(&mut self.in_buff)?;
  [4.412]

  [4.10664]
  + handle.read(&mut self.in_buff)?;

  +
• replacement in src/lib.rs at line 570
  [4.10695]→[4.10695:10839](∅→∅)
  − if slice_to_num(&self.in_buff[..4])? as usize != (MAGIC_SKIPPABLE_START | 0xE) {

  − return Err(Error::Other("PrefixUnknown"));
  [4.10695]

  [4.10839]
  + let mut prefix = slice_to_num(&self.in_buff[..4])?;

  + if prefix != (MAGIC_SKIPPABLE_START | 0xE) {

  + return Err(Error::PrefixUnknown(prefix));
• replacement in src/lib.rs at line 574
  [4.10849]→[4.10849:10999](∅→∅)
  − if slice_to_num(&self.in_buff[4..8])? as usize + SKIPPABLE_HEADER_SIZE != frame_size {

  − return Err(Error::Other("PrefixUnknown"));
  [4.10849]

  [4.10999]
  +

  + prefix = slice_to_num(&self.in_buff[4..8])?;

  + if prefix as usize + SKIPPABLE_HEADER_SIZE != frame_size {

  + return Err(Error::PrefixUnknown(prefix));
• replacement in src/lib.rs at line 588
  [4.11352]→[4.11352:11401](∅→∅)
  − let offset = SEEKABLE_BUFF_SIZE;
  [4.11352]

  [4.11401]
  + let offset = SEEKABLE_BUFF_SIZE - pos;
• replacement in src/lib.rs at line 595
  [4.476]→[4.11696:11774](∅→∅),[4.11696]→[4.11696:11774](∅→∅),[4.11774]→[2.344:487](∅→∅)
  − // FIXME: if pointer arithmetic replace, this needs to change

  − handle.read_exact(unsafe {

  − slice::from_raw_parts_mut(buffer_ptr.add(offset), to_read)

  − })?;
  [4.476]

  [4.11896]
  + // FIXME: if pointer arithmetic were to be replaced, this needs to change

  + handle

  + .read(unsafe { slice::from_raw_parts_mut(buffer_ptr.add(offset), to_read) })?;
• replacement in src/lib.rs at line 602
  [4.11961]→[4.11961:12131](∅→∅)
  − entries[idx].c_offset = c_offset;

  − entries[idx].d_offset = d_offset;

  −

  − c_offset += slice_to_num(&self.in_buff[pos..pos + 4])? as usize;
  [4.11961]

  [4.12131]
  + entries.push(SeekEntry {

  + c_offset,

  + d_offset,

  + checksum: 0,

  + });

  +

  + let a = slice_to_num(&self.in_buff[pos..pos + 4])? as usize;

  + c_offset += a;
• replacement in src/lib.rs at line 621
  [4.253693]→[4.12431:12529](∅→∅)
  − entries[num_frames].c_offset = c_offset;

  − entries[num_frames].d_offset = d_offset;
  [4.253693]

  [4.12529]
  + entries.push(SeekEntry {

  + c_offset,

  + d_offset,

  + checksum: 0,

  + });

  +
• replacement in src/lib.rs at line 639
  [4.12821]→[4.12821:13026](∅→∅)
  − let dstream_init = unsafe { ZSTD_initDStream(self.dstream) };

  − if unsafe { ZSTD_isError(dstream_init) } != 0 {

  − Err(Error::ZSTD(dstream_init))

  − } else {

  − Ok(())
  [4.12821]

  [4.254705]
  + unsafe {

  + let dstream_init = ZSTD_initDStream(self.dstream);

  + if ZSTD_isError(dstream_init) != 0 {

  + return Err(Error::ZSTD(dstream_init));

  + } else {

  + Ok(())

  + }
• replacement in src/lib.rs at line 654
  [4.13365]→[4.13365:13430](∅→∅)
  − return Err(Error::Other("DestinationSizeTooSmall"));
  [4.13365]

  [4.13430]
  + Err(Error::DSizeTooSmall(dest.len(), dec_size))

  + } else {

  + self.decompress(

  + dest,

  + dec_size,

  + self.seek_table.entries[index].d_offset as u64,

  + )
• edit in src/lib.rs at line 662
  [4.13440]→[4.13440:13576](∅→∅)
  −

  − self.decompress(

  − dest,

  − dec_size,

  − self.seek_table.entries[index].d_offset as u64,

  − )
• edit in src/lib.rs at line 671
  [4.13789]→[4.13789:13825](∅→∅)
  − let dst = out.as_mut_ptr();
• replacement in src/lib.rs at line 702
  [4.15103]→[4.15103:15152](∅→∅)
  − dst: dst as *mut c_void,
  [4.15103]

  [4.15152]
  + dst: out.as_mut_ptr() as *mut c_void,
• replacement in src/lib.rs at line 709
  [4.15353]→[4.15353:15615](∅→∅)
  − let mut to_read =

  − unsafe { ZSTD_decompressStream(self.dstream, &mut out_tmp, &mut self.inn) };

  − if unsafe { ZSTD_isError(to_read) } != 0 {

  − return Err(Error::ZSTD(to_read));

  − }
  [4.15353]

  [4.15615]
  + let mut to_read;

  +

  + unsafe {

  + to_read = ZSTD_decompressStream(self.dstream, &mut out_tmp, &mut self.inn);

  +

  + if ZSTD_isError(to_read) != 0 {

  + return Err(Error::ZSTD(to_read));

  + }

  + };
• replacement in src/lib.rs at line 736
  [4.16433]→[4.16433:16505](∅→∅)
  − return Err(Error::Other("CorruptionDetected"));
  [4.16433]

  [4.16505]
  + return Err(Error::Corruption("during decompression"));
• replacement in src/lib.rs at line 749
  [4.552]→[4.16956:16983](∅→∅),[4.16956]→[4.16956:16983](∅→∅),[4.16983]→[2.611:746](∅→∅)
  − handle

  − .read_exact(&mut self.in_buff)

  − .map_err(|_| Error::Other("Not able to read buffer"))?;
  [4.552]

  [4.17111]
  + handle.read(&mut self.in_buff)?;
• replacement in src/lib.rs at line 755
  [4.17227]→[4.17227:17292](∅→∅)
  − if self.decompressed_offset != offset + len as u64 {
  [4.17227]

  [4.17292]
  + if self.decompressed_offset == offset + len as u64 {
• edit in src/lib.rs at line 783
  [4.846]→[4.846:923](∅→∅),[4.923]→[4.18207:18272](∅→∅),[4.18207]→[4.18207:18272](∅→∅),[4.18272]→[4.924:967](∅→∅),[4.967]→[4.18328:18458](∅→∅),[4.18328]→[4.18328:18458](∅→∅),[4.18458]→[4.968:1020](∅→∅)
  − let mut seekable = Seekable::make_seekable(source, ptr::null_mut());

  − seekable.init_advanced()?;

  − Ok(seekable)

  − }

  − }

  −

  − impl<R: io::Read + io::Seek> Seekable<R> {

  − /// Initialise a decompressor with a file. This method opens the file, and dropping the resulting `Seekable` closes the file.

  − pub fn init(source: R) -> Result<Self, Error> {
• edit in src/lib.rs at line 787
  [4.255561]→[4.18692:18803](∅→∅)
  −

  − // TODO: implement this properly

  − // pub fn into_inner(self) -> Box<R> {

  − // *self.src

  − // }
• replacement in src/lib.rs at line 793
  [4.255647]→[4.18860:18898](∅→∅)
  − self.seek_table.entries.len()
  [4.255647]

  [4.255710]
  + self.seek_table.entries.len() - 1
• replacement in src/lib.rs at line 797
  [4.18991]→[4.18991:19093](∅→∅)
  − if frame_index >= self.get_num_frames() {

  − Err(Error::Other("FrameIndexTooLarge"))
  [4.18991]

  [4.19093]
  + let max_frames = self.get_num_frames();

  + if frame_index >= max_frames {

  + Err(Error::FIndexTooLarge(frame_index, max_frames))
• replacement in src/lib.rs at line 806
  [4.19273]→[4.19273:19375](∅→∅)
  − if frame_index >= self.get_num_frames() {

  − Err(Error::Other("FrameIndexTooLarge"))
  [4.19273]

  [4.19375]
  + let max_frames = self.get_num_frames();

  + if frame_index >= max_frames {

  + Err(Error::FIndexTooLarge(frame_index, max_frames))
• replacement in src/lib.rs at line 816
  [4.19627]→[4.19627:19729](∅→∅)
  − if frame_index >= self.get_num_frames() {

  − Err(Error::Other("FrameIndexTooLarge"))
  [4.19627]

  [4.19729]
  + let max_frames = self.get_num_frames();

  + if frame_index >= max_frames {

  + Err(Error::FIndexTooLarge(frame_index, max_frames))
• replacement in src/lib.rs at line 825
  [4.19911]→[4.19911:20012](∅→∅)
  − if frame_index > self.get_num_frames() {

  − Err(Error::Other("FrameIndexTooLarge"))
  [4.19911]

  [4.20012]
  + let max_frames = self.get_num_frames();

  + if frame_index >= max_frames {

  + Err(Error::FIndexTooLarge(frame_index, max_frames))
• replacement in src/lib.rs at line 829
  [4.20029]→[4.20029:20159](∅→∅)
  − Ok(self.seek_table.entries[frame_index + 1].d_offset

  − - self.seek_table.entries[frame_index].d_offset)
  [4.20029]

  [4.257079]
  + let r = self.seek_table.entries[frame_index + 1].d_offset

  + - self.seek_table.entries[frame_index].d_offset;

  + Ok(r)
• replacement in src/lib.rs at line 894
  [4.20938]→[4.20938:20961](∅→∅)
  − ZSTD_compress(
  [4.20938]

  [4.259636]
  + let ret = ZSTD_compress(
• replacement in src/lib.rs at line 900
  [4.259801]→[4.21039:21056](∅→∅)
  − )

  − };
  [4.259801]

  [4.21056]
  + );
• replacement in src/lib.rs at line 902
  [4.21057]→[4.21057:21138](∅→∅),[4.21138]→[4.260079:260085](∅→∅),[4.260079]→[4.260079:260085](∅→∅)
  − if unsafe { ZSTD_isError(ret) } != 0 {

  − return Err(Error::ZSTD(ret));

  − }
  [4.21057]

  [4.21139]
  + if ZSTD_isError(ret) != 0 {

  + return Err(Error::ZSTD(ret));

  + }
• replacement in src/lib.rs at line 906
  [4.21140]→[4.21140:21178](∅→∅)
  − println!("{:?}", dst.as_slice());
  [4.21140]

  [4.21178]
  + ret

  + };
• replacement in src/lib.rs at line 910
  [4.21211]→[4.21211:21212](∅→∅)
  −
  [4.21211]

  [4.21212]
  +
• replacement in src/lib.rs at line 930
  [4.21601]→[4.21601:21715](∅→∅)
  − if self.entries.len() == SEEKABLE_MAXFRAMES {

  − return Err(Error::Other("FrameIndexTooLarge"));
  [4.21601]

  [4.21715]
  + let size = self.entries.len();

  + if size == SEEKABLE_MAXFRAMES {

  + return Err(Error::FIndexTooLarge(size, SEEKABLE_MAXFRAMES as usize));
• replacement in src/lib.rs at line 950
  [4.22109]→[4.22109:22306](∅→∅)
  − pub fn stwrite32(&self, output: &mut ZSTD_outBuffer, value: usize, offset: usize) -> usize {

  − if (self.seek_table_pos as usize) < offset + 4 {

  − let tmp = value.to_ne_bytes();
  [4.22109]

  [4.22306]
  + pub fn stwrite32(&mut self, output: &mut ZSTD_outBuffer, value: u32, offset: u32) -> usize {

  + if self.seek_table_pos < offset + 4 {
• replacement in src/lib.rs at line 954
  [4.22386]→[4.22386:22445](∅→∅)
  − offset + 4 - self.seek_table_pos as usize,
  [4.22386]

  [4.22445]
  + (offset + 4 - self.seek_table_pos) as usize,
• replacement in src/lib.rs at line 959
  [4.22557]→[4.22557:22818](∅→∅)
  − ptr::copy_nonoverlapping(

  − tmp.as_ptr().add(self.seek_table_pos as usize - offset) as *const usize,

  − output.dst.add(output.pos) as *mut usize,

  − len_write,

  − )

  − };
  [4.22557]

  [4.22818]
  + let base = output.dst.add(output.pos) as *mut u8;

  + ptr::copy(value.to_ne_bytes().as_ptr(),base,len_write);

  + }
• edit in src/lib.rs at line 964
  [4.22856]

  [4.22856]
  + self.seek_table_pos += len_write as u32;
• replacement in src/lib.rs at line 1007
  [4.23734]→[4.23734:23810](∅→∅)
  − ret = self.stwrite32(output, table_len - SKIPPABLE_HEADER_SIZE, 4);
  [4.23734]

  [4.23810]
  + ret = self.stwrite32(output, (table_len - SKIPPABLE_HEADER_SIZE) as u32, 4);
• replacement in src/lib.rs at line 1015
  [4.23964]→[4.23964:24030](∅→∅)
  − let start = SKIPPABLE_HEADER_SIZE + size_p_frame * i;
  [4.23964]

  [4.24030]
  + let start = (SKIPPABLE_HEADER_SIZE + size_p_frame * i) as u32;
• replacement in src/lib.rs at line 1018
  [4.24080]→[4.24080:24162](∅→∅)
  − ret = self.stwrite32(output, self.entries[i].c_size as usize, start);
  [4.24080]

  [4.24162]
  + ret = self.stwrite32(output, self.entries[i].c_size, start);
• replacement in src/lib.rs at line 1023
  [4.24236]→[4.24236:24322](∅→∅)
  − ret = self.stwrite32(output, self.entries[i].d_size as usize, start + 4);
  [4.24236]

  [4.24322]
  + ret = self.stwrite32(output, self.entries[i].d_size, start + 4);
• replacement in src/lib.rs at line 1029
  [4.24437]→[4.24437:24529](∅→∅)
  − ret = self.stwrite32(output, self.entries[i].checksum as usize, start + 8);
  [4.24437]

  [4.24529]
  + ret = self.stwrite32(output, self.entries[i].checksum as u32, start + 8);
• replacement in src/lib.rs at line 1043
  [4.24798]→[4.24798:24878](∅→∅)
  − self.entries.len(),

  − table_len - SEEK_TABLE_FOOTER_SIZE,
  [4.24798]

  [4.24878]
  + self.entries.len() as u32,

  + (table_len - SEEK_TABLE_FOOTER_SIZE) as u32,
• replacement in src/lib.rs at line 1053
  [4.25068]→[4.25068:25124](∅→∅)
  − if (self.seek_table_pos as usize) < table_len {
  [4.25068]

  [4.25124]
  + if (self.seek_table_pos as usize) < (table_len - 4) {
• replacement in src/lib.rs at line 1058
  [4.25279]→[4.25279:25334](∅→∅),[4.25334]→[2.839:938](∅→∅),[2.938]→[4.25443:25444](∅→∅),[4.25443]→[4.25443:25444](∅→∅)
  − array

  − .get_mut(output.pos)

  − .map(|el| *el = sfd)

  − .ok_or(Error::Other("index out of bounds"))?;

  −
  [4.25279]

  [4.25444]
  + array[output.pos] = sfd;
• edit in src/lib.rs at line 1060
  [4.25473]

  [4.25473]
  + self.seek_table_pos += 1;
• replacement in src/lib.rs at line 1063
  [4.25484]→[4.25484:25560](∅→∅)
  − ret = self.stwrite32(output, SEEKABLE_MAGIC_NUMBER, table_len - 4);
  [4.25484]

  [4.25560]
  + ret = self.stwrite32(output, SEEKABLE_MAGIC_NUMBER, (table_len - 4) as u32);
• replacement in src/lib.rs at line 1068
  [4.25622]→[4.25622:25734](∅→∅)
  − if self.seek_table_pos as usize != table_len {

  − Err(Error::Other("Generic error from ZSTD"))
  [4.25622]

  [4.25734]
  + if (self.seek_table_pos as usize) != table_len {

  + Err(Error::Generic)
• replacement in src/lib.rs at line 1107
  [4.262356]→[4.262356:262401](∅→∅),[4.262401]→[4.26137:26209](∅→∅)
  − output.write_all(frame.as_slice())?;

  − log.log_frame(frame.src_size, frame.dst_size, frame.checksum)?;
  [4.262356]

  [4.262431]
  + let t = frame.as_slice();

  + output.write_all(t)?;

  + log.log_frame(frame.dst_size, frame.src_size, frame.checksum)?;
• replacement in src/lib.rs at line 1121
  [4.263412]→[3.0:62](∅→∅)
  − let mut s = { Seekable::init_buf(&mut output).unwrap() };
  [4.263412]

  [4.263470]
  + let mut s = Seekable::init_buf(&mut output).unwrap();
• replacement in src/lib.rs at line 1126
  [4.263654]→[3.130:192](∅→∅)
  − s.decompress_frame(&mut decomp[n..], frame).unwrap();
  [4.263654]

  [4.263707]
  + if let Err(_) = s.decompress_frame(&mut decomp[n..], frame) {

  + println!("Error in frame {}", frame);

  + }
• replacement in src/lib.rs at line 1135
  [4.263818]→[4.263818:264957](∅→∅),[4.264957]→[3.255:264](∅→∅),[3.264]→[4.264957:264963](∅→∅),[4.264957]→[4.264957:264963](∅→∅)
  − #[test]

  − fn test() {

  − let mut cstream = SeekableCStream::new(10, 256).unwrap();

  − let input = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut diam ante, sollicitudin a dolor et, volutpat elementum nulla. Etiam nec efficitur nibh, quis rutrum risus. Maecenas quis lorem malesuada, aliquet mi vel, viverra nunc. Donec et nulla sed velit sagittis varius. Suspendisse vestibulum, neque lobortis ornare vestibulum, orci turpis vulputate nisi, ut sodales neque purus eget magna. Nunc condimentum, diam eu consequat venenatis, est nisl semper lorem, et lobortis velit justo sed nulla. Nunc sit amet tempor nunc, vel posuere ipsum. Cras erat tortor, pulvinar ac pretium eu, auctor ac nibh. Duis iaculis porta magna, eu lobortis elit. Duis vitae massa eros. Nulla non magna accumsan, egestas quam sit amet, laoreet lectus.";

  − let mut input_pos = 0;

  − let mut output = vec![0; input.len()];

  − let mut output_pos = 0;

  − while input_pos < input.len() {

  − let (a, b) = cstream

  − .compress(&mut output[output_pos..], &input[input_pos..])

  − .unwrap();

  − output_pos += a;

  − input_pos += b;

  −

  − }
  [4.263818]

  [3.265]
  + // #[test]

  + // fn test() {

  + // let mut cstream = SeekableCStream::new(10, 256).unwrap();

  + // let input = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut diam ante, sollicitudin a dolor et, volutpat elementum nulla. Etiam nec efficitur nibh, quis rutrum risus. Maecenas quis lorem malesuada, aliquet mi vel, viverra nunc. Donec et nulla sed velit sagittis varius. Suspendisse vestibulum, neque lobortis ornare vestibulum, orci turpis vulputate nisi, ut sodales neque purus eget magna. Nunc condimentum, diam eu consequat venenatis, est nisl semper lorem, et lobortis velit justo sed nulla. Nunc sit amet tempor nunc, vel posuere ipsum. Cras erat tortor, pulvinar ac pretium eu, auctor ac nibh. Duis iaculis porta magna, eu lobortis elit. Duis vitae massa eros. Nulla non magna accumsan, egestas quam sit amet, laoreet lectus.";

  + // let mut input_pos = 0;

  + // let mut output = vec![0; input.len()];

  + // let mut output_pos = 0;

  + // while input_pos < input.len() {

  + // let (a, b) = cstream

  + // .compress(&mut output[output_pos..], &input[input_pos..])

  + // .unwrap();

  + // output_pos += a;

  + // input_pos += b;

  + // }

  + // while let Ok(n) = cstream.end_stream(&mut output[output_pos..]) {

  + // if n == 0 {

  + // break;

  + // }

  + // output_pos += n;

  + // }

  + // output.truncate(output_pos);

  + // {

  + // use std::io::Write;

  + // let mut file = std::fs::File::create("test").unwrap();

  + // file.write_all(&output).unwrap();

  + // }

  + // println!("input len = {:?}, pos = {:?}", input.len(), output_pos);
• replacement in src/lib.rs at line 1163
  [3.266]→[3.266:512](∅→∅),[3.512]→[4.265033:265152](∅→∅),[4.265033]→[4.265033:265152](∅→∅),[4.265152]→[4.26267:26348](∅→∅),[4.26348]→[4.265243:265396](∅→∅),[4.265243]→[4.265243:265396](∅→∅),[4.265396]→[3.513:575](∅→∅),[3.575]→[4.265454:265495](∅→∅),[4.265454]→[4.265454:265495](∅→∅),[4.265495]→[3.576:642](∅→∅),[3.642]→[4.265552:265715](∅→∅),[4.265552]→[4.265552:265715](∅→∅),[4.265715]→[3.643:705](∅→∅),[3.705]→[4.265768:265774](∅→∅),[4.265768]→[4.265768:265774](∅→∅),[4.265774]→[3.706:767](∅→∅),[3.767]→[4.265835:265877](∅→∅),[4.26405]→[4.265835:265877](∅→∅),[4.265835]→[4.265835:265877](∅→∅)
  − let mut output_stream = ZSTD_outBuffer {

  − dst: output[output_pos..].as_mut_ptr() as *mut c_void,

  − size: output.len() - output_pos as size_t,

  − pos: 0,

  − };

  −

  − while let Ok(n) = cstream.end_stream(&mut output_stream) {

  − if n == 0 {

  − break;

  − }

  − output_pos += n;

  − }

  − output.truncate(output_pos);

  − {

  − use io::Write;

  − let mut file = fs::File::create("test").unwrap();

  − file.write_all(&output).unwrap();

  − }

  − println!("input len = {:?}, pos = {:?}", input.len(), output_pos);

  −

  − let mut decomp = Vec::new();

  − let mut s = { Seekable::init_buf(&mut output).unwrap() };

  − for frame in 0..s.get_num_frames() {

  − let size = s.get_frame_decompressed_size(frame).unwrap();

  − println!("{:?} {:?}", size, s.get_frame_decompressed_offset(frame));

  − let n = decomp.len();

  − decomp.extend(std::iter::repeat(0).take(size));

  − s.decompress_frame(&mut decomp[n..], frame).unwrap();

  − }

  − println!("{:?}", std::str::from_utf8(&decomp).unwrap());

  − assert_eq!(&input[..], &decomp[..])

  − }
  [3.266]
  + // let mut decomp = Vec::new();

  + // let mut s = { Seekable::init_buf(&mut output).unwrap() };

  + // for frame in 0..s.get_num_frames() {

  + // let size = s.get_frame_decompressed_size(frame).unwrap();

  + // println!("{:?} {:?}", size, s.get_frame_decompressed_offset(frame).unwrap());

  + // let n = decomp.len();

  + // decomp.extend(std::iter::repeat(0).take(size));

  + // s.decompress_frame(&mut decomp[n..], frame).unwrap();

  + // }

  + // println!("{:?}", std::str::from_utf8(&decomp).unwrap());

  + // assert_eq!(&input[..], &decomp[..])

  + // }