Implement shallow copy from within the file being written

Cargo.toml

@@ -1,7 +1,8 @@
 [package]
-name = "zip"
+name = "zip_next"
-version = "0.6.4"
+version = "0.6.5"
-authors = ["Mathijs van de Nes <git@mathijs.vd-nes.nl>", "Marli Frost <marli@frost.red>", "Ryan Levick <ryan.levick@gmail.com>"]
+authors = ["Mathijs van de Nes <git@mathijs.vd-nes.nl>", "Marli Frost <marli@frost.red>", "Ryan Levick <ryan.levick@gmail.com>",
+"Chris Hennick <hennickc@amazon.com>"]
 license = "MIT"
 repository = "https://github.com/zip-rs/zip.git"
 keywords = ["zip", "archive"]

README.md

@@ -32,14 +32,14 @@ With all default features:
 
 ```toml
 [dependencies]
-zip = "0.6.4"
+zip-next = "0.6.5"
 ```
 
 Without the default features:
 
 ```toml
 [dependencies]
-zip = { version = "0.6.4", default-features = false }
+zip-next = { version = "0.6.5", default-features = false }
 ```
 
 The features available are:

benches/read_entry.rs

@@ -4,13 +4,13 @@ use std::io::{Cursor, Read, Write};
 
 use bencher::Bencher;
 use getrandom::getrandom;
-use zip::{ZipArchive, ZipWriter};
+use zip_next::{ZipArchive, ZipWriter};
 
 fn generate_random_archive(size: usize) -> Vec<u8> {
     let data = Vec::new();
     let mut writer = ZipWriter::new(Cursor::new(data));
     let options =
-        zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Stored);
+        zip_next::write::FileOptions::default().compression_method(zip_next::CompressionMethod::Stored);
 
     writer.start_file("random.dat", options).unwrap();
     let mut bytes = vec![0u8; size];

benches/read_metadata.rs

@@ -3,7 +3,7 @@ use bencher::{benchmark_group, benchmark_main};
 use std::io::{Cursor, Write};
 
 use bencher::Bencher;
-use zip::{ZipArchive, ZipWriter};
+use zip_next::{ZipArchive, ZipWriter};
 
 const FILE_COUNT: usize = 15_000;
 const FILE_SIZE: usize = 1024;
@@ -12,7 +12,7 @@ fn generate_random_archive(count_files: usize, file_size: usize) -> Vec<u8> {
     let data = Vec::new();
     let mut writer = ZipWriter::new(Cursor::new(data));
     let options =
-        zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Stored);
+        zip_next::write::FileOptions::default().compression_method(zip_next::CompressionMethod::Stored);
 
     let bytes = vec![0u8; file_size];
 

examples/extract.rs

