From cde5d5ed11a91fe3217ee27ad1ac9135326ce20d Mon Sep 17 00:00:00 2001 From: Chris Hennick Date: Sun, 23 Apr 2023 14:33:10 -0700 Subject: [PATCH] Implement shallow copy from within the file being written --- Cargo.toml | 7 +-- README.md | 4 +- benches/read_entry.rs | 4 +- benches/read_metadata.rs | 4 +- examples/extract.rs | 2 +- examples/extract_lorem.rs | 2 +- examples/file_info.rs | 2 +- examples/stdin_info.rs | 2 +- examples/write_dir.rs | 28 +++++------ examples/write_sample.rs | 8 +-- fuzz/fuzz_targets/fuzz_read.rs | 2 +- src/lib.rs | 2 +- src/read.rs | 22 ++++---- src/result.rs | 4 +- src/write.rs | 92 ++++++++++++++++++++++++++++------ tests/aes_encryption.rs | 2 +- tests/end_to_end.rs | 28 +++++------ tests/invalid_date.rs | 2 +- tests/issue_234.rs | 4 +- tests/zip64_large.rs | 2 +- tests/zip_comment_garbage.rs | 2 +- tests/zip_crypto.rs | 8 +-- 22 files changed, 148 insertions(+), 85 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 5468919a..474d09cd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,8 @@ [package] -name = "zip" -version = "0.6.4" -authors = ["Mathijs van de Nes ", "Marli Frost ", "Ryan Levick "] +name = "zip_next" +version = "0.6.5" +authors = ["Mathijs van de Nes ", "Marli Frost ", "Ryan Levick ", +"Chris Hennick "] license = "MIT" repository = "https://github.com/zip-rs/zip.git" keywords = ["zip", "archive"] diff --git a/README.md b/README.md index d8f91b78..257ed5cd 100644 --- a/README.md +++ b/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: diff --git a/benches/read_entry.rs b/benches/read_entry.rs index af9affe3..03b94fe4 100644 --- a/benches/read_entry.rs +++ b/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 { 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]; diff --git a/benches/read_metadata.rs b/benches/read_metadata.rs index 95334b1c..295cd050 100644 --- a/benches/read_metadata.rs +++ b/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 { 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]; diff --git a/examples/extract.rs b/examples/extract.rs index 30807162..e5bad04c 100644 --- a/examples/extract.rs +++ b/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(); diff --git a/examples/extract_lorem.rs b/examples/extract_lorem.rs index bc50abe1..0d1705c5 100644 --- a/examples/extract_lorem.rs +++ b/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, diff --git a/examples/file_info.rs b/examples/file_info.rs index 6a2adc58..1730eb8d 100644 --- a/examples/file_info.rs +++ b/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(); diff --git a/examples/stdin_info.rs b/examples/stdin_info.rs index a609916a..f49d6e73 100644 --- a/examples/stdin_info.rs +++ b/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)", diff --git a/examples/write_dir.rs b/examples/write_dir.rs index 3b043528..429e136e 100644 --- a/examples/write_dir.rs +++ b/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::write::FileOptions; +use zip_next::result::ZipError; +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 = Some(zip::CompressionMethod::Stored); +const METHOD_STORED: Option = Some(zip_next::CompressionMethod::Stored); #[cfg(any( feature = "deflate", feature = "deflate-miniz", feature = "deflate-zlib" ))] -const METHOD_DEFLATED: Option = Some(zip::CompressionMethod::Deflated); +const METHOD_DEFLATED: Option = Some(zip_next::CompressionMethod::Deflated); #[cfg(not(any( feature = "deflate", feature = "deflate-miniz", feature = "deflate-zlib" )))] -const METHOD_DEFLATED: Option = None; +const METHOD_DEFLATED: Option = None; #[cfg(feature = "bzip2")] -const METHOD_BZIP2: Option = Some(zip::CompressionMethod::Bzip2); +const METHOD_BZIP2: Option = Some(zip_next::CompressionMethod::Bzip2); #[cfg(not(feature = "bzip2"))] -const METHOD_BZIP2: Option = None; +const METHOD_BZIP2: Option = None; #[cfg(feature = "zstd")] -const METHOD_ZSTD: Option = Some(zip::CompressionMethod::Zstd); +const METHOD_ZSTD: Option = Some(zip_next::CompressionMethod::Zstd); #[cfg(not(feature = "zstd"))] -const METHOD_ZSTD: Option = None; +const METHOD_ZSTD: Option = None; fn real_main() -> i32 { let args: Vec<_> = std::env::args().collect(); @@ -66,12 +66,12 @@ fn zip_dir( it: &mut dyn Iterator, prefix: &str, writer: T, - method: zip::CompressionMethod, -) -> zip::result::ZipResult<()> + method: zip_next::CompressionMethod, +) -> 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, -) -> zip::result::ZipResult<()> { + method: zip_next::CompressionMethod, +) -> zip_next::result::ZipResult<()> { if !Path::new(src_dir).is_dir() { return Err(ZipError::FileNotFound); } diff --git a/examples/write_sample.rs b/examples/write_sample.rs index 2e45cb1e..bb9739d0 100644 --- a/examples/write_sample.rs +++ b/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")?; diff --git a/fuzz/fuzz_targets/fuzz_read.rs b/fuzz/fuzz_targets/fuzz_read.rs index 97fbdd3b..359cf227 100644 --- a/fuzz/fuzz_targets/fuzz_read.rs +++ b/fuzz/fuzz_targets/fuzz_read.rs @@ -3,7 +3,7 @@ use libfuzzer_sys::fuzz_target; fn decompress_all(data: &[u8]) -> Result<(), Box> { 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)?; diff --git a/src/lib.rs b/src/lib.rs index 7f3e7a01..8975837d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -21,7 +21,7 @@ //! //! //! - +#![feature(read_buf)] #![warn(missing_docs)] pub use crate::compression::{CompressionMethod, SUPPORTED_COMPRESSION_METHODS}; diff --git a/src/read.rs b/src/read.rs index b702b4f2..e7400ef3 100644 --- a/src/read.rs +++ b/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<()> { - /// let mut zip = zip::ZipArchive::new(reader)?; + /// fn list_zip_contents(reader: impl Read + Seek) -> zip_next::result::ZipResult<()> { + /// 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>), #[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>), @@ -178,12 +178,12 @@ impl<'a> ZipFileReader<'a> { /// A struct for reading a zip file pub struct ZipFile<'a> { - data: Cow<'a, ZipFileData>, - crypto_reader: Option>, - reader: ZipFileReader<'a>, + pub(crate) data: Cow<'a, ZipFileData>, + pub(crate) crypto_reader: Option>, + pub(crate) reader: ZipFileReader<'a>, } -fn find_content<'a>( +pub(crate) fn find_content<'a>( data: &ZipFileData, reader: &'a mut (impl Read + Seek), ) -> ZipResult> { @@ -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 => { diff --git a/src/result.rs b/src/result.rs index 00d558cb..11b10ad0 100644 --- a/src/result.rs +++ b/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; - /// # let mut archive = zip::ZipArchive::new(std::io::Cursor::new(&[])).unwrap(); + /// # use zip_next::result::ZipError; + /// # 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"), /// _ => (), diff --git a/src/write.rs b/src/write.rs index 3f41c4d6..14f73658 100644 --- a/src/write.rs +++ b/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, + pub(super) comment: Vec } } pub use zip_writer::ZipWriter; @@ -291,7 +291,7 @@ impl ZipWriter { 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 ZipWriter { 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 ZipWriter { /// /// ``` /// use byteorder::{LittleEndian, WriteBytesExt}; - /// use zip::{ZipArchive, ZipWriter, result::ZipResult}; - /// use zip::{write::FileOptions, CompressionMethod}; + /// use zip_next::{ZipArchive, ZipWriter, result::ZipResult}; + /// use zip_next::{write::FileOptions, CompressionMethod}; /// use std::io::{Write, Cursor}; /// /// # fn main() -> ZipResult<()> { @@ -623,12 +623,12 @@ impl ZipWriter { /// ```no_run /// use std::fs::File; /// use std::io::{Read, Seek, Write}; - /// use zip::{ZipArchive, ZipWriter}; + /// use zip_next::{ZipArchive, ZipWriter}; /// /// fn copy_rename( /// src: &mut ZipArchive, /// dst: &mut ZipWriter, - /// ) -> zip::result::ZipResult<()> + /// ) -> zip_next::result::ZipResult<()> /// where /// R: Read + Seek, /// W: Write + Seek, @@ -676,9 +676,9 @@ impl ZipWriter { /// ```no_run /// use std::fs::File; /// use std::io::{Read, Seek, Write}; - /// use zip::{ZipArchive, ZipWriter}; + /// use zip_next::{ZipArchive, ZipWriter}; /// - /// fn copy(src: &mut ZipArchive, dst: &mut ZipWriter) -> zip::result::ZipResult<()> + /// fn copy(src: &mut ZipArchive, dst: &mut ZipWriter) -> zip_next::result::ZipResult<()> /// where /// R: Read + Seek, /// W: Write + Seek, @@ -841,6 +841,32 @@ impl ZipWriter { } } +impl ZipWriter { + 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 Drop for ZipWriter { 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(); diff --git a/tests/aes_encryption.rs b/tests/aes_encryption.rs index 4b393ebf..eaad6888 100644 --- a/tests/aes_encryption.rs +++ b/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"; diff --git a/tests/end_to_end.rs b/tests/end_to_end.rs index 09e7ce47..b5dedf32 100644 --- a/tests/end_to_end.rs +++ b/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::{CompressionMethod, SUPPORTED_COMPRESSION_METHODS}; +use zip_next::write::FileOptions; +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 zip = zip::ZipWriter::new(&mut tgt_file); + let mut src_archive = zip_next::ZipArchive::new(src_file).unwrap(); + 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>, method: CompressionMethod, -) -> zip::result::ZipResult<()> { - let mut zip = zip::ZipWriter::new(file); +) -> zip_next::result::ZipResult<()> { + 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(zip_file: R) -> zip::result::ZipResult> { - let mut archive = zip::ZipArchive::new(zip_file).unwrap(); +fn check_test_archive(zip_file: R) -> zip_next::result::ZipResult> { + let mut archive = zip_next::ZipArchive::new(zip_file).unwrap(); // Check archive contains expected file names. { @@ -147,9 +147,9 @@ fn check_test_archive(zip_file: R) -> zip::result::ZipResult( - archive: &mut zip::ZipArchive, + archive: &mut zip_next::ZipArchive, name: &str, -) -> zip::result::ZipResult { +) -> zip_next::result::ZipResult { 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( - archive: &mut zip::ZipArchive, + archive: &mut zip_next::ZipArchive, name: &str, expected: &[u8], ) { diff --git a/tests/invalid_date.rs b/tests/invalid_date.rs index 3f24e251..b684bf6a 100644 --- a/tests/invalid_date.rs +++ b/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, diff --git a/tests/issue_234.rs b/tests/issue_234.rs index f8c1d2c8..48e5d668 100644 --- a/tests/issue_234.rs +++ b/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:?}"), diff --git a/tests/zip64_large.rs b/tests/zip64_large.rs index 468ef198..7cbdd1b5 100644 --- a/tests/zip64_large.rs +++ b/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() { diff --git a/tests/zip_comment_garbage.rs b/tests/zip_comment_garbage.rs index ef4d9750..73702a08 100644 --- a/tests/zip_comment_garbage.rs +++ b/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() { diff --git a/tests/zip_crypto.rs b/tests/zip_crypto.rs index 6c4d6b81..3251e4a6 100644 --- a/tests/zip_crypto.rs +++ b/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( - zip::result::ZipError::PASSWORD_REQUIRED, + Err(zip_next::result::ZipError::UnsupportedArchive( + 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" ),