From a16a34f1a5a4cbe9ceb30fb984c2ebccf930d109 Mon Sep 17 00:00:00 2001 From: Danny McClanahan <1305167+cosmicexplorer@users.noreply.github.com> Date: Thu, 7 Sep 2023 00:21:31 -0400 Subject: [PATCH 1/6] use displaydoc and thiserror to remove some boilerplate --- Cargo.toml | 2 ++ src/result.rs | 51 +++++++++++---------------------------------------- src/write.rs | 5 ++++- 3 files changed, 17 insertions(+), 41 deletions(-) mode change 100644 => 100755 src/result.rs diff --git a/Cargo.toml b/Cargo.toml index fbf4c7ae..26129c36 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -28,10 +28,12 @@ bzip2-rs = { version = "0.1.2", optional = true } chrono = { version = "0.4.38", optional = true } constant_time_eq = { version = "0.3.0", optional = true } crc32fast = "1.4.0" +displaydoc = { version = "0.2.4", default-features = false } flate2 = { version = "1.0.28", default-features = false, optional = true } hmac = { version = "0.12.1", optional = true, features = ["reset"] } pbkdf2 = { version = "0.12.2", optional = true } sha1 = { version = "0.10.6", optional = true } +thiserror = "1.0.48" time = { workspace = true, optional = true, features = [ "std", ] } diff --git a/src/result.rs b/src/result.rs old mode 100644 new mode 100755 index f2bb4609..2e231144 --- a/src/result.rs +++ b/src/result.rs @@ -1,67 +1,38 @@ +#![allow(unknown_lints)] // non_local_definitions isn't in Rust 1.70 +#![allow(non_local_definitions)] //! Error types that can be emitted from this library +use displaydoc::Display; +use thiserror::Error; + use std::error::Error; use std::fmt; use std::io; -use std::io::IntoInnerError; use std::num::TryFromIntError; /// Generic result type with ZipError as its error variant pub type ZipResult = Result; /// Error type for Zip -#[derive(Debug)] +#[derive(Debug, Display, Error)] #[non_exhaustive] pub enum ZipError { - /// An Error caused by I/O - Io(io::Error), + /// i/o error: {0} + Io(#[from] io::Error), - /// This file is probably not a zip archive + /// invalid Zip archive: {0} InvalidArchive(&'static str), - /// This archive is not supported + /// unsupported Zip archive: {0} UnsupportedArchive(&'static str), - /// The requested file could not be found in the archive + /// specified file not found in archive FileNotFound, /// The password provided is incorrect InvalidPassword, } -impl From for ZipError { - fn from(err: io::Error) -> ZipError { - ZipError::Io(err) - } -} - -impl From> for ZipError { - fn from(value: IntoInnerError) -> Self { - ZipError::Io(value.into_error()) - } -} - -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"), - ZipError::InvalidPassword => write!(fmt, "incorrect password for encrypted file"), - } - } -} - -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 /// diff --git a/src/write.rs b/src/write.rs index 0051f253..379a7bd8 100644 --- a/src/write.rs +++ b/src/write.rs @@ -1418,7 +1418,10 @@ impl GenericZipWriter { #[cfg(feature = "deflate-zopfli")] GenericZipWriter::ZopfliDeflater(w) => w.finish()?, #[cfg(feature = "deflate-zopfli")] - GenericZipWriter::BufferedZopfliDeflater(w) => w.into_inner()?.finish()?, + GenericZipWriter::BufferedZopfliDeflater(w) => w + .into_inner() + .map_err(|e| ZipError::Io(e.into_error()))? + .finish()?, #[cfg(feature = "bzip2")] GenericZipWriter::Bzip2(w) => w.finish()?, #[cfg(feature = "zstd")] From 0321c0555732cd8ecdac123b52c396112814395b Mon Sep 17 00:00:00 2001 From: Jan Starke Date: Sat, 2 Mar 2024 19:49:39 +0100 Subject: [PATCH 2/6] fix some clippy warnings fix another clippy complaint ad support for extended timestamp support missing timestamps in the extended timestamps field handle inconsistencies between flags and len handle len_left add getter Update README.md to state that the crate has moved ad support for extended timestamp handle inconsistencies between flags and len handle len_left add getter Update README.md to state that the crate has moved --- README.md | 97 +------------------------- src/cp437.rs | 1 + src/extra_fields/extended_timestamp.rs | 88 +++++++++++++++++++++++ src/extra_fields/mod.rs | 29 ++++++++ src/lib.rs | 2 + src/read.rs | 24 ++++++- src/read/stream.rs | 3 +- src/types.rs | 5 ++ src/write.rs | 3 +- 9 files changed, 152 insertions(+), 100 deletions(-) create mode 100644 src/extra_fields/extended_timestamp.rs create mode 100644 src/extra_fields/mod.rs diff --git a/README.md b/README.md index f06cdbb5..3c1f9f5a 100644 --- a/README.md +++ b/README.md @@ -1,95 +1,4 @@ -zip-rs -====== +zip has moved +============= -[![Build Status](https://img.shields.io/github/workflow/status/zip-rs/zip/CI)](https://github.com/zip-rs/zip/actions?query=branch%3Amaster+workflow%3ACI) -[![Crates.io version](https://img.shields.io/crates/v/zip.svg)](https://crates.io/crates/zip) -[![Discord](https://badgen.net/badge/icon/discord?icon=discord&label)](https://discord.gg/rQ7H9cSsF4) - -[Documentation](https://docs.rs/zip/0.6.3/zip/) - -Info ----- - - -A zip library for rust which supports reading and writing of simple ZIP files. - -Supported compression formats: - -* stored (i.e. none) -* deflate -* bzip2 -* zstd - -Currently unsupported zip extensions: - -* Encryption -* Multi-disk - -Usage ------ - -With all default features: - -```toml -[dependencies] -zip = "0.6" -``` - -Without the default features: - -```toml -[dependencies] -zip = { version = "0.6.6", default-features = false } -``` - -The features available are: - -* `aes-crypto`: Enables decryption of files which were encrypted with AES. Supports AE-1 and AE-2 methods. -* `deflate`: Enables the deflate compression algorithm, which is the default for zip files. -* `bzip2`: Enables the BZip2 compression algorithm. -* `time`: Enables features using the [time](https://github.com/rust-lang-deprecated/time) crate. -* `zstd`: Enables the Zstandard compression algorithm. - -All of these are enabled by default. - -MSRV ----- - -Our current Minimum Supported Rust Version is **1.59.0**. When adding features, -we will follow these guidelines: - -- We will always support the latest four minor Rust versions. This gives you a 6 - month window to upgrade your compiler. -- Any change to the MSRV will be accompanied with a **minor** version bump - - While the crate is pre-1.0, this will be a change to the PATCH version. - -Examples --------- - -See the [examples directory](examples) for: - * How to write a file to a zip. - * How to write a directory of files to a zip (using [walkdir](https://github.com/BurntSushi/walkdir)). - * How to extract a zip file. - * How to extract a single file from a zip. - * How to read a zip from the standard input. - -Fuzzing -------- - -Fuzzing support is through [cargo fuzz](https://github.com/rust-fuzz/cargo-fuzz). To install cargo fuzz: - -```bash -cargo install cargo-fuzz -``` - -To list fuzz targets: - -```bash -cargo +nightly fuzz list -``` - -To start fuzzing zip extraction: - -```bash -cargo +nightly fuzz run fuzz_read -``` +This repository was formerly the source of the [zip](https://crates.io/crates/zip) Rust crate for compressing and decompressing ZIP files, but that has moved to https://github.com/Pr0methean/zip. Please submit all issues and pull requests there, and close any existing copies here. Once the existing ones are closed, this repository will be archived. diff --git a/src/cp437.rs b/src/cp437.rs index 4dba9af1..696c0506 100644 --- a/src/cp437.rs +++ b/src/cp437.rs @@ -187,6 +187,7 @@ mod test { } #[test] + #[allow(invalid_from_utf8)] fn example_slice() { use super::FromCp437; let data = b"Cura\x87ao"; diff --git a/src/extra_fields/extended_timestamp.rs b/src/extra_fields/extended_timestamp.rs new file mode 100644 index 00000000..26f2943c --- /dev/null +++ b/src/extra_fields/extended_timestamp.rs @@ -0,0 +1,88 @@ +use std::io::Read; + +use byteorder::LittleEndian; +use byteorder::ReadBytesExt; + +use crate::result::{ZipError, ZipResult}; + +/// extended timestamp, as described in + +#[derive(Debug, Clone)] +pub struct ExtendedTimestamp { + mod_time: Option, + ac_time: Option, + cr_time: Option, +} + +impl ExtendedTimestamp { + /// creates an extended timestamp struct by reading the required bytes from the reader. + /// + /// This method assumes that the length has already been read, therefore + /// it must be passed as an argument + pub fn try_from_reader(reader: &mut R, len: u16) -> ZipResult + where + R: Read, + { + let flags = reader.read_u8()?; + + // the `flags` field refers to the local headers and might not correspond + // to the len field. If the length field is 1+4, we assume that only + // the modification time has been set + + // > Those times that are present will appear in the order indicated, but + // > any combination of times may be omitted. (Creation time may be + // > present without access time, for example.) TSize should equal + // > (1 + 4*(number of set bits in Flags)), as the block is currently + // > defined. + if len != 5 && len as u32 != 1 + 4 * flags.count_ones() { + //panic!("found len {len} and flags {flags:08b}"); + return Err(ZipError::UnsupportedArchive( + "flags and len don't match in extended timestamp field", + )); + } + + if flags & 0b11111000 != 0 { + return Err(ZipError::UnsupportedArchive( + "found unsupported timestamps in the extended timestamp header", + )); + } + + let mod_time = if (flags & 0b00000001u8 == 0b00000001u8) || len == 5 { + Some(reader.read_u32::()?) + } else { + None + }; + + let ac_time = if flags & 0b00000010u8 == 0b00000010u8 && len > 5 { + Some(reader.read_u32::()?) + } else { + None + }; + + let cr_time = if flags & 0b00000100u8 == 0b00000100u8 && len > 5 { + Some(reader.read_u32::()?) + } else { + None + }; + Ok(Self { + mod_time, + ac_time, + cr_time, + }) + } + + /// returns the last modification timestamp + pub fn mod_time(&self) -> Option<&u32> { + self.mod_time.as_ref() + } + + /// returns the last access timestamp + pub fn ac_time(&self) -> Option<&u32> { + self.ac_time.as_ref() + } + + /// returns the creation timestamp + pub fn cr_time(&self) -> Option<&u32> { + self.cr_time.as_ref() + } +} diff --git a/src/extra_fields/mod.rs b/src/extra_fields/mod.rs new file mode 100644 index 00000000..9ccfdd6c --- /dev/null +++ b/src/extra_fields/mod.rs @@ -0,0 +1,29 @@ +//! types for extra fields + +/// marker trait to denote the place where this extra field has been stored +pub trait ExtraFieldVersion {} + +/// use this to mark extra fields specified in a local header + +#[derive(Debug, Clone)] +pub struct LocalHeaderVersion; + +/// use this to mark extra fields specified in the central header + +#[derive(Debug, Clone)] +pub struct CentralHeaderVersion; + +impl ExtraFieldVersion for LocalHeaderVersion {} +impl ExtraFieldVersion for CentralHeaderVersion {} + +mod extended_timestamp; + +pub use extended_timestamp::*; + +/// contains one extra field +#[derive(Debug, Clone)] +pub enum ExtraField { + + /// extended timestamp, as described in + ExtendedTimestamp(ExtendedTimestamp) +} diff --git a/src/lib.rs b/src/lib.rs index e2228e5b..45aeca60 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -42,6 +42,8 @@ mod spec; mod types; pub mod write; mod zipcrypto; +pub mod extra_fields; +pub use extra_fields::ExtraField; /// Unstable APIs /// diff --git a/src/read.rs b/src/read.rs index b702b4f2..8dedd1d1 100644 --- a/src/read.rs +++ b/src/read.rs @@ -5,6 +5,7 @@ use crate::aes::{AesReader, AesReaderValid}; use crate::compression::CompressionMethod; use crate::cp437::FromCp437; use crate::crc32::Crc32Reader; +use crate::extra_fields::{ExtendedTimestamp, ExtraField}; use crate::result::{InvalidPassword, ZipError, ZipResult}; use crate::spec; use crate::types::{AesMode, AesVendorVersion, AtomicU64, DateTime, System, ZipFileData}; @@ -724,6 +725,7 @@ fn central_header_to_zip_file_inner( external_attributes: external_file_attributes, large_file: false, aes_mode: None, + extra_fields: Vec::new(), }; match parse_extra_field(&mut result) { @@ -803,6 +805,17 @@ fn parse_extra_field(file: &mut ZipFileData) -> ZipResult<()> { CompressionMethod::from_u16(compression_method) }; } + 0x5455 => { + // extended timestamp + // https://libzip.org/specifications/extrafld.txt + + file.extra_fields.push(ExtraField::ExtendedTimestamp( + ExtendedTimestamp::try_from_reader(&mut reader, len)?, + )); + + // the reader for ExtendedTimestamp consumes `len` bytes + len_left = 0; + } _ => { // Other fields are ignored } @@ -935,8 +948,7 @@ impl<'a> ZipFile<'a> { pub fn is_dir(&self) -> bool { self.name() .chars() - .rev() - .next() + .next_back() .map_or(false, |c| c == '/' || c == '\\') } @@ -973,6 +985,11 @@ impl<'a> ZipFile<'a> { pub fn central_header_start(&self) -> u64 { self.data.central_header_start } + + /// iterate through all extra fields + pub fn extra_data_fields(&self) -> impl Iterator { + self.data.extra_fields.iter() + } } impl<'a> Read for ZipFile<'a> { @@ -991,7 +1008,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 => { @@ -1091,6 +1108,7 @@ pub fn read_zipfile_from_stream<'a, R: io::Read>( external_attributes: 0, large_file: false, aes_mode: None, + extra_fields: Vec::new(), }; match parse_extra_field(&mut result) { diff --git a/src/read/stream.rs b/src/read/stream.rs index 5a01b23f..dc967ee8 100644 --- a/src/read/stream.rs +++ b/src/read/stream.rs @@ -184,8 +184,7 @@ impl ZipStreamFileMetadata { pub fn is_dir(&self) -> bool { self.name() .chars() - .rev() - .next() + .next_back() .map_or(false, |c| c == '/' || c == '\\') } diff --git a/src/types.rs b/src/types.rs index c3d0a45d..e496015a 100644 --- a/src/types.rs +++ b/src/types.rs @@ -49,6 +49,7 @@ mod atomic { } } +use crate::extra_fields::ExtraField; #[cfg(feature = "time")] use crate::result::DateTimeRangeError; #[cfg(feature = "time")] @@ -350,6 +351,9 @@ pub struct ZipFileData { pub large_file: bool, /// AES mode if applicable pub aes_mode: Option<(AesMode, AesVendorVersion)>, + + /// extra fields, see + pub extra_fields: Vec, } impl ZipFileData { @@ -508,6 +512,7 @@ mod test { external_attributes: 0, large_file: false, aes_mode: None, + extra_fields: Vec::new(), }; assert_eq!( data.file_name_sanitized(), diff --git a/src/write.rs b/src/write.rs index 4cdc031b..4b1d2cbd 100644 --- a/src/write.rs +++ b/src/write.rs @@ -397,6 +397,7 @@ impl ZipWriter { external_attributes: permissions << 16, large_file: options.large_file, aes_mode: None, + extra_fields: Vec::new(), }; write_local_file_header(writer, &file)?; @@ -411,7 +412,7 @@ impl ZipWriter { } if let Some(keys) = options.encrypt_with { let mut zipwriter = crate::zipcrypto::ZipCryptoWriter { writer: core::mem::replace(&mut self.inner, GenericZipWriter::Closed).unwrap(), buffer: vec![], keys }; - let mut crypto_header = [0u8; 12]; + let crypto_header = [0u8; 12]; zipwriter.write_all(&crypto_header)?; self.inner = GenericZipWriter::Storer(MaybeEncrypted::Encrypted(zipwriter)); From 09331a935e592e0d3e5a15f9bfa814e667aae056 Mon Sep 17 00:00:00 2001 From: Jan Starke Date: Thu, 2 May 2024 09:24:05 +0200 Subject: [PATCH 3/6] add clippy exclusion --- src/read.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/read.rs b/src/read.rs index 8dedd1d1..3c5ba04a 100644 --- a/src/read.rs +++ b/src/read.rs @@ -1017,6 +1017,7 @@ impl<'a> Drop for ZipFile<'a> { } }; + #[allow(clippy::unused_io_amount)] loop { match reader.read(&mut buffer) { Ok(0) => break, From ccaba9df74f89baae82ffa5a861284e3f54dc11f Mon Sep 17 00:00:00 2001 From: Jan Starke Date: Thu, 2 May 2024 09:34:20 +0200 Subject: [PATCH 4/6] add test case for extended timestamp --- tests/data/extended_timestamp.zip | Bin 0 -> 297 bytes tests/zip_extended_timestamp.rs | 19 +++++++++++++++++++ 2 files changed, 19 insertions(+) create mode 100644 tests/data/extended_timestamp.zip create mode 100644 tests/zip_extended_timestamp.rs diff --git a/tests/data/extended_timestamp.zip b/tests/data/extended_timestamp.zip new file mode 100644 index 0000000000000000000000000000000000000000..aa93eb62afa3520fefa674de59f49693032803b1 GIT binary patch literal 297 zcmWIWW@Zs#fB;2?xMM~<>Oc+%a{zH}W^QUpWkG6UK|xMta$-qlex80=UW#6RVsU1% zUVcGpUP^v)X>Mv>iC#%+MM(hAFfOoJXT29ifEiGNgF%L&B()f*tfC||gp+|;(9t+e z9*9dTxEUB(UNAE-fQbNaMkYOG+zx`7xug-qf;kVQOO6?r%@Qz83|ks~foz03SRwAf Ta04qFNDC7XwgBmV5QhN(bWS#E literal 0 HcmV?d00001 diff --git a/tests/zip_extended_timestamp.rs b/tests/zip_extended_timestamp.rs new file mode 100644 index 00000000..9fecbacd --- /dev/null +++ b/tests/zip_extended_timestamp.rs @@ -0,0 +1,19 @@ +use std::io; +use zip::ZipArchive; + +#[test] +fn test_extended_timestamp() { + let mut v = Vec::new(); + v.extend_from_slice(include_bytes!("../tests/data/extended_timestamp.zip")); + let mut archive = ZipArchive::new(io::Cursor::new(v)).expect("couldn't open test zip file"); + + for field in archive.by_name("test.txt").unwrap().extra_data_fields() { + match field { + zip::ExtraField::ExtendedTimestamp(ts) => { + assert!(ts.ac_time().is_none()); + assert!(ts.cr_time().is_none()); + assert_eq!(*ts.mod_time().unwrap(), 1714635025); + }, + } + } +} From a994667db62c166fd5f8db31f32472d560358a11 Mon Sep 17 00:00:00 2001 From: Chris Hennick <4961925+Pr0methean@users.noreply.github.com> Date: Thu, 2 May 2024 09:39:50 -0700 Subject: [PATCH 5/6] style: remove extra spaces before comment --- src/result.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/result.rs b/src/result.rs index 2e231144..391a6a82 100755 --- a/src/result.rs +++ b/src/result.rs @@ -1,4 +1,4 @@ -#![allow(unknown_lints)] // non_local_definitions isn't in Rust 1.70 +#![allow(unknown_lints)] // non_local_definitions isn't in Rust 1.70 #![allow(non_local_definitions)] //! Error types that can be emitted from this library From 9af296d080a93668f71009c49f4f18cd7e6c60de Mon Sep 17 00:00:00 2001 From: Chris Hennick <4961925+Pr0methean@users.noreply.github.com> Date: Thu, 2 May 2024 10:55:41 -0700 Subject: [PATCH 6/6] style: cargo fmt --all, fix bzip2 error --- src/extra_fields/extended_timestamp.rs | 2 +- src/extra_fields/mod.rs | 3 +-- src/lib.rs | 2 +- src/read.rs | 8 ++++---- tests/zip_extended_timestamp.rs | 2 +- 5 files changed, 8 insertions(+), 9 deletions(-) diff --git a/src/extra_fields/extended_timestamp.rs b/src/extra_fields/extended_timestamp.rs index 26f2943c..e5e3fb70 100644 --- a/src/extra_fields/extended_timestamp.rs +++ b/src/extra_fields/extended_timestamp.rs @@ -17,7 +17,7 @@ pub struct ExtendedTimestamp { impl ExtendedTimestamp { /// creates an extended timestamp struct by reading the required bytes from the reader. /// - /// This method assumes that the length has already been read, therefore + /// This method assumes that the length has already been read, therefore /// it must be passed as an argument pub fn try_from_reader(reader: &mut R, len: u16) -> ZipResult where diff --git a/src/extra_fields/mod.rs b/src/extra_fields/mod.rs index 9ccfdd6c..145cfade 100644 --- a/src/extra_fields/mod.rs +++ b/src/extra_fields/mod.rs @@ -23,7 +23,6 @@ pub use extended_timestamp::*; /// contains one extra field #[derive(Debug, Clone)] pub enum ExtraField { - /// extended timestamp, as described in - ExtendedTimestamp(ExtendedTimestamp) + ExtendedTimestamp(ExtendedTimestamp), } diff --git a/src/lib.rs b/src/lib.rs index b2ef9445..8ece3c20 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -39,13 +39,13 @@ mod aes_ctr; mod compression; mod cp437; mod crc32; +pub mod extra_fields; pub mod read; pub mod result; mod spec; mod types; pub mod write; mod zipcrypto; -pub mod extra_fields; pub use extra_fields::ExtraField; #[doc = "Unstable APIs\n\ diff --git a/src/read.rs b/src/read.rs index 3491b764..f76de446 100644 --- a/src/read.rs +++ b/src/read.rs @@ -30,7 +30,7 @@ use flate2::read::DeflateDecoder; use deflate64::Deflate64Decoder; #[cfg(feature = "bzip2")] -use bzip2::read::BzDecoder; +use bzip2_rs::decoder::DecoderReader; #[cfg(feature = "zstd")] use zstd::stream::read::Decoder as ZstdDecoder; @@ -146,7 +146,7 @@ pub(crate) enum ZipFileReader<'a> { #[cfg(feature = "deflate64")] Deflate64(Crc32Reader>>>), #[cfg(feature = "bzip2")] - Bzip2(Crc32Reader>>), + Bzip2(Crc32Reader>>), #[cfg(feature = "zstd")] Zstd(Crc32Reader>>>), #[cfg(feature = "lzma")] @@ -307,7 +307,7 @@ pub(crate) fn make_reader( } #[cfg(feature = "bzip2")] CompressionMethod::Bzip2 => { - let bzip2_reader = BzDecoder::new(reader); + let bzip2_reader = DecoderReader::new(reader); ZipFileReader::Bzip2(Crc32Reader::new(bzip2_reader, crc32, ae2_encrypted)) } #[cfg(feature = "zstd")] @@ -1102,7 +1102,7 @@ impl<'a> ZipFile<'a> { } /// iterate through all extra fields - pub fn extra_data_fields(&self) -> impl Iterator { + pub fn extra_data_fields(&self) -> impl Iterator { self.data.extra_fields.iter() } } diff --git a/tests/zip_extended_timestamp.rs b/tests/zip_extended_timestamp.rs index 9fecbacd..983e4fb5 100644 --- a/tests/zip_extended_timestamp.rs +++ b/tests/zip_extended_timestamp.rs @@ -13,7 +13,7 @@ fn test_extended_timestamp() { assert!(ts.ac_time().is_none()); assert!(ts.cr_time().is_none()); assert_eq!(*ts.mod_time().unwrap(), 1714635025); - }, + } } } }