Merge branch 'master' into feature/end-to-end-tests-only

src/compression.rs

@@ -9,7 +9,7 @@ use std::fmt;
 /// contents to be read without context.
 ///
 /// When creating ZIP files, you may choose the method to use with
-/// [`zip::write::FileOptions::compression_method`]
+/// [`crate::write::FileOptions::compression_method`]
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum CompressionMethod {
     /// Store the file as is
@@ -157,7 +157,7 @@ mod test {
 
     #[test]
     fn from_eq_to() {
-        for v in 0..(::std::u16::MAX as u32 + 1) {
+        for v in 0..(u16::MAX as u32 + 1) {
             #[allow(deprecated)]
             let from = CompressionMethod::from_u16(v as u16);
             #[allow(deprecated)]
@@ -167,20 +167,19 @@ mod test {
     }
 
     fn methods() -> Vec<CompressionMethod> {
-        let mut methods = Vec::new();
+        vec![
-        methods.push(CompressionMethod::Stored);
+            CompressionMethod::Stored,
-        #[cfg(any(
+            #[cfg(any(
-            feature = "deflate",
+                feature = "deflate",
-            feature = "deflate-miniz",
+                feature = "deflate-miniz",
-            feature = "deflate-zlib"
+                feature = "deflate-zlib"
-        ))]
+            ))]
-        methods.push(CompressionMethod::Deflated);
+            CompressionMethod::Deflated,
-        #[cfg(feature = "bzip2")]
+            #[cfg(feature = "bzip2")]
-        methods.push(CompressionMethod::Bzip2);
+            CompressionMethod::Bzip2,
-        #[cfg(feature = "zstd")]
+            #[cfg(feature = "zstd")]
-        methods.push(CompressionMethod::Zstd);
+            CompressionMethod::Zstd,
-
+        ]
-        methods
     }
 
     #[test]

src/cp437.rs

@@ -6,7 +6,8 @@ pub trait FromCp437 {
     type Target;
 
     /// Function that does the conversion from cp437.
-    /// Gennerally allocations will be avoided if all data falls into the ASCII range.
+    /// Generally allocations will be avoided if all data falls into the ASCII range.
+    #[allow(clippy::wrong_self_convention)]
     fn from_cp437(self) -> Self::Target;
 }
 

src/read.rs

@@ -198,11 +198,11 @@ fn make_crypto_reader<'a>(
     Ok(Ok(reader))
 }
 
