use std::borrow::Cow;
use zip::result::ZipError;
pub(crate) fn message(err: &ZipError) -> String {
match err {
ZipError::Io(io_err) => format!("i/o error: {io_err}"),
ZipError::InvalidArchive(Cow::Borrowed(s)) => {
let s: &'static str = s;
format!("invalid Zip archive: {s}")
}
ZipError::InvalidArchive(Cow::Owned(_)) => "invalid Zip archive".to_string(),
ZipError::UnsupportedArchive(s) => {
let s: &'static str = s;
format!("unsupported Zip archive: {s}")
}
ZipError::FileNotFound => "specified file not found in archive".to_string(),
ZipError::InvalidPassword => "provided password is incorrect".to_string(),
ZipError::CompressionMethodNotSupported(id) => {
format!("compression method not supported: {id}")
}
ZipError::DecompressedSizeLimitExceeded { size, limit } => {
format!("decompressed size {size} exceeds limit {limit}")
}
ZipError::DecompressedSizeUnknown => {
"decompressed size is unknown, so a size limit cannot be checked".to_string()
}
_ => "zip error (unrecognized variant)".to_string(),
}
}
#[cfg(test)]
mod tests {
use super::message;
use std::borrow::Cow;
use std::io;
use zip::result::ZipError;
const ZIP_RETURNING: [&str; 6] = [
"ZipArchive::new",
"open_archive(",
".by_index(",
".by_name(",
".start_file(",
".finish()",
];
const SOURCES: [(&str, &str); 8] = [
("classify.rs", include_str!("classify.rs")),
("decrypt.rs", include_str!("decrypt.rs")),
("decrypt_entries.rs", include_str!("decrypt_entries.rs")),
("decrypt_stream.rs", include_str!("decrypt_stream.rs")),
("encrypt.rs", include_str!("encrypt.rs")),
("encrypt_stream.rs", include_str!("encrypt_stream.rs")),
("reencrypt.rs", include_str!("reencrypt.rs")),
("zip_stream.rs", include_str!("zip_stream.rs")),
];
#[test]
fn every_ziperror_site_routes_through_message() {
for (name, src) in SOURCES {
let lines: Vec<&str> = src.lines().collect();
for (i, line) in lines.iter().enumerate() {
if !ZIP_RETURNING.iter().any(|m| line.contains(m)) {
continue;
}
let Some(conv) = lines[i..(i + 3).min(lines.len())]
.iter()
.find(|l| l.contains(".map_err("))
else {
continue; };
assert!(
!(conv.contains("::Zip(") && conv.contains(".to_string()")),
"{name}:{} converts a ZipError with its own Display; route it \
through zip_err::message instead:\n {}",
i + 1,
line.trim()
);
}
}
}
#[test]
fn wildcard_arm_contributes_no_text_of_its_own() {
let src = include_str!("zip_err.rs");
let arm = src
.lines()
.find(|l| l.trim_start().starts_with("_ =>"))
.expect("message() must keep a wildcard arm; #[non_exhaustive] requires one");
assert!(
!arm.contains("format!") && !arm.contains('{'),
"the wildcard arm must not quote an unknown variant's Display: {}",
arm.trim()
);
}
#[test]
fn message_matches_display_for_every_known_variant() {
let cases = [
ZipError::Io(io::Error::other("disk exploded")),
ZipError::InvalidArchive(Cow::Borrowed("bad local file header")),
ZipError::UnsupportedArchive("zip64 not supported"),
ZipError::FileNotFound,
ZipError::InvalidPassword,
ZipError::CompressionMethodNotSupported(99),
ZipError::DecompressedSizeLimitExceeded { size: 7, limit: 3 },
ZipError::DecompressedSizeUnknown,
];
for case in cases {
assert_eq!(message(&case), case.to_string());
}
}
#[test]
fn an_owned_invalid_archive_message_is_not_quoted() {
let e = ZipError::InvalidArchive(Cow::Owned("Duplicate filename: EVIL".into()));
assert_eq!(message(&e), "invalid Zip archive");
assert_ne!(message(&e), e.to_string());
}
}