16 files changed, 267 insertions, 174 deletions

diff --git a/.vscode/settings.json b/.vscode/settings.json
index de3e119..b0a2099 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -5,11 +5,15 @@
     "chrono",
     "datatypes",
     "datetime",
+    "decompressor",
     "eocdr",
-    "LZMA",
+    "flate",
+    "lzma",
     "newtype",
     "repr",
-    "rposition"
+    "rposition",
+    "seekable",
+    "unseekable"
   ],
   "rust-analyzer.linkedProjects": ["./Cargo.toml", "./Cargo.toml"]
 }
diff --git a/Cargo.toml b/Cargo.toml
index f2ae11c..fe6ca40 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,6 +12,8 @@ categories = ["compression", "filesystem"]
 exclude = [".vscode/"]
 
 [dependencies]
+bzip2 = "0.4.4"
 chrono = "0.4.29"
 flate2 = "1.0.30"
 serde = { version = "1.0.203", features = ["derive"] }
+xz2 = "0.1.7"
diff --git a/src/archive.rs b/src/archive.rs
index 8a9e8de..2dab393 100644
--- a/src/archive.rs
+++ b/src/archive.rs
@@ -25,19 +25,19 @@ where
         Self::read(File::open(path)?)
     }
 
-    pub fn files(&self) -> &Vec<D::FileInfo> {
+    pub fn files(&self) -> Vec<&D::FileInfo> {
         self.driver.files()
     }
 
-    pub fn get_file_info(&self, index: usize) -> ArchiveResult<&D::FileInfo, D::Error> {
-        self.driver.get_file_info(index)
+    pub fn get_file_info(&self, name: &str) -> ArchiveResult<&D::FileInfo, D::Error> {
+        self.driver.get_file_info(name)
     }
 
     pub fn get_file_reader<'d>(
         &'d mut self,
-        index: usize,
-    ) -> ArchiveResult<ArchiveFile<D::FileDriver<'d>>, D::Error> {
-        Ok(ArchiveFile::new(self.driver.get_file_reader(index)?))
+        name: &str,
+    ) -> ArchiveResult<ArchiveFile<D::FileReader<'d>>, D::Error> {
+        Ok(ArchiveFile::new(self.driver.get_file_reader(name)?))
     }
 }
 
diff --git a/src/driver/driver.rs b/src/driver/driver.rs
index 4c6baad..f7f1f24 100644
--- a/src/driver/driver.rs
+++ b/src/driver/driver.rs
@@ -8,34 +8,37 @@ pub trait Driver: Sized {
 
     type Io;
     type FileInfo: ArchiveFileInfo;
-    type FileDriver<'d>: FileDriver
-    where
-        Self::FileInfo: 'd,
-        Self::Io: 'd;
 }
 
 pub trait ArchiveRead: Driver
 where
     Self::Io: Read,
 {
+    type FileReader<'d>: FileDriver
+    where
+        Self: 'd;
+
     // Create driver instance
     fn read(io: Self::Io) -> ArchiveResult<Self, Self::Error>;
 
     // Return vec of file info
-    fn files(&self) -> &Vec<Self::FileInfo>;
+    fn files(&self) -> Vec<&Self::FileInfo>;
 
     // Return file info by index
-    fn get_file_info(&self, index: usize) -> ArchiveResult<&Self::FileInfo, Self::Error>;
+    fn get_file_info(&self, name: &str) -> ArchiveResult<&Self::FileInfo, Self::Error>;
 
     // Return file reader by index
     fn get_file_reader<'d>(
         &'d mut self,
-        index: usize,
-    ) -> ArchiveResult<Self::FileDriver<'d>, Self::Error>;
+        name: &str,
+    ) -> ArchiveResult<Self::FileReader<'d>, Self::Error>;
 }
 
 pub trait ArchiveWrite: Driver
 where
     Self::Io: Read + Write,
 {
+    type FileWriter<'d>: FileDriver
+    where
+        Self: 'd;
 }