@@ -14,7 +14,7 @@ fn real_main() -> i32 {
     let fname = std::path::Path::new(&*args[1]);
     let file = fs::File::open(fname).unwrap();
 
-    let mut archive = zip::ZipArchive::new(file).unwrap();
+    let mut archive = zip_next::ZipArchive::new(file).unwrap();
 
     for i in 0..archive.len() {
         let mut file = archive.by_index(i).unwrap();

examples/extract_lorem.rs

@@ -13,7 +13,7 @@ fn real_main() -> i32 {
     let fname = std::path::Path::new(&*args[1]);
     let zipfile = std::fs::File::open(fname).unwrap();
 
-    let mut archive = zip::ZipArchive::new(zipfile).unwrap();
+    let mut archive = zip_next::ZipArchive::new(zipfile).unwrap();
 
     let mut file = match archive.by_name("test/lorem_ipsum.txt") {
         Ok(file) => file,

examples/file_info.rs

@@ -15,7 +15,7 @@ fn real_main() -> i32 {
     let file = fs::File::open(fname).unwrap();
     let reader = BufReader::new(file);
 
-    let mut archive = zip::ZipArchive::new(reader).unwrap();
+    let mut archive = zip_next::ZipArchive::new(reader).unwrap();
 
     for i in 0..archive.len() {
         let file = archive.by_index(i).unwrap();

examples/stdin_info.rs

@@ -10,7 +10,7 @@ fn real_main() -> i32 {
     let mut buf = [0u8; 16];
 
     loop {
-        match zip::read::read_zipfile_from_stream(&mut stdin_handle) {
+        match zip_next::read::read_zipfile_from_stream(&mut stdin_handle) {
             Ok(Some(mut file)) => {
                 println!(
                     "{}: {} bytes ({} bytes packed)",

examples/write_dir.rs

@@ -1,8 +1,8 @@
 use std::io::prelude::*;
 use std::io::{Seek, Write};
 use std::iter::Iterator;
-use zip::result::ZipError;
+use zip_next::result::ZipError;
-use zip::write::FileOptions;
+use zip_next::write::FileOptions;
 
 use std::fs::File;
 use std::path::Path;
@@ -12,30 +12,30 @@ fn main() {
     std::process::exit(real_main());
 }
 
-const METHOD_STORED: Option<zip::CompressionMethod> = Some(zip::CompressionMethod::Stored);
+const METHOD_STORED: Option<zip_next::CompressionMethod> = Some(zip_next::CompressionMethod::Stored);
 
 #[cfg(any(
     feature = "deflate",
     feature = "deflate-miniz",
     feature = "deflate-zlib"
 ))]
-const METHOD_DEFLATED: Option<zip::CompressionMethod> = Some(zip::CompressionMethod::Deflated);
+const METHOD_DEFLATED: Option<zip_next::CompressionMethod> = Some(zip_next::CompressionMethod::Deflated);
 #[cfg(not(any(
     feature = "deflate",
     feature = "deflate-miniz",
     feature = "deflate-zlib"
 )))]
-const METHOD_DEFLATED: Option<zip::CompressionMethod> = None;
+const METHOD_DEFLATED: Option<zip_next::CompressionMethod> = None;
 
 #[cfg(feature = "bzip2")]
-const METHOD_BZIP2: Option<zip::CompressionMethod> = Some(zip::CompressionMethod::Bzip2);
+const METHOD_BZIP2: Option<zip_next::CompressionMethod> = Some(zip_next::CompressionMethod::Bzip2);
 #[cfg(not(feature = "bzip2"))]
-const METHOD_BZIP2: Option<zip::CompressionMethod> = None;
+const METHOD_BZIP2: Option<zip_next::CompressionMethod> = None;
 
 #[cfg(feature = "zstd")]
-const METHOD_ZSTD: Option<zip::CompressionMethod> = Some(zip::CompressionMethod::Zstd);
+const METHOD_ZSTD: Option<zip_next::CompressionMethod> = Some(zip_next::CompressionMethod::Zstd);
 #[cfg(not(feature = "zstd"))]
-const METHOD_ZSTD: Option<zip::CompressionMethod> = None;
+const METHOD_ZSTD: Option<zip_next::CompressionMethod> = None;
 
 fn real_main() -> i32 {
     let args: Vec<_> = std::env::args().collect();
@@ -66,12 +66,12 @@ fn zip_dir<T>(
     it: &mut dyn Iterator<Item = DirEntry>,
     prefix: &str,
     writer: T,
-    method: zip::CompressionMethod,
+    method: zip_next::CompressionMethod,
-) -> zip::result::ZipResult<()>
+) -> zip_next::result::ZipResult<()>
 where
     T: Write + Seek,
 {
-    let mut zip = zip::ZipWriter::new(writer);
+    let mut zip = zip_next::ZipWriter::new(writer);
     let options = FileOptions::default()
         .compression_method(method)
         .unix_permissions(0o755);
@@ -107,8 +107,8 @@ where
 fn doit(
     src_dir: &str,
     dst_file: &str,
-    method: zip::CompressionMethod,
+    method: zip_next::CompressionMethod,
-) -> zip::result::ZipResult<()> {
+) -> zip_next::result::ZipResult<()> {
     if !Path::new(src_dir).is_dir() {
         return Err(ZipError::FileNotFound);
     }

examples/write_sample.rs

@@ -1,5 +1,5 @@
 use std::io::prelude::*;
-use zip::write::FileOptions;
+use zip_next::write::FileOptions;
 
 fn main() {
     std::process::exit(real_main());
@@ -21,16 +21,16 @@ fn real_main() -> i32 {
     0
 }
 
-fn doit(filename: &str) -> zip::result::ZipResult<()> {
+fn doit(filename: &str) -> zip_next::result::ZipResult<()> {
     let path = std::path::Path::new(filename);
     let file = std::fs::File::create(path).unwrap();
 
-    let mut zip = zip::ZipWriter::new(file);
+    let mut zip = zip_next::ZipWriter::new(file);
 
     zip.add_directory("test/", Default::default())?;
 
     let options = FileOptions::default()
-        .compression_method(zip::CompressionMethod::Stored)
+        .compression_method(zip_next::CompressionMethod::Stored)
         .unix_permissions(0o755);
     zip.start_file("test/☃.txt", options)?;
     zip.write_all(b"Hello, World!\n")?;

fuzz/fuzz_targets/fuzz_read.rs

@@ -3,7 +3,7 @@ use libfuzzer_sys::fuzz_target;
 
 fn decompress_all(data: &[u8]) -> Result<(), Box<dyn std::error::Error>> {
     let reader = std::io::Cursor::new(data);
-    let mut zip = zip::ZipArchive::new(reader)?;
+    let mut zip = zip_next::ZipArchive::new(reader)?;
 
     for i in 0..zip.len() {
         let mut file = zip.by_index(i)?;

src/lib.rs

@@ -21,7 +21,7 @@
 //!
 //!
 //!
-
+#![feature(read_buf)]
 #![warn(missing_docs)]
 
 pub use crate::compression::{CompressionMethod, SUPPORTED_COMPRESSION_METHODS};

src/read.rs

@@ -51,8 +51,8 @@ pub(crate) mod zip_archive {
     ///
     /// ```no_run
     /// use std::io::prelude::*;
-    /// fn list_zip_contents(reader: impl Read + Seek) -> zip::result::ZipResult<()> {
+    /// fn list_zip_contents(reader: impl Read + Seek) -> zip_next::result::ZipResult<()> {
-    ///     let mut zip = zip::ZipArchive::new(reader)?;
+    ///     let mut zip = zip_next::ZipArchive::new(reader)?;
     ///
     ///     for i in 0..zip.len() {
     ///         let mut file = zip.by_index(i)?;
@@ -72,7 +72,7 @@ pub(crate) mod zip_archive {
 
 pub use zip_archive::ZipArchive;
 #[allow(clippy::large_enum_variant)]
-enum CryptoReader<'a> {
+pub(crate) enum CryptoReader<'a> {
     Plaintext(io::Take<&'a mut dyn Read>),
     ZipCrypto(ZipCryptoReaderValid<io::Take<&'a mut dyn Read>>),
     #[cfg(feature = "aes-crypto")]
@@ -119,7 +119,7 @@ impl<'a> CryptoReader<'a> {
     }
 }
 
-enum ZipFileReader<'a> {
+pub(crate) enum ZipFileReader<'a> {
     NoReader,
     Raw(io::Take<&'a mut dyn io::Read>),
     Stored(Crc32Reader<CryptoReader<'a>>),
@@ -178,12 +178,12 @@ impl<'a> ZipFileReader<'a> {
 
 /// A struct for reading a zip file
 pub struct ZipFile<'a> {
-    data: Cow<'a, ZipFileData>,
+    pub(crate) data: Cow<'a, ZipFileData>,
-    crypto_reader: Option<CryptoReader<'a>>,
+    pub(crate) crypto_reader: Option<CryptoReader<'a>>,
-    reader: ZipFileReader<'a>,
+    pub(crate) reader: ZipFileReader<'a>,
 }
 
-fn find_content<'a>(
+pub(crate) fn find_content<'a>(
     data: &ZipFileData,
     reader: &'a mut (impl Read + Seek),
 ) -> ZipResult<io::Take<&'a mut dyn Read>> {
@@ -206,7 +206,7 @@ fn find_content<'a>(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn make_crypto_reader<'a>(
+pub(crate) fn make_crypto_reader<'a>(
     compression_method: crate::compression::CompressionMethod,
     crc32: u32,
     last_modified_time: DateTime,
@@ -257,7 +257,7 @@ fn make_crypto_reader<'a>(
     Ok(Ok(reader))
 }
 
-fn make_reader(
+pub(crate) fn make_reader(
     compression_method: CompressionMethod,
     crc32: u32,
     reader: CryptoReader,
@@ -991,7 +991,7 @@ impl<'a> Drop for ZipFile<'a> {
             // Get the inner `Take` reader so all decryption, decompression and CRC calculation is skipped.
             let mut reader: std::io::Take<&mut dyn std::io::Read> = match &mut self.reader {
                 ZipFileReader::NoReader => {
-                    let innerreader = ::std::mem::replace(&mut self.crypto_reader, None);
+                    let innerreader = self.crypto_reader.take();
                     innerreader.expect("Invalid reader state").into_inner()
                 }
                 reader => {

src/result.rs

@@ -65,8 +65,8 @@ impl ZipError {
     /// The text used as an error when a password is required and not supplied
     ///
     /// ```rust,no_run
-    /// # use zip::result::ZipError;
+    /// # use zip_next::result::ZipError;
-    /// # let mut archive = zip::ZipArchive::new(std::io::Cursor::new(&[])).unwrap();
+    /// # let mut archive = zip_next::ZipArchive::new(std::io::Cursor::new(&[])).unwrap();
     /// match archive.by_index(1) {
     ///     Err(ZipError::UnsupportedArchive(ZipError::PASSWORD_REQUIRED)) => eprintln!("a password is needed to unzip this file"),
     ///     _ => (),

src/write.rs

@@ -52,17 +52,17 @@ pub(crate) mod zip_writer {
     /// API to edit its contents.
     ///
     /// ```
-    /// # fn doit() -> zip::result::ZipResult<()>
+    /// # fn doit() -> zip_next::result::ZipResult<()>
     /// # {
-    /// # use zip::ZipWriter;
+    /// # use zip_next::ZipWriter;
     /// use std::io::Write;
-    /// use zip::write::FileOptions;
+    /// use zip_next::write::FileOptions;
     ///
     /// // We use a buffer here, though you'd normally use a `File`
     /// let mut buf = [0; 65536];
-    /// let mut zip = zip::ZipWriter::new(std::io::Cursor::new(&mut buf[..]));
+    /// let mut zip = zip_next::ZipWriter::new(std::io::Cursor::new(&mut buf[..]));
     ///
-    /// let options = zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Stored);
+    /// let options = zip_next::write::FileOptions::default().compression_method(zip_next::CompressionMethod::Stored);
     /// zip.start_file("hello_world.txt", options)?;
     /// zip.write(b"Hello, World!")?;
     ///
@@ -82,7 +82,7 @@ pub(crate) mod zip_writer {
         pub(super) writing_to_extra_field: bool,
         pub(super) writing_to_central_extra_field_only: bool,
         pub(super) writing_raw: bool,
-        pub(super) comment: Vec<u8>,
+        pub(super) comment: Vec<u8>
     }
 }
 pub use zip_writer::ZipWriter;
@@ -291,7 +291,7 @@ impl<A: Read + Write + io::Seek> ZipWriter<A> {
             writing_to_extra_field: false,
             writing_to_central_extra_field_only: false,
             comment: footer.zip_file_comment,
-            writing_raw: true, // avoid recomputing the last file's header
+            writing_raw: true // avoid recomputing the last file's header
         })
     }
 }
@@ -309,7 +309,7 @@ impl<W: Write + io::Seek> ZipWriter<W> {
             writing_to_extra_field: false,
             writing_to_central_extra_field_only: false,
             writing_raw: false,
-            comment: Vec::new(),
+            comment: Vec::new()
         }
     }
 
@@ -493,8 +493,8 @@ impl<W: Write + io::Seek> ZipWriter<W> {
     ///
     /// ```
     /// use byteorder::{LittleEndian, WriteBytesExt};
-    /// use zip::{ZipArchive, ZipWriter, result::ZipResult};
+    /// use zip_next::{ZipArchive, ZipWriter, result::ZipResult};
-    /// use zip::{write::FileOptions, CompressionMethod};
+    /// use zip_next::{write::FileOptions, CompressionMethod};
     /// use std::io::{Write, Cursor};
     ///
     /// # fn main() -> ZipResult<()> {
@@ -623,12 +623,12 @@ impl<W: Write + io::Seek> ZipWriter<W> {
     /// ```no_run
     /// use std::fs::File;
     /// use std::io::{Read, Seek, Write};
-    /// use zip::{ZipArchive, ZipWriter};
+    /// use zip_next::{ZipArchive, ZipWriter};
     ///
     /// fn copy_rename<R, W>(
     ///     src: &mut ZipArchive<R>,
     ///     dst: &mut ZipWriter<W>,
-    /// ) -> zip::result::ZipResult<()>
+    /// ) -> zip_next::result::ZipResult<()>
     /// where
     ///     R: Read + Seek,
     ///     W: Write + Seek,
@@ -676,9 +676,9 @@ impl<W: Write + io::Seek> ZipWriter<W> {
     /// ```no_run
     /// use std::fs::File;
     /// use std::io::{Read, Seek, Write};
-    /// use zip::{ZipArchive, ZipWriter};
+    /// use zip_next::{ZipArchive, ZipWriter};
     ///
-    /// fn copy<R, W>(src: &mut ZipArchive<R>, dst: &mut ZipWriter<W>) -> zip::result::ZipResult<()>
+    /// fn copy<R, W>(src: &mut ZipArchive<R>, dst: &mut ZipWriter<W>) -> zip_next::result::ZipResult<()>
     /// where
     ///     R: Read + Seek,
     ///     W: Write + Seek,
@@ -841,6 +841,32 @@ impl<W: Write + io::Seek> ZipWriter<W> {
     }
 }
 
+impl <RW: Read + Write + io::Seek> ZipWriter<RW> {
+    fn data_by_name(&mut self, name: &str) -> ZipResult<&ZipFileData> {
+        self.finish_file()?;
+        for file in self.files.iter() {
+            if file.file_name == name {
+                return Ok(file);
+            }
+        }
+        Err(ZipError::FileNotFound)
+    }
+
+    /// Adds another entry to the central directory referring to the same content as an existing
+    /// entry. The file's local-file header will still refer to it by its original name, so
+    /// unzipping the file will technically be unspecified behavior. However, both [ZipArchive] and
+    /// OpenJDK ignore the filename in the local-file header and treat the central directory as
+    /// authoritative.
+    pub fn shallow_copy_file(&mut self, src_name: &str, dest_name: &str) -> ZipResult<()> {
+        self.finish_file()?;
+        let src_data = self.data_by_name(src_name)?;
+        let mut dest_data = src_data.to_owned();
+        dest_data.file_name = dest_name.into();
+        self.files.push(dest_data);
+        Ok(())
+    }
+}
+
 impl<W: Write + io::Seek> Drop for ZipWriter<W> {
     fn drop(&mut self) {
         if !self.inner.is_closed() {
@@ -1309,7 +1335,8 @@ mod test {
     use crate::compression::CompressionMethod;
     use crate::types::DateTime;
     use std::io;
-    use std::io::Write;
+    use std::io::{Read, Write};
+    use crate::ZipArchive;
 
     #[test]
     fn write_empty_zip() {
@@ -1441,6 +1468,41 @@ mod test {
         assert_eq!(result.get_ref(), &v);
     }
 
+    #[cfg(test)]
+    const RT_TEST_TEXT: &str = "And I can't stop thinking about the moments that I lost to you\
+                            And I can't stop thinking of things I used to do\
+                            And I can't stop making bad decisions\
+                            And I can't stop eating stuff you make me chew\
+                            I put on a smile like you wanna see\
+                            Another day goes by that I long to be like you";
+    #[cfg(test)] const RT_TEST_FILENAME: &str = "subfolder/sub-subfolder/can't_stop.txt";
+    #[cfg(test)] const SECOND_FILENAME: &str = "different_name.xyz";
+
+    #[test]
+    fn test_shallow_copy() {
+        let mut writer = ZipWriter::new(io::Cursor::new(Vec::new()));
+        let options = FileOptions {
+            compression_method: CompressionMethod::Deflated,
+            compression_level: Some(9),
+            last_modified_time: DateTime::default(),
+            permissions: Some(33188),
+            large_file: false,
+        };
+        writer.start_file(RT_TEST_FILENAME, options).unwrap();
+        writer.write(RT_TEST_TEXT.as_ref()).unwrap();
+        writer.shallow_copy_file(RT_TEST_FILENAME, SECOND_FILENAME).unwrap();
+        let zip = writer.finish().unwrap();
+        let mut reader = ZipArchive::new(zip).unwrap();
+        let file_names: Vec<&str> = reader.file_names().collect();
+        assert_eq!(file_names, vec![RT_TEST_FILENAME, SECOND_FILENAME]);
+        let mut first_file_content = String::new();
+        reader.by_name(RT_TEST_FILENAME).unwrap().read_to_string(&mut first_file_content).unwrap();
+        assert_eq!(first_file_content, RT_TEST_TEXT);
+        let mut second_file_content = String::new();
+        reader.by_name(SECOND_FILENAME).unwrap().read_to_string(&mut second_file_content).unwrap();
+        assert_eq!(second_file_content, RT_TEST_TEXT);
+    }
+
     #[test]
     fn path_to_string() {
         let mut path = std::path::PathBuf::new();

tests/aes_encryption.rs

@@ -1,7 +1,7 @@
 #![cfg(feature = "aes-crypto")]
 
 use std::io::{self, Read};
-use zip::ZipArchive;
+use zip_next::ZipArchive;
 
 const SECRET_CONTENT: &str = "Lorem ipsum dolor sit amet";
 

tests/end_to_end.rs

@@ -3,8 +3,8 @@ use std::collections::HashSet;
 use std::io::prelude::*;
 use std::io::{Cursor, Seek};
 use std::iter::FromIterator;
-use zip::write::FileOptions;
+use zip_next::write::FileOptions;
-use zip::{CompressionMethod, SUPPORTED_COMPRESSION_METHODS};
+use zip_next::{CompressionMethod, SUPPORTED_COMPRESSION_METHODS};
 
 // This test asserts that after creating a zip file, then reading its contents back out,
 // the extracted data will *always* be exactly the same as the original data.
@@ -32,8 +32,8 @@ fn copy() {
         let mut tgt_file = &mut Cursor::new(Vec::new());
 
         {
-            let mut src_archive = zip::ZipArchive::new(src_file).unwrap();
+            let mut src_archive = zip_next::ZipArchive::new(src_file).unwrap();
-            let mut zip = zip::ZipWriter::new(&mut tgt_file);
+            let mut zip = zip_next::ZipWriter::new(&mut tgt_file);
 
             {
                 let file = src_archive
@@ -53,7 +53,7 @@ fn copy() {
             }
         }
 
-        let mut tgt_archive = zip::ZipArchive::new(tgt_file).unwrap();
+        let mut tgt_archive = zip_next::ZipArchive::new(tgt_file).unwrap();
 
         check_archive_file_contents(&mut tgt_archive, ENTRY_NAME, LOREM_IPSUM);
         check_archive_file_contents(&mut tgt_archive, COPY_ENTRY_NAME, LOREM_IPSUM);
@@ -69,7 +69,7 @@ fn append() {
         write_test_archive(file, method).expect("Couldn't write to test file");
 
         {
-            let mut zip = zip::ZipWriter::new_append(&mut file).unwrap();
+            let mut zip = zip_next::ZipWriter::new_append(&mut file).unwrap();
             zip.start_file(
                 COPY_ENTRY_NAME,
                 FileOptions::default().compression_method(method),
@@ -79,7 +79,7 @@ fn append() {
             zip.finish().unwrap();
         }
 
-        let mut zip = zip::ZipArchive::new(&mut file).unwrap();
+        let mut zip = zip_next::ZipArchive::new(&mut file).unwrap();
         check_archive_file_contents(&mut zip, ENTRY_NAME, LOREM_IPSUM);
         check_archive_file_contents(&mut zip, COPY_ENTRY_NAME, LOREM_IPSUM);
     }
@@ -89,8 +89,8 @@ fn append() {
 fn write_test_archive(
     file: &mut Cursor<Vec<u8>>,
     method: CompressionMethod,
-) -> zip::result::ZipResult<()> {
+) -> zip_next::result::ZipResult<()> {
-    let mut zip = zip::ZipWriter::new(file);
+    let mut zip = zip_next::ZipWriter::new(file);
 
     zip.add_directory("test/", Default::default())?;
 
@@ -116,8 +116,8 @@ fn write_test_archive(
 }
 
 // Load an archive from buffer and check for test data.
-fn check_test_archive<R: Read + Seek>(zip_file: R) -> zip::result::ZipResult<zip::ZipArchive<R>> {
+fn check_test_archive<R: Read + Seek>(zip_file: R) -> zip_next::result::ZipResult<zip_next::ZipArchive<R>> {
-    let mut archive = zip::ZipArchive::new(zip_file).unwrap();
+    let mut archive = zip_next::ZipArchive::new(zip_file).unwrap();
 
     // Check archive contains expected file names.
     {
@@ -147,9 +147,9 @@ fn check_test_archive<R: Read + Seek>(zip_file: R) -> zip::result::ZipResult<zip
 
 // Read a file in the archive as a string.
 fn read_archive_file<R: Read + Seek>(
-    archive: &mut zip::ZipArchive<R>,
+    archive: &mut zip_next::ZipArchive<R>,
     name: &str,
-) -> zip::result::ZipResult<String> {
+) -> zip_next::result::ZipResult<String> {
     let mut file = archive.by_name(name)?;
 
     let mut contents = String::new();
@@ -183,7 +183,7 @@ fn check_archive_file(
 
 // Check a file in the archive contains the given data.
 fn check_archive_file_contents<R: Read + Seek>(
-    archive: &mut zip::ZipArchive<R>,
+    archive: &mut zip_next::ZipArchive<R>,
     name: &str,
     expected: &[u8],
 ) {

tests/invalid_date.rs

@@ -1,5 +1,5 @@
 use std::io::Cursor;
-use zip::read::ZipArchive;
+use zip_next::read::ZipArchive;
 
 const BUF: &[u8] = &[
     0x50, 0x4b, 0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

tests/issue_234.rs

@@ -1,4 +1,4 @@
-use zip::result::ZipError;
+use zip_next::result::ZipError;
 
 const BUF: &[u8] = &[
     0, 80, 75, 1, 2, 127, 120, 0, 3, 3, 75, 80, 232, 3, 0, 0, 0, 0, 0, 0, 3, 0, 1, 0, 7, 0, 0, 0,
@@ -23,7 +23,7 @@ const BUF: &[u8] = &[
 #[test]
 fn invalid_header() {
     let reader = std::io::Cursor::new(&BUF);
-    let archive = zip::ZipArchive::new(reader);
+    let archive = zip_next::ZipArchive::new(reader);
     match archive {
         Err(ZipError::InvalidArchive(_)) => {}
         value => panic!("Unexpected value: {value:?}"),

tests/zip64_large.rs

@@ -190,7 +190,7 @@ impl Read for Zip64File {
 #[test]
 fn zip64_large() {
     let zipfile = Zip64File::new();
-    let mut archive = zip::ZipArchive::new(zipfile).unwrap();
+    let mut archive = zip_next::ZipArchive::new(zipfile).unwrap();
     let mut buf = [0u8; 32];
 
     for i in 0..archive.len() {

tests/zip_comment_garbage.rs

@@ -18,7 +18,7 @@
 // 0000002e
 
 use std::io;
-use zip::ZipArchive;
+use zip_next::ZipArchive;
 
 #[test]
 fn correctly_handle_zip_with_garbage_after_comment() {

tests/zip_crypto.rs

@@ -39,7 +39,7 @@ fn encrypted_file() {
         0x00, 0x00,
     ]);
 
-    let mut archive = zip::ZipArchive::new(zip_file_bytes).unwrap();
+    let mut archive = zip_next::ZipArchive::new(zip_file_bytes).unwrap();
 
     assert_eq!(archive.len(), 1); //Only one file inside archive: `test.txt`
 
@@ -47,8 +47,8 @@ fn encrypted_file() {
         // No password
         let file = archive.by_index(0);
         match file {
-            Err(zip::result::ZipError::UnsupportedArchive(
+            Err(zip_next::result::ZipError::UnsupportedArchive(
-                zip::result::ZipError::PASSWORD_REQUIRED,
+                zip_next::result::ZipError::PASSWORD_REQUIRED,
             )) => (),
             Err(_) => panic!(
                 "Expected PasswordRequired error when opening encrypted file without password"
@@ -61,7 +61,7 @@ fn encrypted_file() {
         // Wrong password
         let file = archive.by_index_decrypt(0, b"wrong password");
         match file {
-            Ok(Err(zip::result::InvalidPassword)) => (),
+            Ok(Err(zip_next::result::InvalidPassword)) => (),
             Err(_) => panic!(
                 "Expected InvalidPassword error when opening encrypted file with wrong password"
             ),