DevComp/zip-rs-wasm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Implement shallow copy from within the file being written

Browse source
This commit is contained in:
Chris Hennick 2023-04-23 14:33:10 -07:00
parent e32db515a2
commit cde5d5ed11
No known key found for this signature in database
GPG key ID: 25653935CC8B6C74
22 changed files with 148 additions and 85 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
Cargo.toml
View file

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

4
README.md
View file

@ -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:

4
benches/read_entry.rs
View file

@ -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];

4
benches/read_metadata.rs
View file

@ -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];

2
examples/extract.rs
View file

@ -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();

2
examples/extract_lorem.rs
View file

@ -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,

2
examples/file_info.rs
View file

@ -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();

2
examples/stdin_info.rs
View file

@ -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)",

28
examples/write_dir.rs
View file

@ -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<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,
) -> 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);
}

8
examples/write_sample.rs
View file

@ -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")?;

2
fuzz/fuzz_targets/fuzz_read.rs
View file

@ -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)?;

2
src/lib.rs
View file

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

22
src/read.rs
View file

@ -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<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>,
crypto_reader: Option<CryptoReader<'a>>,
reader: ZipFileReader<'a>,
pub(crate) data: Cow<'a, ZipFileData>,
pub(crate) crypto_reader: Option<CryptoReader<'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 => {

4
src/result.rs
View file

@ -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"),
/// _ => (),

92
src/write.rs
View file

@ -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::{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<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();

2
tests/aes_encryption.rs
View file

@ -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";

28
tests/end_to_end.rs
View file

@ -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<Vec<u8>>,
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<R: Read + Seek>(zip_file: R) -> zip::result::ZipResult<zip::ZipArchive<R>> {
let mut archive = zip::ZipArchive::new(zip_file).unwrap();
fn check_test_archive<R: Read + Seek>(zip_file: R) -> zip_next::result::ZipResult<zip_next::ZipArchive<R>> {
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],
) {

2
tests/invalid_date.rs
View file

@ -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,

4
tests/issue_234.rs
View file

@ -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:?}"),

2
tests/zip64_large.rs
View file

@ -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() {

2
tests/zip_comment_garbage.rs
View file

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

8
tests/zip_crypto.rs
View file

@ -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"
),