diff --git a/src/zip/driver.rs b/src/zip/driver.rs
index a280dc7..e276844 100644
--- a/src/zip/driver.rs
+++ b/src/zip/driver.rs
@@ -1,13 +1,17 @@
 use crate::driver::{ArchiveRead, ArchiveWrite, Driver};
 use crate::zip::structs::{deserialize, EOCDR64Locator, ExtraHeader, CDR, EOCDR, EOCDR64};
-use crate::zip::{BitFlag, CompressionMethod, ZipError, ZipFile, ZipFileInfo, ZipResult};
+use crate::zip::{
+    BitFlag, CompressionMethod, ZipError, ZipFileInfo, ZipFileReader, ZipFileWriter, ZipResult,
+};
 use chrono::{Local, NaiveDate, NaiveDateTime, NaiveTime};
+use std::collections::HashMap as Map;
+use std::fs::File;
 use std::io::{Read, Seek, SeekFrom, Write};
 
-pub struct Zip<Io> {
+pub struct Zip<Io = File> {
     io: Io,
 
-    files: Vec<ZipFileInfo>,
+    files: Map<String, ZipFileInfo>,
     comment: String,
 }
 
@@ -15,11 +19,12 @@ impl<Io> Driver for Zip<Io> {
     type Error = ZipError;
 
     type Io = Io;
-    type FileDriver<'d> = ZipFile<'d, Self::Io> where Self::Io: 'd;
     type FileInfo = ZipFileInfo;
 }
 
 impl<Io: Read + Seek> ArchiveRead for Zip<Io> {
+    type FileReader<'d> = ZipFileReader<'d, Io> where Io: 'd;
+
     fn read(mut io: Self::Io) -> ZipResult<Self> {
         // Search eocdr
         let limit = 65557.min(io.seek(SeekFrom::End(0))?) as i64;
@@ -79,7 +84,7 @@ impl<Io: Read + Seek> ArchiveRead for Zip<Io> {
             };
 
         // Read cd records
-        let mut files = Vec::with_capacity(cd_records as usize);
+        let mut files = Map::with_capacity(cd_records as usize);
         io.seek(SeekFrom::Start(cd_pointer))?;
         let buf = {
             let mut buf = vec![0; cd_size as usize];
@@ -134,49 +139,54 @@ impl<Io: Read + Seek> ArchiveRead for Zip<Io> {
                 }
             }
 
-            files.push(ZipFileInfo::new(
-                CompressionMethod::from_struct_id(cdr.compression_method)?,
-                BitFlag::new(cdr.bit_flag),
-                NaiveDateTime::new(
-                    NaiveDate::from_ymd_opt(
-                        (cdr.dos_date as i32 >> 9 & 0x7F) + 1980,
-                        cdr.dos_date as u32 >> 5 & 0xF,
-                        cdr.dos_date as u32 & 0x1F,
-                    )
-                    .ok_or(ZipError::InvalidDate)?,
-                    NaiveTime::from_hms_opt(
-                        (cdr.dos_time as u32 >> 11) & 0x1F,
-                        (cdr.dos_time as u32 >> 5) & 0x3F,
-                        (cdr.dos_time as u32 & 0x1F) * 2,
+            files.insert(
+                name.clone(),
+                ZipFileInfo::new(
+                    CompressionMethod::from_struct_id(cdr.compression_method)?,
+                    BitFlag::new(cdr.bit_flag),
+                    NaiveDateTime::new(
+                        NaiveDate::from_ymd_opt(
+                            (cdr.dos_date as i32 >> 9 & 0x7F) + 1980,
+                            cdr.dos_date as u32 >> 5 & 0xF,
+                            cdr.dos_date as u32 & 0x1F,
+                        )
+                        .ok_or(ZipError::InvalidDate)?,
+                        NaiveTime::from_hms_opt(
+                            (cdr.dos_time as u32 >> 11) & 0x1F,
+                            (cdr.dos_time as u32 >> 5) & 0x3F,
+                            (cdr.dos_time as u32 & 0x1F) * 2,
+                        )
+                        .ok_or(ZipError::InvalidTime)?,
                     )
-                    .ok_or(ZipError::InvalidTime)?,
-                )
-                .and_local_timezone(Local)
-                .unwrap(),
-                cdr.crc,
-                compressed_size,
-                size,
-                header_pointer,
-                name,
-                comment,
-            ));
+                    .and_local_timezone(Local)
+                    .unwrap(),
+                    cdr.crc,
+                    compressed_size,
+                    size,
+                    header_pointer,
+                    name,
+                    comment,
+                ),
+            );
         }
 
         Ok(Self { io, files, comment })
     }
 
-    fn files(&self) -> &Vec<Self::FileInfo> {
-        &self.files
+    fn files(&self) -> Vec<&Self::FileInfo> {
+        let mut files: Vec<&Self::FileInfo> = self.files.values().collect();
+        files.sort_by_key(|f| &f.name);
+        files
     }
 
-    fn get_file_info(&self, index: usize) -> ZipResult<&Self::FileInfo> {
-        self.files.get(index).ok_or(ZipError::FileNotFound.into())
+    fn get_file_info(&self, name: &str) -> ZipResult<&Self::FileInfo> {
+        self.files.get(name).ok_or(ZipError::FileNotFound.into())
     }
 
-    fn get_file_reader<'d>(&'d mut self, index: usize) -> ZipResult<Self::FileDriver<'d>> {
-        Ok(ZipFile::new(
+    fn get_file_reader<'d>(&'d mut self, name: &str) -> ZipResult<Self::FileReader<'d>> {
+        Ok(ZipFileReader::new(
             &mut self.io,
-            self.files.get(index).ok_or(ZipError::FileNotFound)?,
+            self.files.get(name).ok_or(ZipError::FileNotFound)?,
         )?)
     }
 }
@@ -187,6 +197,8 @@ impl<Io: Read + Seek> Zip<Io> {
     }
 }
 
-impl<Io: Read + Write + Seek> ArchiveWrite for Zip<Io> {}
+impl<Io: Read + Write + Seek> ArchiveWrite for Zip<Io> {
+    type FileWriter<'d> = ZipFileWriter<'d, Io> where Io: 'd;
+}
 
 impl<Io: Read + Write + Seek> Zip<Io> {}
diff --git a/src/zip/error.rs b/src/zip/error.rs
index 3acbf8c..5659f93 100644
--- a/src/zip/error.rs
+++ b/src/zip/error.rs
@@ -21,6 +21,7 @@ pub enum ZipError {
 
     NegativeFileOffset,
     FileNotFound,
+    CompressionDataIsUnseekable,
 }
 
 impl From<ZipError> for ArchiveError<ZipError> {
@@ -59,6 +60,7 @@ impl Display for ZipError {
 
             Self::NegativeFileOffset => write!(f, "Negative file offset"),
             Self::FileNotFound => write!(f, "File not found"),
+            Self::CompressionDataIsUnseekable => write!(f, "Compression data is unseekable"),
         }
     }
 }