-fn make_reader<'a>(
+fn make_reader(
     compression_method: CompressionMethod,
     crc32: u32,
-    reader: CryptoReader<'a>,
+    reader: CryptoReader,
-) -> ZipFileReader<'a> {
+) -> ZipFileReader {
     match compression_method {
         CompressionMethod::Stored => ZipFileReader::Stored(Crc32Reader::new(reader, crc32)),
         #[cfg(any(
@@ -317,7 +317,7 @@ impl<R: Read + io::Seek> ZipArchive<R> {
                 let directory_start = footer
                     .central_directory_offset
                     .checked_add(archive_offset)
-                    .ok_or_else(|| {
+                    .ok_or({
                         ZipError::InvalidArchive("Invalid central directory size or offset")
                     })?;
 
@@ -346,7 +346,7 @@ impl<R: Read + io::Seek> ZipArchive<R> {
         let mut files = Vec::new();
         let mut names_map = HashMap::new();
 
-        if let Err(_) = reader.seek(io::SeekFrom::Start(directory_start)) {
+        if reader.seek(io::SeekFrom::Start(directory_start)).is_err() {
             return Err(ZipError::InvalidArchive(
                 "Could not seek to start of central directory",
             ));
@@ -471,14 +471,14 @@ impl<R: Read + io::Seek> ZipArchive<R> {
     }
 
     /// Get a contained file by index
-    pub fn by_index<'a>(&'a mut self, file_number: usize) -> ZipResult<ZipFile<'a>> {
+    pub fn by_index(&mut self, file_number: usize) -> ZipResult<ZipFile<'_>> {
         Ok(self
             .by_index_with_optional_password(file_number, None)?
             .unwrap())
     }
 
     /// Get a contained file by index without decompressing it
-    pub fn by_index_raw<'a>(&'a mut self, file_number: usize) -> ZipResult<ZipFile<'a>> {
+    pub fn by_index_raw(&mut self, file_number: usize) -> ZipResult<ZipFile<'_>> {
         let reader = &mut self.reader;
         self.files
             .get_mut(file_number)
@@ -617,7 +617,10 @@ pub(crate) fn central_header_to_zip_file<R: Read + io::Seek>(
     }
 
     // Account for shifted zip offsets.
-    result.header_start += archive_offset;
+    result.header_start = result
+        .header_start
+        .checked_add(archive_offset)
+        .ok_or(ZipError::InvalidArchive("Archive header is too large"))?;
 
     Ok(result)
 }
@@ -1031,7 +1034,7 @@ mod test {
         let mut v = Vec::new();
         v.extend_from_slice(include_bytes!("../tests/data/zip64_demo.zip"));
         let reader = ZipArchive::new(io::Cursor::new(v)).unwrap();
-        assert!(reader.len() == 1);
+        assert_eq!(reader.len(), 1);
     }
 
     #[test]
@@ -1042,7 +1045,7 @@ mod test {
         let mut v = Vec::new();
         v.extend_from_slice(include_bytes!("../tests/data/mimetype.zip"));
         let mut reader = ZipArchive::new(io::Cursor::new(v)).unwrap();
-        assert!(reader.comment() == b"");
+        assert_eq!(reader.comment(), b"");
         assert_eq!(reader.by_index(0).unwrap().central_header_start(), 77);
     }
 
@@ -1055,9 +1058,8 @@ mod test {
         v.extend_from_slice(include_bytes!("../tests/data/mimetype.zip"));
         let mut reader = io::Cursor::new(v);
         loop {
-            match read_zipfile_from_stream(&mut reader).unwrap() {
+            if read_zipfile_from_stream(&mut reader).unwrap().is_none() {
-                None => break,
+                break;
-                _ => (),
             }
         }
     }
@@ -1093,14 +1095,14 @@ mod test {
         let mut buf3 = [0; 5];
         let mut buf4 = [0; 5];
 
-        file1.read(&mut buf1).unwrap();
+        file1.read_exact(&mut buf1).unwrap();
-        file2.read(&mut buf2).unwrap();
+        file2.read_exact(&mut buf2).unwrap();
-        file1.read(&mut buf3).unwrap();
+        file1.read_exact(&mut buf3).unwrap();
-        file2.read(&mut buf4).unwrap();
+        file2.read_exact(&mut buf4).unwrap();
 
         assert_eq!(buf1, buf2);
         assert_eq!(buf3, buf4);
-        assert!(buf1 != buf3);
+        assert_ne!(buf1, buf3);
     }
 
     #[test]

src/result.rs

@@ -1,37 +1,66 @@
 //! Error types that can be emitted from this library
 
+use std::error::Error;
+use std::fmt;
 use std::io;
 
-use thiserror::Error;
-
 /// Generic result type with ZipError as its error variant
 pub type ZipResult<T> = Result<T, ZipError>;
 
 /// The given password is wrong
-#[derive(Error, Debug)]
+#[derive(Debug)]
-#[error("invalid password for file in archive")]
 pub struct InvalidPassword;
 
+impl fmt::Display for InvalidPassword {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "invalid password for file in archive")
+    }
+}
+
+impl Error for InvalidPassword {}
+
 /// Error type for Zip
-#[derive(Debug, Error)]
+#[derive(Debug)]
 pub enum ZipError {
     /// An Error caused by I/O
-    #[error(transparent)]
+    Io(io::Error),
-    Io(#[from] io::Error),
 
     /// This file is probably not a zip archive
-    #[error("invalid Zip archive")]
     InvalidArchive(&'static str),
 
     /// This archive is not supported
-    #[error("unsupported Zip archive")]
     UnsupportedArchive(&'static str),
 
     /// The requested file could not be found in the archive
-    #[error("specified file not found in archive")]
     FileNotFound,
 }
 
+impl From<io::Error> for ZipError {
+    fn from(err: io::Error) -> ZipError {
+        ZipError::Io(err)
+    }
+}
+
+impl fmt::Display for ZipError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            ZipError::Io(err) => write!(fmt, "{}", err),
+            ZipError::InvalidArchive(err) => write!(fmt, "invalid Zip archive: {}", err),
+            ZipError::UnsupportedArchive(err) => write!(fmt, "unsupported Zip archive: {}", err),
+            ZipError::FileNotFound => write!(fmt, "specified file not found in archive"),
+        }
+    }
+}
+
+impl Error for ZipError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            ZipError::Io(err) => Some(err),
+            _ => None,
+        }
+    }
+}
+
 impl ZipError {
     /// The text used as an error when a password is required and not supplied
     ///

src/types.rs

@@ -1,5 +1,8 @@
 //! Types that specify what is contained in a ZIP.
 
+#[cfg(feature = "time")]
+use time::{error::ComponentRange, Date, Month, OffsetDateTime, PrimitiveDateTime, Time};
+
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum System {
     Dos = 0,
@@ -62,7 +65,7 @@ impl DateTime {
         let seconds = (timepart & 0b0000000000011111) << 1;
         let minutes = (timepart & 0b0000011111100000) >> 5;
         let hours = (timepart & 0b1111100000000000) >> 11;
-        let days = (datepart & 0b0000000000011111) >> 0;
+        let days = datepart & 0b0000000000011111;
         let months = (datepart & 0b0000000111100000) >> 5;
         let years = (datepart & 0b1111111000000000) >> 9;
 
@@ -85,6 +88,7 @@ impl DateTime {
     /// * hour: [0, 23]
     /// * minute: [0, 59]
     /// * second: [0, 60]
+    #[allow(clippy::result_unit_err)]
     pub fn from_date_and_time(
         year: u16,
         month: u8,
@@ -93,8 +97,7 @@ impl DateTime {
         minute: u8,
         second: u8,
     ) -> Result<DateTime, ()> {
-        if year >= 1980
+        if (1980..=2107).contains(&year)
-            && year <= 2107
             && month >= 1
             && month <= 12
             && day >= 1
@@ -117,30 +120,19 @@ impl DateTime {
     }
 
     #[cfg(feature = "time")]
-    /// Converts a ::time::Tm object to a DateTime
+    /// Converts a OffsetDateTime object to a DateTime
     ///
     /// Returns `Err` when this object is out of bounds
-    pub fn from_time(tm: ::time::Tm) -> Result<DateTime, ()> {
+    #[allow(clippy::result_unit_err)]
-        if tm.tm_year >= 80
+    pub fn from_time(dt: OffsetDateTime) -> Result<DateTime, ()> {
-            && tm.tm_year <= 207
+        if dt.year() >= 1980 && dt.year() <= 2107 {
-            && tm.tm_mon >= 0
-            && tm.tm_mon <= 11
-            && tm.tm_mday >= 1
-            && tm.tm_mday <= 31
-            && tm.tm_hour >= 0
-            && tm.tm_hour <= 23
-            && tm.tm_min >= 0
-            && tm.tm_min <= 59
-            && tm.tm_sec >= 0
-            && tm.tm_sec <= 60
-        {
             Ok(DateTime {
-                year: (tm.tm_year + 1900) as u16,
+                year: (dt.year()) as u16,
-                month: (tm.tm_mon + 1) as u8,
+                month: (dt.month()) as u8,
-                day: tm.tm_mday as u8,
+                day: dt.day() as u8,
-                hour: tm.tm_hour as u8,
+                hour: dt.hour() as u8,
-                minute: tm.tm_min as u8,
+                minute: dt.minute() as u8,
-                second: tm.tm_sec as u8,
+                second: dt.second() as u8,
             })
         } else {
             Err(())
@@ -158,20 +150,14 @@ impl DateTime {
     }
 
     #[cfg(feature = "time")]
-    /// Converts the datetime to a Tm structure
+    /// Converts the DateTime to a OffsetDateTime structure
-    ///
+    pub fn to_time(&self) -> Result<OffsetDateTime, ComponentRange> {
-    /// The fields `tm_wday`, `tm_yday`, `tm_utcoff` and `tm_nsec` are set to their defaults.
+        use std::convert::TryFrom;
-    pub fn to_time(&self) -> ::time::Tm {
+
-        ::time::Tm {
+        let date =
-            tm_sec: self.second as i32,
+            Date::from_calendar_date(self.year as i32, Month::try_from(self.month)?, self.day)?;
-            tm_min: self.minute as i32,
+        let time = Time::from_hms(self.hour, self.minute, self.second)?;
-            tm_hour: self.hour as i32,
+        Ok(PrimitiveDateTime::new(date, time).assume_utc())
-            tm_mday: self.day as i32,
-            tm_mon: self.month as i32 - 1,
-            tm_year: self.year as i32 - 1900,
-            tm_isdst: -1,
-            ..::time::empty_tm()
-        }
     }
 
     /// Get the year. There is no epoch, i.e. 2018 will be returned as 2018.
@@ -271,10 +257,7 @@ impl ZipFileData {
 
         ::std::path::Path::new(&filename)
             .components()
-            .filter(|component| match *component {
+            .filter(|component| matches!(*component, ::std::path::Component::Normal(..)))
-                ::std::path::Component::Normal(..) => true,
-                _ => false,
-            })
             .fold(::std::path::PathBuf::new(), |mut path, ref cur| {
                 path.push(cur.as_os_str());
                 path
@@ -340,6 +323,7 @@ mod test {
     }
 
     #[test]
+    #[allow(clippy::unusual_byte_groupings)]
     fn datetime_default() {
         use super::DateTime;
         let dt = DateTime::default();
@@ -348,6 +332,7 @@ mod test {
     }
 
     #[test]
+    #[allow(clippy::unusual_byte_groupings)]
     fn datetime_max() {
         use super::DateTime;
         let dt = DateTime::from_date_and_time(2107, 12, 31, 23, 59, 60).unwrap();
@@ -374,58 +359,26 @@ mod test {
         assert!(DateTime::from_date_and_time(2107, 12, 32, 0, 0, 0).is_err());
     }
 
+    #[cfg(feature = "time")]
+    use time::{format_description::well_known::Rfc3339, OffsetDateTime};
+
     #[cfg(feature = "time")]
     #[test]
     fn datetime_from_time_bounds() {
         use super::DateTime;
+        use time::macros::datetime;
 
         // 1979-12-31 23:59:59
-        assert!(DateTime::from_time(::time::Tm {
+        assert!(DateTime::from_time(datetime!(1979-12-31 23:59:59 UTC)).is_err());
-            tm_sec: 59,
-            tm_min: 59,
-            tm_hour: 23,
-            tm_mday: 31,
-            tm_mon: 11,  // tm_mon has number range [0, 11]
-            tm_year: 79, // 1979 - 1900 = 79
-            ..::time::empty_tm()
-        })
-        .is_err());
 
         // 1980-01-01 00:00:00
-        assert!(DateTime::from_time(::time::Tm {
+        assert!(DateTime::from_time(datetime!(1980-01-01 00:00:00 UTC)).is_ok());
-            tm_sec: 0,
-            tm_min: 0,
-            tm_hour: 0,
-            tm_mday: 1,
-            tm_mon: 0,   // tm_mon has number range [0, 11]
-            tm_year: 80, // 1980 - 1900 = 80
-            ..::time::empty_tm()
-        })
-        .is_ok());
 
         // 2107-12-31 23:59:59
-        assert!(DateTime::from_time(::time::Tm {
+        assert!(DateTime::from_time(datetime!(2107-12-31 23:59:59 UTC)).is_ok());
-            tm_sec: 59,
-            tm_min: 59,
-            tm_hour: 23,
-            tm_mday: 31,
-            tm_mon: 11,   // tm_mon has number range [0, 11]
-            tm_year: 207, // 2107 - 1900 = 207
-            ..::time::empty_tm()
-        })
-        .is_ok());
 
         // 2108-01-01 00:00:00
-        assert!(DateTime::from_time(::time::Tm {
+        assert!(DateTime::from_time(datetime!(2108-01-01 00:00:00 UTC)).is_err());
-            tm_sec: 0,
-            tm_min: 0,
-            tm_hour: 0,
-            tm_mday: 1,
-            tm_mon: 0,    // tm_mon has number range [0, 11]
-            tm_year: 208, // 2108 - 1900 = 208
-            ..::time::empty_tm()
-        })
-        .is_err());
     }
 
     #[test]
@@ -441,7 +394,7 @@ mod test {
 
         #[cfg(feature = "time")]
         assert_eq!(
-            format!("{}", dt.to_time().rfc3339()),
+            dt.to_time().unwrap().format(&Rfc3339).unwrap(),
             "2018-11-17T10:38:30Z"
         );
     }
@@ -458,10 +411,7 @@ mod test {
         assert_eq!(dt.second(), 62);
 
         #[cfg(feature = "time")]
-        assert_eq!(
+        assert!(dt.to_time().is_err());
-            format!("{}", dt.to_time().rfc3339()),
-            "2107-15-31T31:63:62Z"
-        );
 
         let dt = DateTime::from_msdos(0x0000, 0x0000);
         assert_eq!(dt.year(), 1980);
@@ -472,10 +422,7 @@ mod test {
         assert_eq!(dt.second(), 0);
 
         #[cfg(feature = "time")]
-        assert_eq!(
+        assert!(dt.to_time().is_err());
-            format!("{}", dt.to_time().rfc3339()),
-            "1980-00-00T00:00:00Z"
-        );
     }
 
     #[cfg(feature = "time")]
@@ -484,8 +431,8 @@ mod test {
         use super::DateTime;
 
         // 2020-01-01 00:00:00
-        let clock = ::time::Timespec::new(1577836800, 0);
+        let clock = OffsetDateTime::from_unix_timestamp(1_577_836_800).unwrap();
-        let tm = ::time::at_utc(clock);
+
-        assert!(DateTime::from_time(tm).is_ok());
+        assert!(DateTime::from_time(clock).is_ok());
     }
 }

src/write.rs

@@ -22,6 +22,9 @@ use flate2::write::DeflateEncoder;
 #[cfg(feature = "bzip2")]
 use bzip2::write::BzEncoder;
 
+#[cfg(feature = "time")]
+use time::OffsetDateTime;
+
 #[cfg(feature = "zstd")]
 use zstd::stream::write::Encoder as ZstdEncoder;
 
@@ -118,7 +121,7 @@ impl FileOptions {
             )))]
             compression_method: CompressionMethod::Stored,
             #[cfg(feature = "time")]
-            last_modified_time: DateTime::from_time(time::now()).unwrap_or_default(),
+            last_modified_time: DateTime::from_time(OffsetDateTime::now_utc()).unwrap_or_default(),
             #[cfg(not(feature = "time"))]
             last_modified_time: DateTime::default(),
             permissions: None,
@@ -130,6 +133,7 @@ impl FileOptions {
     ///
     /// The default is `CompressionMethod::Deflated`. If the deflate compression feature is
     /// disabled, `CompressionMethod::Stored` becomes the default.
+    #[must_use]
     pub fn compression_method(mut self, method: CompressionMethod) -> FileOptions {
         self.compression_method = method;
         self
@@ -139,6 +143,7 @@ impl FileOptions {
     ///
     /// The default is the current timestamp if the 'time' feature is enabled, and 1980-01-01
     /// otherwise
+    #[must_use]
     pub fn last_modified_time(mut self, mod_time: DateTime) -> FileOptions {
         self.last_modified_time = mod_time;
         self
@@ -149,6 +154,7 @@ impl FileOptions {
     /// The format is represented with unix-style permissions.
     /// The default is `0o644`, which represents `rw-r--r--` for files,
     /// and `0o755`, which represents `rwxr-xr-x` for directories
+    #[must_use]
     pub fn unix_permissions(mut self, mode: u32) -> FileOptions {
         self.permissions = Some(mode & 0o777);
         self
@@ -159,6 +165,7 @@ impl FileOptions {
     /// If set to `false` and the file exceeds the limit, an I/O error is thrown. If set to `true`,
     /// readers will require ZIP64 support and if the file does not exceed the limit, 20 B are
     /// wasted. The default is `false`.
+    #[must_use]
     pub fn large_file(mut self, large: bool) -> FileOptions {
         self.large_file = large;
         self
@@ -239,7 +246,10 @@ impl<A: Read + Write + io::Seek> ZipWriter<A> {
         let (archive_offset, directory_start, number_of_files) =
             ZipArchive::get_directory_counts(&mut readwriter, &footer, cde_start_pos)?;
 
-        if let Err(_) = readwriter.seek(io::SeekFrom::Start(directory_start)) {
+        if readwriter
+            .seek(io::SeekFrom::Start(directory_start))
+            .is_err()
+        {
             return Err(ZipError::InvalidArchive(
                 "Could not seek to start of central directory",
             ));
@@ -309,7 +319,7 @@ impl<W: Write + io::Seek> ZipWriter<W> {
     {
         self.finish_file()?;
 
-        let raw_values = raw_values.unwrap_or_else(|| ZipRawValues {
+        let raw_values = raw_values.unwrap_or(ZipRawValues {
             crc32: 0,
             compressed_size: 0,
             uncompressed_size: 0,
@@ -550,7 +560,7 @@ impl<W: Write + io::Seek> ZipWriter<W> {
         }
         let file = self.files.last_mut().unwrap();
 
-        validate_extra_data(&file)?;
+        validate_extra_data(file)?;
 
         if !self.writing_to_central_extra_field_only {
             let writer = self.inner.get_plain();
@@ -608,11 +618,11 @@ impl<W: Write + io::Seek> ZipWriter<W> {
     where
         S: Into<String>,
     {
-        let options = FileOptions::default()
+        let mut options = FileOptions::default()
             .last_modified_time(file.last_modified())
             .compression_method(file.compression());
         if let Some(perms) = file.unix_mode() {
-            options.unix_permissions(perms);
+            options = options.unix_permissions(perms);
         }
 
         let raw_values = ZipRawValues {
@@ -868,10 +878,7 @@ impl<W: Write + io::Seek> GenericZipWriter<W> {
     }
 
     fn is_closed(&self) -> bool {
-        match *self {
+        matches!(*self, GenericZipWriter::Closed)
-            GenericZipWriter::Closed => true,
-            _ => false,
-        }
     }
 
     fn get_plain(&mut self) -> &mut W {
@@ -947,7 +954,7 @@ fn write_local_file_header<T: Write>(writer: &mut T, file: &ZipFileData) -> ZipR
     writer.write_all(file.file_name.as_bytes())?;
     // zip64 extra field
     if file.large_file {
-        write_local_zip64_extra_field(writer, &file)?;
+        write_local_zip64_extra_field(writer, file)?;
     }
 
     Ok(())
@@ -1065,7 +1072,7 @@ fn validate_extra_data(file: &ZipFileData) -> ZipResult<()> {
         )));
     }
 
-    while data.len() > 0 {
+    while !data.is_empty() {
         let left = data.len();
         if left < 4 {
             return Err(ZipError::Io(io::Error::new(
@@ -1245,7 +1252,7 @@ mod test {
         };
         writer.start_file("mimetype", options).unwrap();
         writer
-            .write(b"application/vnd.oasis.opendocument.text")
+            .write_all(b"application/vnd.oasis.opendocument.text")
             .unwrap();
         let result = writer.finish().unwrap();
 

src/zipcrypto.rs

@@ -47,7 +47,7 @@ impl ZipCryptoKeys {
     }
 
     fn crc32(crc: Wrapping<u32>, input: u8) -> Wrapping<u32> {
-        return (crc >> 8) ^ Wrapping(CRCTABLE[((crc & Wrapping(0xff)).0 as u8 ^ input) as usize]);
+        (crc >> 8) ^ Wrapping(CRCTABLE[((crc & Wrapping(0xff)).0 as u8 ^ input) as usize])
     }
 }
 
@@ -71,7 +71,7 @@ impl<R: std::io::Read> ZipCryptoReader<R> {
     /// password byte sequence that is unrepresentable in UTF-8.
     pub fn new(file: R, password: &[u8]) -> ZipCryptoReader<R> {
         let mut result = ZipCryptoReader {
-            file: file,
+            file,
             keys: ZipCryptoKeys::new(),
         };
 
@@ -129,11 +129,11 @@ pub struct ZipCryptoReaderValid<R> {
 }
 
 impl<R: std::io::Read> std::io::Read for ZipCryptoReaderValid<R> {
-    fn read(&mut self, mut buf: &mut [u8]) -> std::io::Result<usize> {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
         // Note: There might be potential for optimization. Inspiration can be found at:
         // https://github.com/kornelski/7z/blob/master/CPP/7zip/Crypto/ZipCrypto.cpp
 
-        let result = self.reader.file.read(&mut buf);
+        let result = self.reader.file.read(buf);
         for byte in buf.iter_mut() {
             *byte = self.reader.keys.decrypt_byte(*byte);
         }

tests/end_to_end.rs

@@ -121,7 +121,7 @@ fn read_zip<R: Read + Seek>(zip_file: R) -> zip::result::ZipResult<zip::ZipArchi
         "test_with_extra_data/🐢.txt",
         ENTRY_NAME,
     ];
-    let expected_file_names = HashSet::from_iter(expected_file_names.iter().map(|&v| v));
+    let expected_file_names = HashSet::from_iter(expected_file_names.iter().copied());
     let file_names = archive.file_names().collect::<HashSet<_>>();
     assert_eq!(file_names, expected_file_names);
 
@@ -173,17 +173,17 @@ fn check_zip_contents(
 
 fn check_zip_file_contents<R: Read + Seek>(archive: &mut zip::ZipArchive<R>, name: &str) {
     let file_contents: String = read_zip_file(archive, name).unwrap();
-    assert!(file_contents.as_bytes() == LOREM_IPSUM);
+    assert_eq!(file_contents.as_bytes(), LOREM_IPSUM);
 }
 
-const LOREM_IPSUM : &'static [u8] = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. In tellus elit, tristique vitae mattis egestas, ultricies vitae risus. Quisque sit amet quam ut urna aliquet
+const LOREM_IPSUM : &[u8] = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. In tellus elit, tristique vitae mattis egestas, ultricies vitae risus. Quisque sit amet quam ut urna aliquet
 molestie. Proin blandit ornare dui, a tempor nisl accumsan in. Praesent a consequat felis. Morbi metus diam, auctor in auctor vel, feugiat id odio. Curabitur ex ex,
 dictum quis auctor quis, suscipit id lorem. Aliquam vestibulum dolor nec enim vehicula, porta tristique augue tincidunt. Vivamus ut gravida est. Sed pellentesque, dolor
 vitae tristique consectetur, neque lectus pulvinar dui, sed feugiat purus diam id lectus. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per
 inceptos himenaeos. Maecenas feugiat velit in ex ultrices scelerisque id id neque.
 ";
 
-const EXTRA_DATA: &'static [u8] = b"Extra Data";
+const EXTRA_DATA: &[u8] = b"Extra Data";
 
 const ENTRY_NAME: &str = "test/lorem_ipsum.txt";