diff --git a/src/zip/file_info.rs b/src/zip/file/info.rs
index 92d52f7..2891b59 100644
--- a/src/zip/file_info.rs
+++ b/src/zip/file/info.rs
@@ -6,9 +6,8 @@ use chrono::{DateTime, Local};
 pub enum CompressionMethod {
     Store,
     Deflate,
-    BZIP2,
+    BZip2,
     LZMA,
-    ZStd,
     XZ,
 }
 
@@ -17,11 +16,10 @@ impl CompressionMethod {
         match id {
             0 => Ok(Self::Store),
             8 => Ok(Self::Deflate),
-            12 => Ok(Self::BZIP2),
+            12 => Ok(Self::BZip2),
             14 => Ok(Self::LZMA),
-            93 => Ok(Self::ZStd),
             95 => Ok(Self::XZ),
-            1..=7 | 9..=11 | 13 | 15..=20 | 94 | 96..=99 => {
+            1..=7 | 9..=11 | 13 | 15..=20 | 93..=94 | 96..=99 => {
                 Err(ZipError::UnsupportedCompressionMethod.into())
             }
             21..=92 | 100.. => Err(ZipError::InvalidCompressionMethod.into()),
diff --git a/src/zip/file/mod.rs b/src/zip/file/mod.rs
new file mode 100644
index 0000000..43ccc04
--- /dev/null
+++ b/src/zip/file/mod.rs
@@ -0,0 +1,7 @@
+mod info;
+mod read;
+mod write;
+
+pub use info::{bit, BitFlag, CompressionMethod, ZipFileInfo};
+pub use read::ZipFileReader;
+pub use write::ZipFileWriter;
diff --git a/src/zip/file/read.rs b/src/zip/file/read.rs
new file mode 100644
index 0000000..56f42da
--- /dev/null
+++ b/src/zip/file/read.rs
@@ -0,0 +1,125 @@
+use crate::driver::FileDriver;
+use crate::zip::{CompressionMethod, ZipError, ZipFileInfo, ZipResult};
+use bzip2::read::BzDecoder;
+use flate2::read::DeflateDecoder;
+use std::io::{
+    Error as IoError, ErrorKind as IoErrorKind, Read, Result as IoResult, Seek, SeekFrom,
+};
+use xz2::read::XzDecoder;
+
+enum IoProxy<Io: Read> {
+    Store(Io),
+    Deflate(DeflateDecoder<Io>),
+    BZip2(BzDecoder<Io>),
+    XZ(XzDecoder<Io>),
+}
+
+pub struct ZipFileReader<'d, Io: Read> {
+    io: IoProxy<&'d mut Io>,
+    info: &'d ZipFileInfo,
+
+    bounds: (u64, u64),
+    cursor: u64,
+}
+
+impl<'d, Io: Read> FileDriver for ZipFileReader<'d, Io> {
+    type Io = Io;
+    type FileInfo = ZipFileInfo;
+
+    fn info(&self) -> &Self::FileInfo {
+        self.info
+    }
+}
+
+impl<'d, Io: Read + Seek> ZipFileReader<'d, Io> {
+    pub fn new(io: &'d mut Io, info: &'d ZipFileInfo) -> ZipResult<Self> {
+        io.seek(SeekFrom::Start(info.header_pointer))?;
+        let buf = {
+            let mut buf = [0; 30];
+            io.read(&mut buf)?;
+            buf
+        };
+        if u32::from_le_bytes(buf[..4].try_into().unwrap()) != 0x04034b50 {
+            return Err(ZipError::InvalidFileHeaderSignature.into());
+        }
+        let data_pointer = info.header_pointer
+            + 30
+            + u16::from_le_bytes(buf[26..28].try_into().unwrap()) as u64
+            + u16::from_le_bytes(buf[28..30].try_into().unwrap()) as u64;
+        io.seek(SeekFrom::Start(data_pointer))?;
+
+        Ok(Self {
+            io: match info.compression_method {
+                CompressionMethod::Store => IoProxy::Store(io),
+                CompressionMethod::Deflate => IoProxy::Deflate(DeflateDecoder::new(io)),
+                CompressionMethod::BZip2 => IoProxy::BZip2(BzDecoder::new(io)),
+                CompressionMethod::LZMA => IoProxy::XZ(XzDecoder::new(io)),
+                CompressionMethod::XZ => IoProxy::XZ(XzDecoder::new(io)),
+            },
+            info,
+
+            bounds: (data_pointer, data_pointer + info.compressed_size),
+            cursor: data_pointer,
+        })
+    }
+
+    pub fn seekable(&self) -> bool {
+        match self.io {
+            IoProxy::Store(..) => true,
+            _ => false,
+        }
+    }
+}
+
+impl<'d, Io: Read> Read for ZipFileReader<'d, Io> {
+    fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
+        let upper = buf.len().min((self.bounds.1 - self.cursor) as usize);
+        let bytes = match &mut self.io {
+            IoProxy::Store(io) => io.read(&mut buf[..upper]),
+            IoProxy::Deflate(io) => io.read(&mut buf[..upper]),
+            IoProxy::BZip2(io) => io.read(&mut buf[..upper]),
+            IoProxy::XZ(io) => io.read(&mut buf[..upper]),
+        }?;
+        self.cursor += upper as u64;
+        Ok(bytes)
+    }
+}
+
+impl<'d, Io: Read + Seek> Seek for ZipFileReader<'d, Io> {
+    fn seek(&mut self, pos: SeekFrom) -> IoResult<u64> {
+        match &mut self.io {
+            IoProxy::Store(io) => {
+                self.cursor = match pos {
+                    SeekFrom::Start(offset) => self.bounds.0 + offset,
+                    SeekFrom::End(offset) => {
+                        let cursor = self.bounds.1.saturating_add_signed(offset);
+                        if cursor < self.bounds.0 {
+                            return Err(IoError::new(
+                                IoErrorKind::InvalidInput,
+                                ZipError::NegativeFileOffset,
+                            ));
+                        }
+                        cursor
+                    }
+                    SeekFrom::Current(offset) => {
+                        let cursor = self.cursor.saturating_add_signed(offset);
+                        if cursor < self.bounds.0 {
+                            return Err(IoError::new(
+                                IoErrorKind::InvalidInput,
+                                ZipError::NegativeFileOffset,
+                            ));
+                        }
+                        cursor
+                    }
+                }
+                .min(self.bounds.1);
+
+                Ok(io.seek(SeekFrom::Start(self.cursor))? - self.bounds.0)
+            }
+            _ => Err(IoError::new(
+                IoErrorKind::Unsupported,
+                ZipError::CompressionDataIsUnseekable,
+            )),
+        }
+    }
+}
diff --git a/src/zip/file/write.rs b/src/zip/file/write.rs
new file mode 100644
index 0000000..627db6d
--- /dev/null
+++ b/src/zip/file/write.rs
@@ -0,0 +1,30 @@
+use crate::driver::FileDriver;
+use crate::zip::ZipFileInfo;
+use bzip2::write::BzEncoder;
+use flate2::write::DeflateEncoder;
+use std::io::Write;
+use xz2::write::XzEncoder;
+
+enum IoProxy<Io: Write> {
+    Store(Io),
+    Deflate(DeflateEncoder<Io>),
+    BZip2(BzEncoder<Io>),
+    XZ(XzEncoder<Io>),
+}
+
+pub struct ZipFileWriter<'d, Io: Write> {
+    io: IoProxy<&'d mut Io>,
+    info: &'d ZipFileInfo,
+
+    bounds: (u64, u64),
+    cursor: u64,
+}
+
+impl<'d, Io: Write> FileDriver for ZipFileWriter<'d, Io> {
+    type Io = Io;
+    type FileInfo = ZipFileInfo;
+
+    fn info(&self) -> &Self::FileInfo {
+        self.info
+    }
+}
diff --git a/src/zip/file_driver.rs b/src/zip/file_driver.rs
deleted file mode 100644
index 51075e4..0000000
--- a/src/zip/file_driver.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-use crate::driver::FileDriver;
-use crate::zip::{ZipError, ZipFileInfo, ZipResult};
-use std::io::{
-    Error as IoError, ErrorKind as IoErrorKind, Read, Result as IoResult, Seek, SeekFrom, Write,
-};
-
-pub struct ZipFile<'d, Io> {
-    io: &'d mut Io,
-    info: &'d ZipFileInfo,
-
-    bounds: (u64, u64),
-    cursor: u64,
-}
-
-impl<'d, Io> FileDriver for ZipFile<'d, Io> {
-    type Io = Io;
-    type FileInfo = ZipFileInfo;
-
-    fn info(&self) -> &Self::FileInfo {
-        self.info
-    }
-}
-
-impl<'d, Io: Read + Seek> ZipFile<'d, Io> {
-    pub fn new(io: &'d mut Io, info: &'d ZipFileInfo) -> ZipResult<Self> {
-        io.seek(SeekFrom::Start(info.header_pointer))?;
-        let buf = {
-            let mut buf = [0; 30];
-            io.read(&mut buf)?;
-            buf
-        };
-        if u32::from_le_bytes(buf[..4].try_into().unwrap()) != 0x04034b50 {
-            return Err(ZipError::InvalidFileHeaderSignature.into());
-        }
-        let data_pointer = info.header_pointer
-            + 30
-            + u16::from_le_bytes(buf[26..28].try_into().unwrap()) as u64
-            + u16::from_le_bytes(buf[28..30].try_into().unwrap()) as u64;
-        io.seek(SeekFrom::Start(data_pointer))?;
-
-        Ok(Self {
-            io,
-            info,
-
-            bounds: (data_pointer, data_pointer + info.compressed_size),
-            cursor: data_pointer,
-        })
-    }
-}
-
-impl<'d, Io: Read> Read for ZipFile<'d, Io> {
-    fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
-        let upper = buf.len().min((self.bounds.1 - self.cursor) as usize);
-        self.cursor += upper as u64;
-        self.io.read(&mut buf[..upper])
-    }
-}
-
-impl<'d, Io: Write> Write for ZipFile<'d, Io> {
-    fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
-        todo!()
-    }
-
-    fn flush(&mut self) -> IoResult<()> {
-        todo!()
-    }
-}
-
-impl<'d, Io: Seek> Seek for ZipFile<'d, Io> {
-    fn seek(&mut self, pos: SeekFrom) -> IoResult<u64> {
-        self.cursor = match pos {
-            SeekFrom::Start(offset) => self.bounds.0 + offset,
-            SeekFrom::End(offset) => {
-                let cursor = self.bounds.1.saturating_add_signed(offset);
-                if cursor < self.bounds.0 {
-                    return Err(IoError::new(
-                        IoErrorKind::InvalidInput,
-                        ZipError::NegativeFileOffset,
-                    ));
-                }
-                cursor
-            }
-            SeekFrom::Current(offset) => {
-                let cursor = self.cursor.saturating_add_signed(offset);
-                if cursor < self.bounds.0 {
-                    return Err(IoError::new(
-                        IoErrorKind::InvalidInput,
-                        ZipError::NegativeFileOffset,
-                    ));
-                }
-                cursor
-            }
-        }
-        .min(self.bounds.1);
-
-        Ok(self.io.seek(SeekFrom::Start(self.cursor))? - self.bounds.0)
-    }
-}
diff --git a/src/zip/mod.rs b/src/zip/mod.rs
index 3fe8384..0f19824 100644
--- a/src/zip/mod.rs
+++ b/src/zip/mod.rs
@@ -1,14 +1,12 @@
 mod archive;
 mod driver;
 mod error;
-mod file_driver;
-mod file_info;
+mod file;
 mod structs;
 
 pub use driver::Zip;
 pub use error::{ZipError, ZipResult};
-pub use file_driver::ZipFile;
-pub use file_info::{bit, BitFlag, CompressionMethod, ZipFileInfo};
+pub use file::{bit, BitFlag, CompressionMethod, ZipFileInfo, ZipFileReader, ZipFileWriter};
 
 #[cfg(test)]
 mod tests;
diff --git a/src/zip/tests.rs b/src/zip/tests.rs
index 05e076d..92a9c3f 100644
--- a/src/zip/tests.rs
+++ b/src/zip/tests.rs
@@ -1,4 +1,4 @@
-use crate::zip::file_info::{bit::DeflateMode, BitFlag};
+use crate::zip::{bit::DeflateMode, BitFlag};
 
 #[test]
 fn test_bit_flag() {
diff --git a/tests/files/archive.zip b/tests/files/archive.zip
new file mode 100644
index 0000000..f5c0137
--- /dev/null
+++ b/tests/files/archive.zip
diff --git a/tests/files/zip.zip b/tests/files/zip.zip
deleted file mode 100644
index f3a090b..0000000
--- a/tests/files/zip.zip
+++ /dev/null
diff --git a/tests/zip.rs b/tests/zip.rs
index e5872c5..eb195f2 100644
--- a/tests/zip.rs
+++ b/tests/zip.rs
@@ -3,7 +3,7 @@ use std::io::{Read, Seek, SeekFrom};
 
 #[test]
 fn test_zip() {
-    let mut archive = Archive::<Zip<_>>::read_from_file("tests/files/zip.zip").unwrap();
+    let mut archive = Archive::<Zip<_>>::read_from_file("tests/files/archive.zip").unwrap();
 
     assert_eq!(archive.comment(), "archive comment");
     assert_eq!(
@@ -12,36 +12,46 @@ fn test_zip() {
             .iter()
             .map(|f| &f.name)
             .collect::<Vec<&String>>(),
-        vec!["b", "c", "a"]
+        vec!["bzip", "deflate", "lzma", "store", "xz"]
     );
 
-    let mut f = archive.get_file_reader(2).unwrap();
+    let mut f = archive.get_file_reader("store").unwrap();
 
     let mut data = String::new();
     f.read_to_string(&mut data).unwrap();
-    assert_eq!(data, "file data \"a\"");
+    assert_eq!(data, "test file data");
 
     assert_eq!(f.seek(SeekFrom::Start(5)).unwrap(), 5);
     let mut data = String::new();
     f.read_to_string(&mut data).unwrap();
-    assert_eq!(data, "data \"a\"");
+    assert_eq!(data, "file data");
 
     assert_eq!(f.seek(SeekFrom::Start(0)).unwrap(), 0);
     let mut data = vec![0; 4];
     f.read(&mut data).unwrap();
-    assert_eq!(String::from_utf8(data).unwrap(), "file");
+    assert_eq!(String::from_utf8(data).unwrap(), "test");
 
     assert_eq!(f.seek(SeekFrom::Current(1)).unwrap(), 5);
     let mut data = vec![0; 4];
     f.read(&mut data).unwrap();
-    assert_eq!(String::from_utf8(data).unwrap(), "data");
+    assert_eq!(String::from_utf8(data).unwrap(), "file");
 
-    assert_eq!(f.seek(SeekFrom::End(-3)).unwrap(), 10);
-    let mut data = vec![0; 3];
+    assert_eq!(f.seek(SeekFrom::End(-4)).unwrap(), 10);
+    let mut data = vec![0; 4];
     f.read(&mut data).unwrap();
-    assert_eq!(String::from_utf8(data).unwrap(), "\"a\"");
+    assert_eq!(String::from_utf8(data).unwrap(), "data");
 
-    assert_eq!(f.seek(SeekFrom::Current(0)).unwrap(), 13);
+    f.seek(SeekFrom::Start(7)).unwrap();
+    assert_eq!(f.seek(SeekFrom::Current(0)).unwrap(), 7);
     f.seek(SeekFrom::End(-100)).unwrap_err();
-    assert_eq!(f.seek(SeekFrom::Current(0)).unwrap(), 13);
+    assert_eq!(f.seek(SeekFrom::Current(0)).unwrap(), 7);
+
+    assert_eq!(f.seek(SeekFrom::Start(100)).unwrap(), 14);
+
+    for name in ["store", "deflate", "bzip", "lzma", "xz"] {
+        let mut f = archive.get_file_reader(name).unwrap();
+        let mut data = String::new();
+        f.read_to_string(&mut data).unwrap();
+        assert_eq!(data, "test file data");
+    }
 }