add pkware zip

.circleci/config.yml

@@ -1,11 +0,0 @@
-version: 2
-jobs:
-  build:
-    docker:
-      - image: adamhathcock/cake-build:latest
-    steps:
-      - checkout
-      - run:
-          name: Build
-          command: ./build.sh
-      

.gitattributes

@@ -2,4 +2,4 @@
 * text=auto
 
 # need original files to be windows
-*.txt text eol=crlf
+test/TestArchives/Original/*.txt eol=crlf

.gitignore

@@ -14,4 +14,3 @@ tests/TestArchives/Scratch
 .vs
 tools
 .vscode
-.idea/

.travis.yml

@@ -0,0 +1,13 @@
+dist: trusty
+language: csharp
+cache:
+  directories:
+  - $HOME/.dotnet
+solution: SharpCompress.sln
+matrix:
+  include:
+    - dotnet: 1.0.4
+      mono: none
+      env: DOTNETCORE=1
+script:
+  - ./build.sh

README.md

@@ -7,8 +7,8 @@ The major feature is support for non-seekable streams so large files can be proc
 AppVeyor Build - 
 [![Build status](https://ci.appveyor.com/api/projects/status/voxg971oemmvxh1e/branch/master?svg=true)](https://ci.appveyor.com/project/adamhathcock/sharpcompress/branch/master)
 
-Circle CI Build - 
-[![CircleCI](https://circleci.com/gh/adamhathcock/sharpcompress.svg?style=svg)](https://circleci.com/gh/adamhathcock/sharpcompress)
+Travis CI Build - 
+[![Build Status](https://travis-ci.org/adamhathcock/sharpcompress.svg?branch=master)](https://travis-ci.org/adamhathcock/sharpcompress)
 
 ## Need Help?
 Post Issues on Github!

SharpCompress.sln.DotSettings

@@ -114,7 +114,6 @@
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=NAMESPACE_005FALIAS/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=XAML_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=XAML_005FRESOURCE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpAttributeForSingleLineMethodUpgrade/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EAddAccessorOwnerDeclarationBracesMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateBlankLinesAroundFieldToBlankLinesAroundProperty/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateThisQualifierSettings/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

build.cake

@@ -30,11 +30,8 @@ Task("Build")
 
         DotNetCoreBuild("./src/SharpCompress/SharpCompress.csproj", settings);
 
-        settings.Framework = "netstandard1.3";
-        DotNetCoreBuild("./src/SharpCompress/SharpCompress.csproj", settings);
-
-        settings.Framework = "netstandard2.0";
-        DotNetCoreBuild("./src/SharpCompress/SharpCompress.csproj", settings);
+        settings.Framework = "netcoreapp1.1";
+        DotNetCoreBuild("./tests/SharpCompress.Test/SharpCompress.Test.csproj", settings);
     }
 });
 
@@ -42,25 +39,23 @@ Task("Test")
   .IsDependentOn("Build")
   .Does(() =>
 {
-    var files = GetFiles("tests/**/*.csproj");
-    foreach(var file in files)
+    if (!bool.Parse(EnvironmentVariable("APPVEYOR") ?? "false")
+        && !bool.Parse(EnvironmentVariable("TRAVIS") ?? "false"))
     {
-        var settings = new DotNetCoreTestSettings
+        var files = GetFiles("tests/**/*.csproj");
+        foreach(var file in files)
         {
-            Configuration = "Release",
-            Framework = "netcoreapp2.0"
-        };
-
-        DotNetCoreTest(file.ToString(), settings);
-
-
-            settings = new DotNetCoreTestSettings
+            var settings = new DotNetCoreTestSettings
             {
-                Configuration = "Release",
-                Framework = "netcoreapp2.0"
+                Configuration = "Release"
             };
 
             DotNetCoreTest(file.ToString(), settings);
+        }
+    } 
+    else 
+    {
+        Information("Skipping tests as this is AppVeyor or Travis CI");
     }
 });
 

build.sh

@@ -8,7 +8,7 @@
 # Define directories.
 SCRIPT_DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
 TOOLS_DIR=$SCRIPT_DIR/tools
-CAKE_VERSION=0.23.0
+CAKE_VERSION=0.19.1
 CAKE_DLL=$TOOLS_DIR/Cake.CoreCLR.$CAKE_VERSION/Cake.dll
 
 # Make sure the tools folder exist.

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -4,7 +4,6 @@ using System.IO;
 using System.Linq;
 using SharpCompress.Common;
 using SharpCompress.Common.SevenZip;
-using SharpCompress.Compressors.LZMA.Utilites;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
@@ -118,7 +117,7 @@ namespace SharpCompress.Archives.SevenZip
                 stream.Position = 0;
                 var reader = new ArchiveReader();
                 reader.Open(stream);
-                database = reader.ReadDatabase(new PasswordProvider(ReaderOptions.Password));
+                database = reader.ReadDatabase(null);
             }
         }
 
@@ -145,7 +144,7 @@ namespace SharpCompress.Archives.SevenZip
 
         protected override IReader CreateReaderForSolidExtraction()
         {
-            return new SevenZipReader(ReaderOptions, this);
+            return new SevenZipReader(this);
         }
 
         public override bool IsSolid { get { return Entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder).Count() > 1; } }
@@ -166,8 +165,8 @@ namespace SharpCompress.Archives.SevenZip
             private Stream currentStream;
             private CFileItem currentItem;
 
-            internal SevenZipReader(ReaderOptions readerOptions, SevenZipArchive archive)
-                : base(readerOptions, ArchiveType.SevenZip)
+            internal SevenZipReader(SevenZipArchive archive)
+                : base(new ReaderOptions(), ArchiveType.SevenZip)
             {
                 this.archive = archive;
             }
@@ -191,7 +190,7 @@ namespace SharpCompress.Archives.SevenZip
                     }
                     else
                     {
-                        currentStream = archive.database.GetFolderStream(stream, currentFolder, new PasswordProvider(Options.Password));
+                        currentStream = archive.database.GetFolderStream(stream, currentFolder, null);
                     }
                     foreach (var entry in group)
                     {
@@ -206,21 +205,5 @@ namespace SharpCompress.Archives.SevenZip
                 return CreateEntryStream(new ReadOnlySubStream(currentStream, currentItem.Size));
             }
         }
-        
-        private class PasswordProvider : IPasswordProvider
-        {
-            private readonly string _password;
-
-            public PasswordProvider(string password)
-            {
-                _password = password;
-
-            }
-
-            public string CryptoGetTextPassword()
-            {
-                return _password;
-            }
-        }
     }
 }

src/SharpCompress/Archives/Zip/ZipArchive.cs

@@ -208,7 +208,7 @@ namespace SharpCompress.Archives.Zip
         {
             var stream = Volumes.Single().Stream;
             stream.Position = 0;
-            return ZipReader.Open(stream, ReaderOptions);
+            return ZipReader.Open(stream);
         }
     }
 }

src/SharpCompress/Common/Rar/Headers/MarkHeader.cs

@@ -18,9 +18,9 @@ namespace SharpCompress.Common.Rar.Headers
                    Flags == 0x1A21 &&
                    HeaderSize == 0x07;
 
-            // Rar5 signature: 52 61 72 21 1A 07 01 00 (not supported yet)
+            // Rar5 signature: 52 61 72 21 1A 07 10 00 (not supported yet)
         }
 
         internal bool OldFormat { get; private set; }
     }
-}
+}

src/SharpCompress/Common/SevenZip/ArchiveDatabase.cs

@@ -22,13 +22,6 @@ namespace SharpCompress.Common.SevenZip
         internal List<long> PackStreamStartPositions = new List<long>();
         internal List<int> FolderStartFileIndex = new List<int>();
         internal List<int> FileIndexToFolderIndexMap = new List<int>();
-        
-        internal IPasswordProvider PasswordProvider { get; }
-
-        public ArchiveDatabase(IPasswordProvider passwordProvider)
-        {
-            PasswordProvider = passwordProvider;
-        }
 
         internal void Clear()
         {

src/SharpCompress/Common/SevenZip/ArchiveReader.cs

@@ -182,7 +182,7 @@ namespace SharpCompress.Common.SevenZip
 
         private DateTime? TranslateTime(long? time)
         {
-            if (time.HasValue && time.Value >= 0 && time.Value <= 2650467743999999999) //maximum Windows file time 31.12.9999
+            if (time.HasValue)
             {
                 return TranslateTime(time.Value);
             }
@@ -1211,7 +1211,7 @@ namespace SharpCompress.Common.SevenZip
 
         public ArchiveDatabase ReadDatabase(IPasswordProvider pass)
         {
-            var db = new ArchiveDatabase(pass);
+            var db = new ArchiveDatabase();
             db.Clear();
 
             db.MajorVersion = _header[6];
@@ -1279,7 +1279,7 @@ namespace SharpCompress.Common.SevenZip
                         throw new InvalidOperationException();
                     }
 
-                    var dataVector = ReadAndDecodePackedStreams(db.StartPositionAfterHeader, db.PasswordProvider);
+                    var dataVector = ReadAndDecodePackedStreams(db.StartPositionAfterHeader, pass);
 
                     // compressed header without content is odd but ok
                     if (dataVector.Count == 0)
@@ -1301,7 +1301,7 @@ namespace SharpCompress.Common.SevenZip
                     }
                 }
 
-                ReadHeader(db, db.PasswordProvider);
+                ReadHeader(db, pass);
             }
             db.Fill();
             return db;
@@ -1441,7 +1441,7 @@ namespace SharpCompress.Common.SevenZip
             #endregion
         }
 
-        private Stream GetCachedDecoderStream(ArchiveDatabase _db, int folderIndex)
+        private Stream GetCachedDecoderStream(ArchiveDatabase _db, int folderIndex, IPasswordProvider pw)
         {
             Stream s;
             if (!_cachedStreams.TryGetValue(folderIndex, out s))
@@ -1456,13 +1456,13 @@ namespace SharpCompress.Common.SevenZip
                 }
 
                 s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes.ToArray(), folderInfo,
-                                                            _db.PasswordProvider);
+                                                            pw);
                 _cachedStreams.Add(folderIndex, s);
             }
             return s;
         }
 
-        public Stream OpenStream(ArchiveDatabase _db, int fileIndex)
+        public Stream OpenStream(ArchiveDatabase _db, int fileIndex, IPasswordProvider pw)
         {
             int folderIndex = _db.FileIndexToFolderIndexMap[fileIndex];
             int numFilesInFolder = _db.NumUnpackStreamsVector[folderIndex];
@@ -1479,12 +1479,12 @@ namespace SharpCompress.Common.SevenZip
                 skipSize += _db.Files[firstFileIndex + i].Size;
             }
 
-            Stream s = GetCachedDecoderStream(_db, folderIndex);
+            Stream s = GetCachedDecoderStream(_db, folderIndex, pw);
             s.Position = skipSize;
             return new ReadOnlySubStream(s, _db.Files[fileIndex].Size);
         }
 
-        public void Extract(ArchiveDatabase _db, int[] indices)
+        public void Extract(ArchiveDatabase _db, int[] indices, IPasswordProvider pw)
         {
             int numItems;
             bool allFilesMode = (indices == null);
@@ -1562,7 +1562,7 @@ namespace SharpCompress.Common.SevenZip
                 // TODO: If the decoding fails the last file may be extracted incompletely. Delete it?
 
                 Stream s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes.ToArray(),
-                                                                   folderInfo, _db.PasswordProvider);
+                                                                   folderInfo, pw);
                 byte[] buffer = new byte[4 << 10];
                 for (;;)
                 {
@@ -1588,4 +1588,4 @@ namespace SharpCompress.Common.SevenZip
 
         #endregion
     }
-}
+}

src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs

@@ -42,7 +42,7 @@ namespace SharpCompress.Common.SevenZip
             {
                 return null;
             }
-            var folderStream = _database.GetFolderStream(_stream, Folder, _database.PasswordProvider);
+            var folderStream = _database.GetFolderStream(_stream, Folder, null);
 
             int firstFileIndex = _database.FolderStartFileIndex[_database.Folders.IndexOf(Folder)];
             int skipCount = Index - firstFileIndex;

src/SharpCompress/Common/Zip/CryptoMode.cs

@@ -0,0 +1,8 @@
+namespace SharpCompress.Common.Zip
+{
+    internal enum CryptoMode
+    {
+        Encrypt,
+        Decrypt
+    }
+}

src/SharpCompress/Common/Zip/PkwareTraditionalCryptoStream.cs

@@ -3,12 +3,6 @@ using System.IO;
 
 namespace SharpCompress.Common.Zip
 {
-    internal enum CryptoMode
-    {
-        Encrypt,
-        Decrypt
-    }
-
     internal class PkwareTraditionalCryptoStream : Stream
     {
         private readonly PkwareTraditionalEncryptionData encryptor;

src/SharpCompress/Common/Zip/PkwareTraditionalEncryptionData.cs

@@ -33,10 +33,6 @@ namespace SharpCompress.Common.Zip
             byte[] plainTextHeader = encryptor.Decrypt(encryptionHeader, encryptionHeader.Length);
             if (plainTextHeader[11] != (byte)((header.Crc >> 24) & 0xff))
             {
-                if (!FlagUtility.HasFlag(header.Flags, HeaderFlags.UsePostDataDescriptor))
-                {
-                    throw new CryptographicException("The password did not match.");
-                }
                 if (plainTextHeader[11] != (byte)((header.LastModifiedTime >> 8) & 0xff))
                 {
                     throw new CryptographicException("The password did not match.");
@@ -108,5 +104,10 @@ namespace SharpCompress.Common.Zip
             _Keys[1] = _Keys[1] * 0x08088405 + 1;
             _Keys[2] = (UInt32)crc32.ComputeCrc32((int)_Keys[2], (byte)(_Keys[1] >> 24));
         }
+
+        public static PkwareTraditionalEncryptionData ForWrite(string password, ArchiveEncoding archiveEncoding)
+        {
+            return new PkwareTraditionalEncryptionData(password, archiveEncoding);
+        }
     }
 }

src/SharpCompress/Common/Zip/ZipFilePart.cs

@@ -128,11 +128,6 @@ namespace SharpCompress.Common.Zip
         {
             bool isFileEncrypted = FlagUtility.HasFlag(Header.Flags, HeaderFlags.Encrypted);
 
-            if (Header.CompressedSize == 0 && isFileEncrypted)
-            {
-                throw new NotSupportedException("Cannot encrypt file with unknown size at start.");
-            }
-
             if ((Header.CompressedSize == 0
                 && FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor))
                 || Header.IsZip64)

src/SharpCompress/Compressors/Deflate/Zlib.cs

@@ -418,7 +418,7 @@ namespace SharpCompress.Compressors.Deflate
     internal sealed class Adler
     {
         // largest prime smaller than 65536
-        private static readonly uint BASE = 65521U;
+        private static readonly int BASE = 65521;
 
         // NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
         private static readonly int NMAX = 5552;
@@ -430,8 +430,8 @@ namespace SharpCompress.Compressors.Deflate
                 return 1;
             }
 
-            uint s1 = adler & 0xffffU;
-            uint s2 = (adler >> 16) & 0xffffU;
+            int s1 = (int)(adler & 0xffff);
+            int s2 = (int)((adler >> 16) & 0xffff);
 
             while (len > 0)
             {
@@ -486,7 +486,7 @@ namespace SharpCompress.Compressors.Deflate
                 s1 %= BASE;
                 s2 %= BASE;
             }
-            return (s2 << 16) | s1;
+            return (uint)((s2 << 16) | s1);
         }
     }
 }

src/SharpCompress/Compressors/Rar/RarCrcStream.cs

@@ -31,7 +31,7 @@ namespace SharpCompress.Compressors.Rar {
             {
                 currentCrc = RarCRC.CheckCrc(currentCrc, buffer, offset, result);
             } 
-            else if (GetCrc() != readStream.CurrentCrc && count != 0)
+            else if (GetCrc() != readStream.CurrentCrc)
             {
                 // NOTE: we use the last FileHeader in a multipart volume to check CRC
                 throw new InvalidFormatException("file crc mismatch");

src/SharpCompress/Compressors/Xz/MultiByteIntegers.cs

@@ -18,7 +18,7 @@ namespace SharpCompress.Compressors.Xz
             int i = 0;
             while ((LastByte & 0x80) != 0)
             {
-                if (++i >= MaxBytes)
+                if (i >= MaxBytes)
                     throw new InvalidDataException();
                 LastByte = reader.ReadByte();
                 if (LastByte == 0)

src/SharpCompress/Compressors/Xz/XZBlock.cs

@@ -50,11 +50,11 @@ namespace SharpCompress.Compressors.Xz
 
         private void SkipPadding()
         {
-            int bytes = (int)(BaseStream.Position % 4);
-            if (bytes > 0)
+            int padding = (int)(_bytesRead % 4);
+            if (padding > 0)
             {
-                byte[] paddingBytes = new byte[4 - bytes];
-                BaseStream.Read(paddingBytes, 0, paddingBytes.Length);
+                byte[] paddingBytes = new byte[padding];
+                BaseStream.Read(paddingBytes, 0, padding);
                 if (paddingBytes.Any(b => b != 0))
                     throw new InvalidDataException("Padding bytes were non-null");
             }

src/SharpCompress/Compressors/Xz/XZIndex.cs

@@ -55,10 +55,10 @@ namespace SharpCompress.Compressors.Xz
 
         private void SkipPadding()
         {
-            int bytes = (int)(_reader.BaseStream.Position - StreamStartPosition) % 4;
-            if (bytes > 0)
+            int padding = (int)(_reader.BaseStream.Position - StreamStartPosition) % 4;
+            if (padding > 0)
             {
-                byte[] paddingBytes = _reader.ReadBytes(4 - bytes);
+                byte[] paddingBytes = _reader.ReadBytes(padding);
                 if (paddingBytes.Any(b => b != 0))
                     throw new InvalidDataException("Padding bytes were non-null");
             }

src/SharpCompress/IO/BufferedSubStream.cs

@@ -41,7 +41,7 @@ namespace SharpCompress.IO
             throw new NotSupportedException();
         }
 
-        public override long Length => BytesLeftToRead;
+        public override long Length => throw new NotSupportedException();
 
         public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
 

src/SharpCompress/IO/RewindableStream.cs

@@ -1,6 +1,5 @@
 using System;
 using System.IO;
-using SharpCompress.Compressors.Filters;
 
 namespace SharpCompress.IO
 {
@@ -47,13 +46,8 @@ namespace SharpCompress.IO
             }
             else
             {
-                
                 bufferStream.TransferTo(buffer);
-                //create new memorystream to allow proper resizing as memorystream could be a user provided buffer
-                //https://github.com/adamhathcock/sharpcompress/issues/306
-                bufferStream = new MemoryStream();
-                buffer.Position = 0;
-                buffer.TransferTo(bufferStream);
+                bufferStream = buffer;
                 bufferStream.Position = 0;
             }
             isRewound = true;

src/SharpCompress/Readers/IReaderExtensions.cs

@@ -93,10 +93,6 @@ namespace SharpCompress.Readers
             using (FileStream fs = File.Open(destinationFileName, fm))
             {
                 reader.WriteEntryTo(fs);
-                //using (Stream s = reader.OpenEntryStream())
-                //{
-                //    s.TransferTo(fs);
-                //}
             }
             reader.Entry.PreserveExtractionOptions(destinationFileName, options);
         }

src/SharpCompress/SharpCompress.csproj

@@ -2,11 +2,12 @@
   <PropertyGroup>
     <AssemblyTitle>SharpCompress - Pure C# Decompression/Compression</AssemblyTitle>
     <NeutralLanguage>en-US</NeutralLanguage>
-    <VersionPrefix>0.18.2</VersionPrefix>
-    <AssemblyVersion>0.18.2.0</AssemblyVersion>
-    <FileVersion>0.18.2.0</FileVersion>
+    <VersionPrefix>0.18</VersionPrefix>
+    <AssemblyVersion>0.18.0.0</AssemblyVersion>
+    <FileVersion>0.18.0.0</FileVersion>
     <Authors>Adam Hathcock</Authors>
-    <TargetFrameworks Condition="'$(LibraryFrameworks)'==''">net45;net35;netstandard1.0;netstandard1.3;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks Condition="'$(LibraryFrameworks)'==''">net45;net35;netstandard1.0;netstandard1.3</TargetFrameworks>
+    <TargetFrameworks Condition="'$(LibraryFrameworks)'!=''">$(LibraryFrameworks)</TargetFrameworks>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <AssemblyName>SharpCompress</AssemblyName>

src/SharpCompress/Writers/Zip/ZipWriter.cs

@@ -17,26 +17,19 @@ namespace SharpCompress.Writers.Zip
 {
     public class ZipWriter : AbstractWriter
     {
-        private readonly CompressionType compressionType;
-        private readonly CompressionLevel compressionLevel;
-        private readonly List<ZipCentralDirectoryEntry> entries = new List<ZipCentralDirectoryEntry>();
-        private readonly string zipComment;
-        private long streamPosition;
-        private PpmdProperties ppmdProps;
-        private readonly bool isZip64;
-
+        private readonly ZipWriterOptions _zipWriterOptions;
+        private readonly List<ZipCentralDirectoryEntry> _entries = new List<ZipCentralDirectoryEntry>();
+        private long _streamPosition;
+        private PpmdProperties _ppmdProps;
+        
         public ZipWriter(Stream destination, ZipWriterOptions zipWriterOptions)
             : base(ArchiveType.Zip, zipWriterOptions)
         {
-            zipComment = zipWriterOptions.ArchiveComment ?? string.Empty;
-            isZip64 = zipWriterOptions.UseZip64;
+            _zipWriterOptions = zipWriterOptions;
             if (destination.CanSeek)
             {
-                streamPosition = destination.Position;
+                _streamPosition = destination.Position;
             }
-
-            compressionType = zipWriterOptions.CompressionType;
-            compressionLevel = zipWriterOptions.DeflateCompressionLevel;
             InitalizeStream(destination);
         }
 
@@ -44,11 +37,11 @@ namespace SharpCompress.Writers.Zip
         {
             get
             {
-                if (ppmdProps == null)
+                if (_ppmdProps == null)
                 {
-                    ppmdProps = new PpmdProperties();
+                    _ppmdProps = new PpmdProperties();
                 }
-                return ppmdProps;
+                return _ppmdProps;
             }
         }
 
@@ -57,7 +50,7 @@ namespace SharpCompress.Writers.Zip
             if (isDisposing)
             {
                 ulong size = 0;
-                foreach (ZipCentralDirectoryEntry entry in entries)
+                foreach (ZipCentralDirectoryEntry entry in _entries)
                 {
                     size += entry.Write(OutputStream);
                 }
@@ -113,26 +106,27 @@ namespace SharpCompress.Writers.Zip
 
         public Stream WriteToStream(string entryPath, ZipWriterEntryOptions options)
         {
-            var compression = ToZipCompressionMethod(options.CompressionType ?? compressionType);
+            var compression = ToZipCompressionMethod(options.CompressionType ?? _zipWriterOptions.CompressionType);
 
             entryPath = NormalizeFilename(entryPath);
             options.ModificationDateTime = options.ModificationDateTime ?? DateTime.Now;
             options.EntryComment = options.EntryComment ?? string.Empty;
-            var entry = new ZipCentralDirectoryEntry(compression, entryPath, (ulong)streamPosition, WriterOptions.ArchiveEncoding)
+            var entry = new ZipCentralDirectoryEntry(compression, entryPath, (ulong)_streamPosition, WriterOptions.ArchiveEncoding)
             {
                 Comment = options.EntryComment,
                 ModificationTime = options.ModificationDateTime
             };
 
             // Use the archive default setting for zip64 and allow overrides
-            var useZip64 = isZip64;
+            var useZip64 = _zipWriterOptions.UseZip64;
             if (options.EnableZip64.HasValue)
+            {
                 useZip64 = options.EnableZip64.Value;
+            }
 
             var headersize = (uint)WriteHeader(entryPath, options, entry, useZip64);
-            streamPosition += headersize;
-            return new ZipWritingStream(this, OutputStream, entry, compression,
-                options.DeflateCompressionLevel ?? compressionLevel);
+            _streamPosition += headersize;
+            return new ZipWritingStream(this, OutputStream, entry, compression, _zipWriterOptions);
         }
 
         private string NormalizeFilename(string filename)
@@ -154,7 +148,7 @@ namespace SharpCompress.Writers.Zip
             if (!OutputStream.CanSeek && useZip64)
                 throw new NotSupportedException("Zip64 extensions are not supported on non-seekable streams");
 
-            var explicitZipCompressionInfo = ToZipCompressionMethod(zipWriterEntryOptions.CompressionType ?? compressionType);
+            var explicitZipCompressionInfo = ToZipCompressionMethod(zipWriterEntryOptions.CompressionType ?? _zipWriterOptions.CompressionType);
             byte[] encodedFilename = WriterOptions.ArchiveEncoding.Encode(filename);
 
             OutputStream.Write(DataConverter.LittleEndian.GetBytes(ZipHeaderFactory.ENTRY_HEADER_BYTES), 0, 4);
@@ -179,6 +173,10 @@ namespace SharpCompress.Writers.Zip
                     flags |= HeaderFlags.Bit1; // eos marker
                 }
             }
+            if (!string.IsNullOrEmpty(_zipWriterOptions.Password))
+            {
+                 flags |= HeaderFlags.Encrypted;   
+            }
             OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)flags), 0, 2);
             OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)explicitZipCompressionInfo), 0, 2); // zipping method
             OutputStream.Write(DataConverter.LittleEndian.GetBytes(zipWriterEntryOptions.ModificationDateTime.DateTimeToDosTime()), 0, 4);
@@ -214,11 +212,11 @@ namespace SharpCompress.Writers.Zip
 
         private void WriteEndRecord(ulong size)
         {
-            byte[] encodedComment = WriterOptions.ArchiveEncoding.Encode(zipComment);
-            var zip64 = isZip64 || entries.Count > ushort.MaxValue || streamPosition >= uint.MaxValue || size >= uint.MaxValue;
+            byte[] encodedComment = WriterOptions.ArchiveEncoding.Encode(_zipWriterOptions.ArchiveComment ?? string.Empty);
+            var zip64 = _zipWriterOptions.UseZip64 || _entries.Count > ushort.MaxValue || _streamPosition >= uint.MaxValue || size >= uint.MaxValue;
 
             var sizevalue = size >= uint.MaxValue ? uint.MaxValue : (uint)size;
-            var streampositionvalue = streamPosition >= uint.MaxValue ? uint.MaxValue : (uint)streamPosition;
+            var streampositionvalue = _streamPosition >= uint.MaxValue ? uint.MaxValue : (uint)_streamPosition;
 
             if (zip64)
             {
@@ -234,26 +232,26 @@ namespace SharpCompress.Writers.Zip
                 OutputStream.Write(DataConverter.LittleEndian.GetBytes((uint)0), 0, 4); // Central dir disk
 
                 // TODO: entries.Count is int, so max 2^31 files
-                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)entries.Count), 0, 8); // Entries in this disk
-                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)entries.Count), 0, 8); // Total entries
+                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)_entries.Count), 0, 8); // Entries in this disk
+                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)_entries.Count), 0, 8); // Total entries
                 OutputStream.Write(DataConverter.LittleEndian.GetBytes(size), 0, 8); // Central Directory size
-                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)streamPosition), 0, 8); // Disk offset
+                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)_streamPosition), 0, 8); // Disk offset
 
                 // Write zip64 end of central directory locator
                 OutputStream.Write(new byte[] { 80, 75, 6, 7 }, 0, 4);
 
                 OutputStream.Write(DataConverter.LittleEndian.GetBytes(0uL), 0, 4); // Entry disk
-                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)streamPosition + size), 0, 8); // Offset to the zip64 central directory
+                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)_streamPosition + size), 0, 8); // Offset to the zip64 central directory
                 OutputStream.Write(DataConverter.LittleEndian.GetBytes(0u), 0, 4); // Number of disks
 
-                streamPosition += recordlen + (4 + 4 + 8 + 4);
-                streampositionvalue = streamPosition >= uint.MaxValue ? uint.MaxValue : (uint)streampositionvalue;
+                _streamPosition += recordlen + (4 + 4 + 8 + 4);
+                streampositionvalue = _streamPosition >= uint.MaxValue ? uint.MaxValue : (uint)streampositionvalue;
             }
 
             // Write normal end of central directory record
             OutputStream.Write(new byte[] { 80, 75, 5, 6, 0, 0, 0, 0 }, 0, 8);
-            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)entries.Count), 0, 2);
-            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)entries.Count), 0, 2);
+            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)_entries.Count), 0, 2);
+            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)_entries.Count), 0, 2);
             OutputStream.Write(DataConverter.LittleEndian.GetBytes(sizevalue), 0, 4);
             OutputStream.Write(DataConverter.LittleEndian.GetBytes((uint)streampositionvalue), 0, 4);
             OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)encodedComment.Length), 0, 2);
@@ -264,30 +262,29 @@ namespace SharpCompress.Writers.Zip
 
         internal class ZipWritingStream : Stream
         {
-            private readonly CRC32 crc = new CRC32();
-            private readonly ZipCentralDirectoryEntry entry;
-            private readonly Stream originalStream;
-            private readonly Stream writeStream;
-            private readonly ZipWriter writer;
-            private readonly ZipCompressionMethod zipCompressionMethod;
-            private readonly CompressionLevel compressionLevel;
-            private CountingWritableSubStream counting;
-            private ulong decompressed;
+            private readonly CRC32 _crc = new CRC32();
+            private readonly ZipCentralDirectoryEntry _entry;
+            private readonly Stream _originalStream;
+            private readonly Stream _writeStream;
+            private readonly ZipWriter _writer;
+            private readonly ZipWriterOptions _zipWriterOptions;
+            private readonly ZipCompressionMethod _zipCompressionMethod;
+            private CountingWritableSubStream _counting;
+            private ulong _decompressed;
 
             // Flag to prevent throwing exceptions on Dispose
-            private bool limitsExceeded;
-            private bool isDisposed;
+            private bool _limitsExceeded;
 
             internal ZipWritingStream(ZipWriter writer, Stream originalStream, ZipCentralDirectoryEntry entry,
-                ZipCompressionMethod zipCompressionMethod, CompressionLevel compressionLevel)
+                                      ZipCompressionMethod zipCompressionMethod,
+                                      ZipWriterOptions zipWriterOptions)
             {
-                this.writer = writer;
-                this.originalStream = originalStream;
-                this.writer = writer;
-                this.entry = entry;
-                this.zipCompressionMethod = zipCompressionMethod;
-                this.compressionLevel = compressionLevel;
-                writeStream = GetWriteStream(originalStream);
+                this._writer = writer;
+                this._originalStream = originalStream;
+                this._entry = entry;
+                _zipWriterOptions = zipWriterOptions;
+                _zipCompressionMethod = zipCompressionMethod;
+                _writeStream = GetWriteStream(originalStream);
             }
 
             public override bool CanRead => false;
@@ -302,106 +299,109 @@ namespace SharpCompress.Writers.Zip
 
             private Stream GetWriteStream(Stream writeStream)
             {
-                counting = new CountingWritableSubStream(writeStream);
-                Stream output = counting;
-                switch (zipCompressionMethod)
+                _counting = new CountingWritableSubStream(writeStream);
+                Stream output = _counting;
+                Stream compressedStream;
+                switch (_zipCompressionMethod)
                 {
                     case ZipCompressionMethod.None:
                         {
-                            return output;
+                            compressedStream = output;
+                            break;
                         }
                     case ZipCompressionMethod.Deflate:
                         {
-                            return new DeflateStream(counting, CompressionMode.Compress, compressionLevel,
-                                                     true);
+                            compressedStream = new DeflateStream(_counting, CompressionMode.Compress, 
+                                                                 _zipWriterOptions.DeflateCompressionLevel,
+                                                                 true);
+                            break;
                         }
                     case ZipCompressionMethod.BZip2:
                         {
-                            return new BZip2Stream(counting, CompressionMode.Compress, true);
+                            compressedStream = new BZip2Stream(_counting, CompressionMode.Compress, true);
+                            break;
                         }
                     case ZipCompressionMethod.LZMA:
                         {
-                            counting.WriteByte(9);
-                            counting.WriteByte(20);
-                            counting.WriteByte(5);
-                            counting.WriteByte(0);
+                            _counting.WriteByte(9);
+                            _counting.WriteByte(20);
+                            _counting.WriteByte(5);
+                            _counting.WriteByte(0);
 
-                            LzmaStream lzmaStream = new LzmaStream(new LzmaEncoderProperties(!originalStream.CanSeek),
-                                                                   false, counting);
-                            counting.Write(lzmaStream.Properties, 0, lzmaStream.Properties.Length);
-                            return lzmaStream;
+                            LzmaStream lzmaStream = new LzmaStream(new LzmaEncoderProperties(!_originalStream.CanSeek),
+                                                                   false, _counting);
+                            _counting.Write(lzmaStream.Properties, 0, lzmaStream.Properties.Length);
+                            compressedStream = lzmaStream;
+                            break;
                         }
                     case ZipCompressionMethod.PPMd:
                         {
-                            counting.Write(writer.PpmdProperties.Properties, 0, 2);
-                            return new PpmdStream(writer.PpmdProperties, counting, true);
+                            _counting.Write(_writer.PpmdProperties.Properties, 0, 2);
+                            compressedStream = new PpmdStream(_writer.PpmdProperties, _counting, true);
+                            break;
                         }
                     default:
                         {
-                            throw new NotSupportedException("CompressionMethod: " + zipCompressionMethod);
+                            throw new NotSupportedException("CompressionMethod: " + _zipCompressionMethod);
                         }
                 }
+
+                if (string.IsNullOrEmpty(_zipWriterOptions.Password))
+                {
+                    return compressedStream;
+                }
+                
+                var encryptionData = PkwareTraditionalEncryptionData.ForWrite(_zipWriterOptions.Password, _zipWriterOptions.ArchiveEncoding);
+                return new PkwareTraditionalCryptoStream(new NonDisposingStream(writeStream), encryptionData, CryptoMode.Encrypt);
             }
 
             protected override void Dispose(bool disposing)
             {
-                if (isDisposed)
-                {
-                    return;
-                }
-
-                isDisposed = true;
-
                 base.Dispose(disposing);
                 if (disposing)
                 {
-                    writeStream.Dispose();
+                    _writeStream.Dispose();
 
-                    if (limitsExceeded)
+                    if (_limitsExceeded)
                     {
                         // We have written invalid data into the archive,
                         // so we destroy it now, instead of allowing the user to continue
                         // with a defunct archive
-                        originalStream.Dispose();
+                        _originalStream.Dispose();
                         return;
                     }
 
-                    entry.Crc = (uint)crc.Crc32Result;
-                    entry.Compressed = counting.Count;
-                    entry.Decompressed = decompressed;
+                    _entry.Crc = (uint)_crc.Crc32Result;
+                    _entry.Compressed = _counting.Count;
+                    _entry.Decompressed = _decompressed;
 
-                    var zip64 = entry.Compressed >= uint.MaxValue || entry.Decompressed >= uint.MaxValue;
-                    var compressedvalue = zip64 ? uint.MaxValue : (uint)counting.Count;
-                    var decompressedvalue = zip64 ? uint.MaxValue : (uint)entry.Decompressed;
+                    var zip64 = _entry.Compressed >= uint.MaxValue || _entry.Decompressed >= uint.MaxValue;
+                    var compressedvalue = zip64 ? uint.MaxValue : (uint)_counting.Count;
+                    var decompressedvalue = zip64 ? uint.MaxValue : (uint)_entry.Decompressed;
 
-                    if (originalStream.CanSeek)
+                    if (_originalStream.CanSeek)
                     {
-                        originalStream.Position = (long)(entry.HeaderOffset + 6);
-                        originalStream.WriteByte(0);
-
-                        originalStream.Position = (long)(entry.HeaderOffset + 14);
-
-                        writer.WriteFooter(entry.Crc, compressedvalue, decompressedvalue);
+                        _writer.WriteFooter(_entry.Crc, compressedvalue, decompressedvalue);
 
                         // Ideally, we should not throw from Dispose()
                         // We should not get here as the Write call checks the limits
-                        if (zip64 && entry.Zip64HeaderOffset == 0)
+                        if (zip64 && _entry.Zip64HeaderOffset == 0)
                             throw new NotSupportedException("Attempted to write a stream that is larger than 4GiB without setting the zip64 option");
 
                         // If we have pre-allocated space for zip64 data,
                         // fill it out, even if it is not required
-                        if (entry.Zip64HeaderOffset != 0)
+                        if (_entry.Zip64HeaderOffset != 0)
                         {
-                            originalStream.Position = (long)(entry.HeaderOffset + entry.Zip64HeaderOffset);
-                            originalStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0x0001), 0, 2);
-                            originalStream.Write(DataConverter.LittleEndian.GetBytes((ushort)(8 + 8)), 0, 2);
+                            _originalStream.Position = (long)(_entry.HeaderOffset + _entry.Zip64HeaderOffset);
+                            _originalStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0x0001), 0, 2);
+                            _originalStream.Write(DataConverter.LittleEndian.GetBytes((ushort)(8 + 8)), 0, 2);
 
-                            originalStream.Write(DataConverter.LittleEndian.GetBytes(entry.Decompressed), 0, 8);
-                            originalStream.Write(DataConverter.LittleEndian.GetBytes(entry.Compressed), 0, 8);
+                            _originalStream.Write(DataConverter.LittleEndian.GetBytes(_entry.Decompressed), 0, 8);
+                            _originalStream.Write(DataConverter.LittleEndian.GetBytes(_entry.Compressed), 0, 8);
                         }
 
-                        originalStream.Position = writer.streamPosition + (long)entry.Compressed;
-                        writer.streamPosition += (long)entry.Compressed;
+                        _originalStream.Position = _writer._streamPosition + (long)_entry.Compressed;
+                        _writer._streamPosition += (long)_entry.Compressed;
                     }
                     else
                     {
@@ -414,19 +414,19 @@ namespace SharpCompress.Writers.Zip
                         if (zip64)
                             throw new NotSupportedException("Streams larger than 4GiB are not supported for non-seekable streams");
 
-                        originalStream.Write(DataConverter.LittleEndian.GetBytes(ZipHeaderFactory.POST_DATA_DESCRIPTOR), 0, 4);
-                        writer.WriteFooter(entry.Crc,
+                        _originalStream.Write(DataConverter.LittleEndian.GetBytes(ZipHeaderFactory.POST_DATA_DESCRIPTOR), 0, 4);
+                        _writer.WriteFooter(_entry.Crc,
                                            (uint)compressedvalue,
                                            (uint)decompressedvalue);
-                        writer.streamPosition += (long)entry.Compressed + 16;
+                        _writer._streamPosition += (long)_entry.Compressed + 16;
                     }
-                    writer.entries.Add(entry);
+                    _writer._entries.Add(_entry);
                 }
             }
 
             public override void Flush()
             {
-                writeStream.Flush();
+                _writeStream.Flush();
             }
 
             public override int Read(byte[] buffer, int offset, int count)
@@ -448,27 +448,27 @@ namespace SharpCompress.Writers.Zip
             {
                 // We check the limits first, because we can keep the archive consistent
                 // if we can prevent the writes from happening
-                if (entry.Zip64HeaderOffset == 0)
+                if (_entry.Zip64HeaderOffset == 0)
                 {
                     // Pre-check, the counting.Count is not exact, as we do not know the size before having actually compressed it
-                    if (limitsExceeded || ((decompressed + (uint)count) > uint.MaxValue) || (counting.Count + (uint)count) > uint.MaxValue)
+                    if (_limitsExceeded || ((_decompressed + (uint)count) > uint.MaxValue) || (_counting.Count + (uint)count) > uint.MaxValue)
                         throw new NotSupportedException("Attempted to write a stream that is larger than 4GiB without setting the zip64 option");
                 }
 
-                decompressed += (uint)count;
-                crc.SlurpBlock(buffer, offset, count);
-                writeStream.Write(buffer, offset, count);
+                _decompressed += (uint)count;
+                _crc.SlurpBlock(buffer, offset, count);
+                _writeStream.Write(buffer, offset, count);
 
-                if (entry.Zip64HeaderOffset == 0)
+                if (_entry.Zip64HeaderOffset == 0)
                 {
                     // Post-check, this is accurate
-                    if ((decompressed > uint.MaxValue) || counting.Count > uint.MaxValue)
+                    if ((_decompressed > uint.MaxValue) || _counting.Count > uint.MaxValue)
                     {
                         // We have written the data, so the archive is now broken
                         // Throwing the exception here, allows us to avoid
                         // throwing an exception in Dispose() which is discouraged
                         // as it can mask other errors
-                        limitsExceeded = true;
+                        _limitsExceeded = true;
                         throw new NotSupportedException("Attempted to write a stream that is larger than 4GiB without setting the zip64 option");
                     }
                 }

src/SharpCompress/Writers/Zip/ZipWriterOptions.cs

@@ -40,5 +40,10 @@ namespace SharpCompress.Writers.Zip
 		/// are less than 4GiB in length.
         /// </summary>
         public bool UseZip64 { get; set; }
+        
+        /// <summary>
+        /// Setting a password will encrypt the zip archive with the Pkware style.
+        /// </summary>
+        public string Password { get; set; }
     }
 }

tests/SharpCompress.Test/ArchiveTests.cs

@@ -40,7 +40,7 @@ namespace SharpCompress.Test
                     foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
                     {
                         entry.WriteToDirectory(SCRATCH_FILES_PATH,
-                                               new ExtractionOptions
+                                               new ExtractionOptions()
                                                {
                                                    ExtractFullPath = true,
                                                    Overwrite = true
@@ -51,24 +51,24 @@ namespace SharpCompress.Test
             }
         }
 
-        protected void ArchiveStreamRead(string testArchive, ReaderOptions readerOptions = null)
+        protected void ArchiveStreamRead(string testArchive)
         {
             testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
-            ArchiveStreamRead(readerOptions, testArchive.AsEnumerable());
+            ArchiveStreamRead(testArchive.AsEnumerable());
         }
 
-        protected void ArchiveStreamRead(ReaderOptions readerOptions = null, params string[] testArchives)
+        protected void ArchiveStreamRead(params string[] testArchives)
         {
-            ArchiveStreamRead(readerOptions, testArchives.Select(x => Path.Combine(TEST_ARCHIVES_PATH, x)));
+            ArchiveStreamRead(testArchives.Select(x => Path.Combine(TEST_ARCHIVES_PATH, x)));
         }
 
-        protected void ArchiveStreamRead(ReaderOptions readerOptions, IEnumerable<string> testArchives)
+        protected void ArchiveStreamRead(IEnumerable<string> testArchives)
         {
             foreach (var path in testArchives)
             {
                 ResetScratch();
                 using (Stream stream = File.OpenRead(path))
-                using (var archive = ArchiveFactory.Open(stream, readerOptions))
+                using (var archive = ArchiveFactory.Open(stream))
                 {
                     foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
                     {
@@ -83,17 +83,17 @@ namespace SharpCompress.Test
             }
         }
 
-        protected void ArchiveFileRead(string testArchive, ReaderOptions readerOptions = null)
+        protected void ArchiveFileRead(string testArchive)
         {
             testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
-            ArchiveFileRead(testArchive.AsEnumerable(), readerOptions);
+            ArchiveFileRead(testArchive.AsEnumerable());
         }
-        protected void ArchiveFileRead(IEnumerable<string> testArchives, ReaderOptions readerOptions = null)
+        protected void ArchiveFileRead(IEnumerable<string> testArchives)
         {
             foreach (var path in testArchives)
             {
                 ResetScratch();
-                using (var archive = ArchiveFactory.Open(path, readerOptions))
+                using (var archive = ArchiveFactory.Open(path))
                 {
                     //archive.EntryExtractionBegin += archive_EntryExtractionBegin;
                     //archive.FilePartExtractionBegin += archive_FilePartExtractionBegin;

tests/SharpCompress.Test/Rar/RarArchiveTests.cs

@@ -35,10 +35,10 @@ namespace SharpCompress.Test.Rar
             ResetScratch();
             using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, testArchive)))
             using (var archive = RarArchive.Open(stream, new ReaderOptions()
-            {
-                Password = password,
-                LeaveStreamOpen = true
-            }))
+                                                         {
+                                                             Password = password,
+                                                             LeaveStreamOpen = true
+                                                         }))
             {
                 foreach (var entry in archive.Entries)
                 {
@@ -66,10 +66,10 @@ namespace SharpCompress.Test.Rar
         {
             ResetScratch();
             using (var archive = RarArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, archiveName), new ReaderOptions()
-            {
-                Password = password,
-                LeaveStreamOpen = true
-            }))
+                                                            {
+                                                                Password = password,
+                                                                LeaveStreamOpen = true
+                                                            }))
             {
                 foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
                 {
@@ -120,12 +120,12 @@ namespace SharpCompress.Test.Rar
         public void Rar_Jpg_ArchiveStreamRead()
         {
             ResetScratch();
-            using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rarjpeg.jpg")))
+            using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "RarJpeg.jpg")))
             {
                 using (var archive = RarArchive.Open(stream, new ReaderOptions()
-                {
-                    LookForHeader = true
-                }))
+                                                             {
+                                                                 LookForHeader = true
+                                                             }))
                 {
                     foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
                     {
@@ -224,7 +224,7 @@ namespace SharpCompress.Test.Rar
                 using (var archive = RarArchive.Open(stream))
                 {
                     Assert.False(archive.IsSolid);
-                    Assert.Contains(true, archive.Entries.Select(entry => entry.IsDirectory));
+                    Assert.True(archive.Entries.Any(entry => entry.IsDirectory));
                 }
             }
         }
@@ -233,10 +233,10 @@ namespace SharpCompress.Test.Rar
         public void Rar_Jpg_ArchiveFileRead()
         {
             ResetScratch();
-            using (var archive = RarArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, "Rarjpeg.jpg"), new ReaderOptions()
-            {
-                LookForHeader = true
-            }))
+            using (var archive = RarArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, "RarJpeg.jpg"), new ReaderOptions()
+                                                                                                  {
+                                                                                                      LookForHeader = true
+                                                                                                  }))
             {
                 foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
                 {

tests/SharpCompress.Test/Rar/RarHeaderFactoryTest.cs

@@ -12,14 +12,14 @@ namespace SharpCompress.Test.Rar
     public class RarHeaderFactoryTest : TestBase
     {
         private readonly RarHeaderFactory rarHeaderFactory;
-
+        
         public RarHeaderFactoryTest()
         {
             ResetScratch();
             rarHeaderFactory = new RarHeaderFactory(StreamingMode.Seekable, new ReaderOptions()
-            {
-                LeaveStreamOpen = true
-            });
+                                                                            {
+                                                                                LeaveStreamOpen = true
+                                                                            });
         }
 
 
@@ -27,7 +27,7 @@ namespace SharpCompress.Test.Rar
         public void ReadHeaders_RecognizeEncryptedFlag()
         {
 
-            ReadEncryptedFlag("Rar.encrypted_filesAndHeader.rar", true);
+            ReadEncryptedFlag("Rar.Encrypted_filesAndHeader.rar", true);
 
 
 

tests/SharpCompress.Test/Rar/RarReaderTests.cs

@@ -149,9 +149,9 @@ namespace SharpCompress.Test.Rar
             ResetScratch();
             using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, testArchive)))
             using (var reader = RarReader.Open(stream, new ReaderOptions()
-            {
-                Password = password
-            }))
+                                                       {
+                                                           Password = password
+                                                       }))
             {
                 while (reader.MoveToNextEntry())
                 {
@@ -209,9 +209,9 @@ namespace SharpCompress.Test.Rar
             ResetScratch();
             using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Audio_program.rar")))
             using (var reader = RarReader.Open(stream, new ReaderOptions()
-            {
-                LookForHeader = true
-            }))
+                                                       {
+                                                           LookForHeader = true
+                                                       }))
             {
                 while (reader.MoveToNextEntry())
                 {
@@ -231,11 +231,11 @@ namespace SharpCompress.Test.Rar
         public void Rar_Jpg_Reader()
         {
             ResetScratch();
-            using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rarjpeg.jpg")))
+            using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "RarJpeg.jpg")))
             using (var reader = RarReader.Open(stream, new ReaderOptions()
-            {
-                LookForHeader = true
-            }))
+                                                        {
+                                                            LookForHeader = true
+                                                        }))
             {
                 while (reader.MoveToNextEntry())
                 {
@@ -262,9 +262,9 @@ namespace SharpCompress.Test.Rar
             ResetScratch();
             using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rar.solid.rar")))
             using (var reader = RarReader.Open(stream, new ReaderOptions()
-            {
-                LookForHeader = true
-            }))
+                                                        {
+                                                            LookForHeader = true
+                                                        }))
             {
                 while (reader.MoveToNextEntry())
                 {
@@ -287,9 +287,9 @@ namespace SharpCompress.Test.Rar
             ResetScratch();
             using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rar.rar")))
             using (var reader = RarReader.Open(stream, new ReaderOptions()
-            {
-                LookForHeader = true
-            }))
+                                                            {
+                                                                LookForHeader = true
+                                                            }))
             {
                 while (reader.MoveToNextEntry())
                 {

tests/SharpCompress.Test/SevenZip/SevenZipArchiveTests.cs

@@ -1,6 +1,5 @@
 using System;
 using SharpCompress.Common;
-using SharpCompress.Readers;
 using Xunit;
 
 namespace SharpCompress.Test.SevenZip
@@ -19,17 +18,6 @@ namespace SharpCompress.Test.SevenZip
             ArchiveFileRead("7Zip.LZMA.7z");
         }
 
-        [Fact]
-        public void SevenZipArchive_LZMAAES_StreamRead()
-        {
-            ArchiveStreamRead("7Zip.LZMA.Aes.7z", new ReaderOptions() {Password = "testpassword"});
-        }
-
-        [Fact]
-        public void SevenZipArchive_LZMAAES_PathRead()
-        {
-            ArchiveFileRead("7Zip.LZMA.Aes.7z", new ReaderOptions() {Password = "testpassword"});
-        }
         [Fact]
         public void SevenZipArchive_PPMd_StreamRead()
         {
@@ -47,7 +35,6 @@ namespace SharpCompress.Test.SevenZip
         {
             ArchiveFileRead("7Zip.PPMd.7z");
         }
-
         [Fact]
         public void SevenZipArchive_LZMA2_StreamRead()
         {
@@ -59,19 +46,6 @@ namespace SharpCompress.Test.SevenZip
         {
             ArchiveFileRead("7Zip.LZMA2.7z");
         }
-
-        [Fact]
-        public void SevenZipArchive_LZMA2AES_StreamRead()
-        {
-            ArchiveStreamRead("7Zip.LZMA2.Aes.7z", new ReaderOptions {Password = "testpassword"});
-        }
-
-        [Fact]
-        public void SevenZipArchive_LZMA2AES_PathRead()
-        {
-            ArchiveFileRead("7Zip.LZMA2.Aes.7z", new ReaderOptions {Password = "testpassword"});
-        }
-
         [Fact]
         public void SevenZipArchive_BZip2_StreamRead()
         {
@@ -93,13 +67,9 @@ namespace SharpCompress.Test.SevenZip
         [Fact]
         public void SevenZipArchive_BZip2_Split()
         {
-            Assert.Throws<IndexOutOfRangeException>(() => ArchiveStreamRead(null, "Original.7z.001",
-                                                                            "Original.7z.002",
-                                                                            "Original.7z.003",
-                                                                            "Original.7z.004",
-                                                                            "Original.7z.005",
-                                                                            "Original.7z.006",
-                                                                            "Original.7z.007"));
+            Assert.Throws<IndexOutOfRangeException>(() => ArchiveStreamRead("Original.7z.001", "Original.7z.002",
+                "Original.7z.003", "Original.7z.004", "Original.7z.005",
+                "Original.7z.006", "Original.7z.007"));
         }
     }
-}
+}

tests/SharpCompress.Test/SharpCompress.Test.csproj

@@ -1,25 +1,28 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp2.0</TargetFrameworks>
+    <TargetFramework>netcoreapp1.1</TargetFramework>
     <AssemblyName>SharpCompress.Test</AssemblyName>
     <AssemblyOriginatorKeyFile>../../SharpCompress.snk</AssemblyOriginatorKeyFile>
     <SignAssembly>true</SignAssembly>
     <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
     <PackageId>SharpCompress.Test</PackageId>
     <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
+    <RuntimeFrameworkVersion>1.1.2</RuntimeFrameworkVersion>
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\src\SharpCompress\SharpCompress.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
-    <PackageReference Include="xunit" Version="2.3.1" />
-  </ItemGroup>
-  <ItemGroup Condition=" '$(TargetFramework)' != 'netstandard2.0' ">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta2-build1317" />
     <PackageReference Include="Microsoft.Extensions.PlatformAbstractions" Version="1.1.0" />
+    <PackageReference Include="xunit" Version="2.3.0-beta2-build3683" />
+    <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.0-beta2-build3683" />
   </ItemGroup>
-  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
-    <PackageReference Include="NETStandard.Library" Version="2.0.0" />
+  <ItemGroup>
+    <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Xz\" />
   </ItemGroup>
 </Project>

tests/SharpCompress.Test/Tar/TarArchiveTests.cs

@@ -35,11 +35,11 @@ namespace SharpCompress.Test.Tar
             using (var archive = TarArchive.Open(unmodified))
             {
                 Assert.Equal(5, archive.Entries.Count);
-                Assert.Contains("very long filename/", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("very long filename/very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename.jpg", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("z_file 1.txt", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("z_file 2.txt", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("z_file 3.txt", archive.Entries.Select(entry => entry.Key));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "very long filename/"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "very long filename/very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename.jpg"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "z_file 1.txt"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "z_file 2.txt"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "z_file 3.txt"));
             }
         }
 
@@ -74,7 +74,7 @@ namespace SharpCompress.Test.Tar
             using (var archive2 = TarArchive.Open(unmodified))
             {
                 Assert.Equal(1, archive2.Entries.Count);
-                Assert.Contains(longFilename, archive2.Entries.Select(entry => entry.Key));
+                Assert.True(archive2.Entries.Any(entry => entry.Key == longFilename));
 
                 foreach (var entry in archive2.Entries)
                     Assert.Equal("dummy filecontent", new StreamReader(entry.OpenEntryStream()).ReadLine());
@@ -85,15 +85,15 @@ namespace SharpCompress.Test.Tar
         public void Tar_UstarArchivePathReadLongName()
         {
             string unmodified = Path.Combine(TEST_ARCHIVES_PATH, "ustar with long names.tar");
-            using (var archive = TarArchive.Open(unmodified))
+            using(var archive = TarArchive.Open(unmodified))
             {
                 Assert.Equal(6, archive.Entries.Count);
-                Assert.Contains("Directory/", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("Directory/Some file with veeeeeeeeeery loooooooooong name", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("Directory/Directory with veeeeeeeeeery loooooooooong name/", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("Directory/Directory with veeeeeeeeeery loooooooooong name/Some file with veeeeeeeeeery loooooooooong name", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("Directory/Directory with veeeeeeeeeery loooooooooong name/Directory with veeeeeeeeeery loooooooooong name/", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("Directory/Directory with veeeeeeeeeery loooooooooong name/Directory with veeeeeeeeeery loooooooooong name/Some file with veeeeeeeeeery loooooooooong name", archive.Entries.Select(entry => entry.Key));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "Directory/"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "Directory/Some file with veeeeeeeeeery loooooooooong name"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "Directory/Directory with veeeeeeeeeery loooooooooong name/"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "Directory/Directory with veeeeeeeeeery loooooooooong name/Some file with veeeeeeeeeery loooooooooong name"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "Directory/Directory with veeeeeeeeeery loooooooooong name/Directory with veeeeeeeeeery loooooooooong name/"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "Directory/Directory with veeeeeeeeeery loooooooooong name/Directory with veeeeeeeeeery loooooooooong name/Some file with veeeeeeeeeery loooooooooong name"));
             }
         }
 
@@ -114,7 +114,7 @@ namespace SharpCompress.Test.Tar
         [Fact]
         public void Tar_Random_Write_Add()
         {
-            string jpg = Path.Combine(ORIGINAL_FILES_PATH, "jpg", "test.jpg");
+            string jpg = Path.Combine(ORIGINAL_FILES_PATH, "jpg","test.jpg");
             string scratchPath = Path.Combine(SCRATCH_FILES_PATH, "Tar.mod.tar");
             string unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.mod.tar");
             string modified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.noEmptyDirs.tar");

tests/SharpCompress.Test/TestBase.cs

@@ -3,6 +3,8 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading;
+using Microsoft.Extensions.PlatformAbstractions;
+using SharpCompress.Common;
 using SharpCompress.Readers;
 using Xunit;
 
@@ -10,7 +12,7 @@ namespace SharpCompress.Test
 {
     public class TestBase : IDisposable
     {
-        protected string SOLUTION_BASE_PATH = null;
+        protected string SOLUTION_BASE_PATH=null;
         protected string TEST_ARCHIVES_PATH;
         protected string ORIGINAL_FILES_PATH;
         protected string MISC_TEST_FILES_PATH;
@@ -179,11 +181,6 @@ namespace SharpCompress.Test
 
         protected void CompareFilesByPath(string file1, string file2)
         {
-            //TODO: fix line ending issues with the text file
-            if (file1.EndsWith("txt"))
-            {
-                return;
-            }
             using (var file1Stream = File.OpenRead(file1))
             using (var file2Stream = File.OpenRead(file2))
             {
@@ -240,14 +237,8 @@ namespace SharpCompress.Test
         public TestBase()
         {
             Monitor.Enter(lockObject);
-
-#if NETSTANDARD20
-            var index = AppDomain.CurrentDomain.BaseDirectory.IndexOf("SharpCompress.Test", StringComparison.OrdinalIgnoreCase);
-            SOLUTION_BASE_PATH = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory.Substring(0, index));
-#else
-            var index = Microsoft.Extensions.PlatformAbstractions.PlatformServices.Default.Application.ApplicationBasePath.IndexOf("SharpCompress.Test", StringComparison.OrdinalIgnoreCase);
-            SOLUTION_BASE_PATH = Path.GetDirectoryName(Microsoft.Extensions.PlatformAbstractions.PlatformServices.Default.Application.ApplicationBasePath.Substring(0, index));
-#endif
+            var index = PlatformServices.Default.Application.ApplicationBasePath.IndexOf("SharpCompress.Test", StringComparison.OrdinalIgnoreCase);
+            SOLUTION_BASE_PATH = Path.GetDirectoryName(PlatformServices.Default.Application.ApplicationBasePath.Substring(0, index));
             TEST_ARCHIVES_PATH = Path.Combine(SOLUTION_BASE_PATH, "TestArchives", "Archives");
             ORIGINAL_FILES_PATH = Path.Combine(SOLUTION_BASE_PATH, "TestArchives", "Original");
             MISC_TEST_FILES_PATH = Path.Combine(SOLUTION_BASE_PATH, "TestArchives", "MiscTest");

tests/SharpCompress.Test/Xz/XZBlockTests.cs

@@ -12,11 +12,6 @@ namespace SharpCompress.Test.Xz
             stream.Position = 12;
         }
 
-        protected override void RewindIndexed(Stream stream)
-        {
-            stream.Position = 12;
-        }
-
         private byte[] ReadBytes(XZBlock block, int bytesToRead)
         {
             byte[] buffer = new byte[bytesToRead];
@@ -74,25 +69,5 @@ namespace SharpCompress.Test.Xz
             var sr = new StreamReader(XZBlock);
             Assert.Equal(sr.ReadToEnd(), Original);
         }
-
-        [Fact]
-        public void NoopWhenNoPadding()
-        {
-            // CompressedStream's only block has no padding.
-            var XZBlock = new XZBlock(CompressedStream, CheckType.CRC64, 8);
-            var sr = new StreamReader(XZBlock);
-            sr.ReadToEnd();
-            Assert.Equal(0L, CompressedStream.Position % 4L);
-        }
-
-        [Fact]
-        public void SkipsPaddingWhenPresent()
-        {
-            // CompressedIndexedStream's first block has 1-byte padding.
-            var XZBlock = new XZBlock(CompressedIndexedStream, CheckType.CRC64, 8);
-            var sr = new StreamReader(XZBlock);
-            sr.ReadToEnd();
-            Assert.Equal(0L, CompressedIndexedStream.Position % 4L);
-        }
     }
 }

tests/SharpCompress.Test/Xz/XZIndexTests.cs

@@ -6,21 +6,11 @@ namespace SharpCompress.Test.Xz
 {
     public class XZIndexTests : XZTestsBase
     {
-        protected override void RewindEmpty(Stream stream)
-        {
-            stream.Position = 12;
-        }
-
         protected override void Rewind(Stream stream)
         {
             stream.Position = 356;
         }
 
-        protected override void RewindIndexed(Stream stream)
-        {
-            stream.Position = 612;
-        }
-
         [Fact]
         public void RecordsStreamStartOnInit()
         {
@@ -44,52 +34,12 @@ namespace SharpCompress.Test.Xz
         }
 
         [Fact]
-        public void ReadsNoRecord()
-        {
-            BinaryReader br = new BinaryReader(CompressedEmptyStream);
-            var index = new XZIndex(br, false);
-            index.Process();
-            Assert.Equal((ulong)0, index.NumberOfRecords);
-        }
-
-        [Fact]
-        public void ReadsOneRecord()
+        public void ReadsNumberOfRecords()
         {
             BinaryReader br = new BinaryReader(CompressedStream);
             var index = new XZIndex(br, false);
             index.Process();
-            Assert.Equal((ulong)1, index.NumberOfRecords);
-        }
-
-        [Fact]
-        public void ReadsMultipleRecords()
-        {
-            BinaryReader br = new BinaryReader(CompressedIndexedStream);
-            var index = new XZIndex(br, false);
-            index.Process();
-            Assert.Equal((ulong)2, index.NumberOfRecords);
-        }
-
-        [Fact]
-        public void ReadsFirstRecord()
-        {
-            BinaryReader br = new BinaryReader(CompressedStream);
-            var index = new XZIndex(br, false);
-            index.Process();
-            Assert.Equal((ulong)OriginalBytes.Length, index.Records[0].UncompressedSize);
-        }
-
-        [Fact]
-        public void SkipsPadding()
-        {
-            // Index with 3-byte padding.
-            using (Stream badStream = new MemoryStream(new byte[] { 0x00, 0x01, 0x10, 0x80, 0x01, 0x00, 0x00, 0x00, 0xB1, 0x01, 0xD9, 0xC9, 0xFF }))
-            {
-                BinaryReader br = new BinaryReader(badStream);
-                var index = new XZIndex(br, false);
-                index.Process();
-                Assert.Equal(0L, badStream.Position % 4L);
-            }
+            Assert.Equal(index.NumberOfRecords, (ulong)1);
         }
     }
 }

tests/SharpCompress.Test/Xz/XZStreamTests.cs

@@ -4,19 +4,8 @@ using Xunit;
 
 namespace SharpCompress.Test.Xz
 {
-    public class XZStreamTests : XZTestsBase
+    public class XZStreamReaderTests : XZTestsBase
     {
-        [Fact]
-        public void CanReadEmptyStream()
-        {
-            XZStream xz = new XZStream(CompressedEmptyStream);
-            using (var sr = new StreamReader(xz))
-            {
-                string uncompressed = sr.ReadToEnd();
-                Assert.Equal(OriginalEmpty, uncompressed);
-            }
-        }
-
         [Fact]
         public void CanReadStream()
         {
@@ -24,18 +13,7 @@ namespace SharpCompress.Test.Xz
             using (var sr = new StreamReader(xz))
             {
                 string uncompressed = sr.ReadToEnd();
-                Assert.Equal(Original, uncompressed);
-            }
-        }
-
-        [Fact]
-        public void CanReadIndexedStream()
-        {
-            XZStream xz = new XZStream(CompressedIndexedStream);
-            using (var sr = new StreamReader(xz))
-            {
-                string uncompressed = sr.ReadToEnd();
-                Assert.Equal(OriginalIndexed, uncompressed);
+                Assert.Equal(uncompressed, Original);
             }
         }
     }

tests/SharpCompress.Test/Xz/XZTestsBase.cs

@@ -7,14 +7,7 @@ namespace SharpCompress.Test.Xz
     {
         public XZTestsBase()
         {
-            RewindEmpty(CompressedEmptyStream);
             Rewind(CompressedStream);
-            RewindIndexed(CompressedIndexedStream);
-        }
-
-        protected virtual void RewindEmpty(Stream stream)
-        {
-            stream.Position = 0;
         }
 
         protected virtual void Rewind(Stream stream)
@@ -22,22 +15,6 @@ namespace SharpCompress.Test.Xz
             stream.Position = 0;
         }
 
-        protected virtual void RewindIndexed(Stream stream)
-        {
-            stream.Position = 0;
-        }
-
-        protected Stream CompressedEmptyStream { get; } = new MemoryStream(CompressedEmpty);
-
-        protected static byte[] CompressedEmpty { get; } = new byte[] {
-            0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00, 0x00, 0x01, 0x69, 0x22, 0xde, 0x36, 0x00, 0x00, 0x00, 0x00,
-            0x1c, 0xdf, 0x44, 0x21, 0x90, 0x42, 0x99, 0x0d, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x59, 0x5a
-        };
-
-        protected static byte[] OriginalEmptyBytes => Encoding.ASCII.GetBytes(OriginalEmpty);
-
-        protected static string OriginalEmpty { get; } = string.Empty;
-
         protected Stream CompressedStream { get; } = new MemoryStream(Compressed);  
 
         protected static byte[] Compressed { get; } = new byte[] {
@@ -88,54 +65,5 @@ namespace SharpCompress.Test.Xz
             "The eager children cry.\r\n" +
             "\"Why, Mary loves the lamb, you know.\"\r\n" +
             "The teacher did reply.";
-
-        protected Stream CompressedIndexedStream { get; } = new MemoryStream(CompressedIndexed);
-
-        protected static byte[] CompressedIndexed { get; } = new byte[] {
-            0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00, 0x00, 0x01, 0x69, 0x22, 0xde, 0x36, 0x03, 0xc0, 0xe3, 0x02,
-            0x80, 0x20, 0x21, 0x01, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xe5, 0xd7, 0x32, 0xe0, 0x0f, 0xff, 0x01,
-            0x5b, 0x5d, 0x00, 0x26, 0x98, 0x4a, 0x47, 0xc6, 0x6a, 0x27, 0xd7, 0x36, 0x7a, 0x05, 0xb9, 0x4f,
-            0xd7, 0xde, 0x3a, 0x0e, 0xee, 0x1b, 0xd7, 0x81, 0xe9, 0xf5, 0x90, 0x1e, 0xd5, 0x9e, 0x88, 0x32,
-            0x1c, 0x7b, 0x43, 0x84, 0x02, 0x58, 0x92, 0xcf, 0x97, 0xfc, 0xae, 0x01, 0x83, 0x23, 0x48, 0x93,
-            0xc6, 0x56, 0xcc, 0x6d, 0xb1, 0x23, 0x10, 0x24, 0x3b, 0x9e, 0x06, 0xaa, 0xc0, 0xce, 0x86, 0x0a,
-            0xb7, 0x9f, 0x99, 0x61, 0xbe, 0x3b, 0x6d, 0xfe, 0x60, 0xef, 0x14, 0x35, 0x7f, 0x21, 0xe8, 0x96,
-            0x0e, 0xbd, 0x41, 0x7c, 0x65, 0x89, 0x96, 0x28, 0x5e, 0x85, 0xa6, 0x4b, 0xf3, 0xf9, 0xf8, 0x25,
-            0x31, 0x4a, 0xbb, 0x72, 0xce, 0xcf, 0x53, 0xdf, 0x13, 0x42, 0x2d, 0xbc, 0x95, 0xa5, 0x6d, 0xc4,
-            0x8c, 0x72, 0x99, 0xe8, 0x9a, 0xcf, 0x80, 0xd4, 0xc4, 0x3f, 0x55, 0xc3, 0x9b, 0x00, 0xce, 0x65,
-            0x27, 0x6e, 0xbf, 0xb2, 0x88, 0xab, 0xc0, 0x5f, 0xf9, 0xd0, 0xc8, 0xbb, 0xd7, 0x48, 0xd7, 0x2e,
-            0x5e, 0xbb, 0x23, 0x35, 0x6e, 0x62, 0xb6, 0x13, 0xd4, 0x06, 0xd1, 0x5b, 0x97, 0xee, 0x5b, 0x89,
-            0x78, 0x07, 0x24, 0x74, 0x59, 0x06, 0x1e, 0x7f, 0x8c, 0xb0, 0x48, 0xff, 0x0a, 0x76, 0xb2, 0x07,
-            0xa0, 0x99, 0xf5, 0x4b, 0x68, 0xd4, 0x55, 0x32, 0xb3, 0x17, 0x7b, 0xb6, 0x26, 0xdb, 0x1c, 0xc3,
-            0x0b, 0xda, 0x3e, 0x46, 0xba, 0x1a, 0x67, 0x23, 0xb7, 0x2a, 0x40, 0xdc, 0xc9, 0xa2, 0xe4, 0xb5,
-            0x68, 0x5c, 0x81, 0x60, 0xa7, 0xad, 0xe6, 0xba, 0xbb, 0x0d, 0x82, 0x8a, 0xe2, 0x03, 0xa9, 0x22,
-            0x09, 0x5e, 0xd8, 0x69, 0xfa, 0x29, 0xd1, 0x32, 0xa1, 0xf0, 0x9b, 0x3c, 0xc3, 0x0b, 0x9a, 0x53,
-            0xf0, 0x3e, 0xf3, 0x1b, 0x77, 0xee, 0x8f, 0xa6, 0x15, 0x02, 0x77, 0x14, 0x54, 0x60, 0xae, 0xbe,
-            0x91, 0x9e, 0xe6, 0x8b, 0x87, 0x6e, 0x46, 0x44, 0x64, 0xc7, 0x58, 0x90, 0x62, 0x25, 0x32, 0xf9,
-            0xcd, 0xd2, 0x73, 0x2e, 0x3f, 0xd7, 0x5d, 0x3c, 0x86, 0x1c, 0xa8, 0x35, 0xa9, 0xc2, 0xcb, 0x59,
-            0xcb, 0xac, 0xb3, 0x03, 0x12, 0xd4, 0x8a, 0xde, 0xd5, 0xc1, 0xd8, 0x0c, 0x32, 0x49, 0x87, 0x97,
-            0x62, 0x4f, 0x32, 0x39, 0x63, 0x5b, 0x8b, 0xd1, 0x6c, 0x5c, 0x90, 0xd9, 0x93, 0x13, 0xae, 0x70,
-            0xf5, 0x2f, 0x40, 0xaf, 0x01, 0x95, 0x01, 0x0c, 0xc5, 0xfa, 0x82, 0xf8, 0x71, 0x9d, 0x53, 0xe6,
-            0x47, 0x6e, 0x99, 0x54, 0x57, 0x41, 0x72, 0xea, 0xf5, 0x78, 0xdd, 0x86, 0xbd, 0x00, 0x00, 0x00,
-            0x72, 0x6a, 0xf2, 0x47, 0x03, 0xc0, 0xcb, 0x01, 0x8d, 0x02, 0x21, 0x01, 0x00, 0x00, 0x00, 0x00,
-            0xfb, 0xa7, 0xf7, 0x94, 0xe0, 0x01, 0x0c, 0x00, 0xc3, 0x5d, 0x00, 0x06, 0x82, 0xca, 0x9b, 0x77,
-            0x93, 0x57, 0xb3, 0x76, 0xbd, 0x8b, 0xcb, 0xee, 0xf4, 0x2c, 0xff, 0x7f, 0x95, 0x33, 0x15, 0x10,
-            0xa5, 0xf9, 0xfd, 0xa6, 0xbb, 0x9e, 0xf9, 0x75, 0x67, 0xee, 0xec, 0x8b, 0x40, 0xea, 0x32, 0x47,
-            0x3d, 0x26, 0xbe, 0x11, 0x9c, 0xa6, 0x40, 0xbe, 0x84, 0x1f, 0x1b, 0x35, 0x1a, 0x66, 0x10, 0x9c,
-            0xf4, 0x12, 0x1a, 0x95, 0x81, 0xb5, 0x55, 0x6b, 0xc5, 0x42, 0xfd, 0x37, 0x70, 0xc5, 0x08, 0xa4,
-            0x27, 0x67, 0x11, 0x0b, 0x1f, 0xcc, 0xdb, 0x54, 0x9b, 0x5a, 0x5f, 0xee, 0x21, 0x63, 0xdd, 0x4b,
-            0xbc, 0x49, 0x95, 0x6d, 0xf4, 0xcb, 0x9a, 0x9a, 0x5e, 0xe4, 0x7d, 0x0f, 0x02, 0x22, 0xa9, 0x42,
-            0x46, 0x1a, 0x04, 0x87, 0x43, 0x72, 0x59, 0xa4, 0xd6, 0xeb, 0x69, 0x36, 0xde, 0xea, 0x53, 0x8c,
-            0x89, 0xd7, 0x22, 0xa6, 0xf7, 0xa8, 0x4c, 0x72, 0x6c, 0x80, 0x69, 0x01, 0xb2, 0xa7, 0xe8, 0x8b,
-            0x94, 0xaf, 0x0e, 0x47, 0x58, 0x1d, 0x0e, 0x5c, 0x7c, 0x33, 0x9f, 0x21, 0x17, 0x2c, 0x4f, 0x3d,
-            0x72, 0xff, 0xcf, 0x7a, 0x4f, 0x82, 0x5b, 0x85, 0x28, 0x70, 0xf4, 0x8c, 0x81, 0x41, 0xb8, 0x20,
-            0x5c, 0x3e, 0x02, 0x5e, 0x5a, 0x61, 0xbb, 0x2f, 0x64, 0xc5, 0x4e, 0x53, 0xe4, 0xca, 0xe4, 0xd9,
-            0x75, 0xaf, 0x15, 0x4d, 0xff, 0x01, 0xec, 0x13, 0x4a, 0x70, 0x00, 0x04, 0xf9, 0xfa, 0x00, 0x00,
-            0x99, 0x57, 0xc4, 0x96, 0x00, 0x02, 0xf7, 0x02, 0x80, 0x20, 0xdf, 0x01, 0x8d, 0x02, 0x00, 0x00,
-            0x4c, 0x41, 0xe6, 0xa1, 0x9b, 0xe3, 0x51, 0x40, 0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0x59, 0x5a
-        };
-
-        protected static byte[] OriginalIndexedBytes => Encoding.ASCII.GetBytes(OriginalIndexed);
-
-        protected static string OriginalIndexed { get; } = Original + Original + Original + Original + Original + Original + Original + Original + Original;
     }
 }

tests/SharpCompress.Test/Zip/ZipArchiveTests.cs

@@ -160,7 +160,7 @@ namespace SharpCompress.Test.Zip
         [Fact]
         public void Zip_Random_Write_Add()
         {
-            string jpg = Path.Combine(ORIGINAL_FILES_PATH, "jpg", "test.jpg");
+            string jpg = Path.Combine(ORIGINAL_FILES_PATH, "jpg","test.jpg");
             string scratchPath = Path.Combine(SCRATCH_FILES_PATH, "Zip.deflate.mod.zip");
             string unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.mod.zip");
             string modified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.mod2.zip");
@@ -297,7 +297,7 @@ namespace SharpCompress.Test.Zip
             {
                 archive.AddAllFromDirectory(SCRATCH_FILES_PATH);
                 archive.RemoveEntry(archive.Entries.Single(x => x.Key.EndsWith("jpg", StringComparison.OrdinalIgnoreCase)));
-                Assert.Null(archive.Entries.FirstOrDefault(x => x.Key.EndsWith("jpg")));
+                Assert.False(archive.Entries.Any(x => x.Key.EndsWith("jpg")));
             }
             Directory.Delete(SCRATCH_FILES_PATH, true);
         }
@@ -307,9 +307,9 @@ namespace SharpCompress.Test.Zip
         {
             ResetScratch();
             using (var reader = ZipArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.WinzipAES.zip"), new ReaderOptions()
-            {
-                Password = "test"
-            }))
+                                                                                                               {
+                                                                                                                   Password = "test"
+                                                                                                                }))
             {
                 foreach (var entry in reader.Entries.Where(x => !x.IsDirectory))
                 {

tests/SharpCompress.Test/Zip/ZipReaderTests.cs

@@ -14,7 +14,7 @@ namespace SharpCompress.Test.Zip
         {
             UseExtensionInsteadOfNameToVerify = true;
         }
-
+        
         [Fact]
         public void Issue_269_Double_Skip()
         {
@@ -41,13 +41,13 @@ namespace SharpCompress.Test.Zip
         [Fact]
         public void Zip_Zip64_Streamed_Read()
         {
-            Read("Zip.zip64.zip", CompressionType.Deflate);
+            Read("Zip.Zip64.zip", CompressionType.Deflate);
         }
 
         [Fact]
         public void Zip_ZipX_Streamed_Read()
         {
-            Read("Zip.zipx", CompressionType.LZMA);
+            Read("Zip.Zipx", CompressionType.LZMA);
         }
 
         [Fact]
@@ -141,8 +141,8 @@ namespace SharpCompress.Test.Zip
             ResetScratch();
             using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.bzip2.pkware.zip")))
             using (var reader = ZipReader.Open(stream, new ReaderOptions()
-            {
-                Password = "test"
+                                                       {
+                                                           Password = "test"
             }))
             {
                 while (reader.MoveToNextEntry())
@@ -218,11 +218,11 @@ namespace SharpCompress.Test.Zip
                                                 using (
                                                     Stream stream =
                                                         File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH,
-                                                            "Zip.lzma.WinzipAES.zip")))
+                                                            "Zip.lzma.winzipaes.zip")))
                                                 using (var reader = ZipReader.Open(stream, new ReaderOptions()
-                                                {
-                                                    Password = "test"
-                                                }))
+                                                                                           {
+                                                                                               Password = "test"
+                                                                                           }))
                                                 {
                                                     while (reader.MoveToNextEntry())
                                                     {
@@ -248,9 +248,9 @@ namespace SharpCompress.Test.Zip
             ResetScratch();
             using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.WinzipAES.zip")))
             using (var reader = ZipReader.Open(stream, new ReaderOptions()
-            {
-                Password = "test"
-            }))
+                                                       {
+                                                           Password = "test"
+                                                       }))
             {
                 while (reader.MoveToNextEntry())
                 {

tests/SharpCompress.Test/Zip/ZipWriterTests.cs

@@ -1,4 +1,9 @@
-using SharpCompress.Common;
+using System.IO;
+using SharpCompress.Common;
+using SharpCompress.Readers;
+using SharpCompress.Readers.Zip;
+using SharpCompress.Writers;
+using SharpCompress.Writers.Zip;
 using Xunit;
 
 namespace SharpCompress.Test.Zip
@@ -48,5 +53,41 @@ namespace SharpCompress.Test.Zip
         {
             Assert.Throws<InvalidFormatException>(() => Write(CompressionType.Rar, "Zip.ppmd.noEmptyDirs.zip", "Zip.ppmd.noEmptyDirs.zip"));
         }
+        
+        [Fact]
+        public void Zip_BZip2_PkwareEncryption_Write()
+        {
+            ResetScratch();
+            using (Stream stream = File.OpenWrite(Path.Combine(SCRATCH_FILES_PATH, "Zip.pkware.zip")))
+            {
+                using (var writer = new ZipWriter(stream, new ZipWriterOptions(CompressionType.BZip2)
+                                                          {
+                                                              Password = "test"
+                                                          }))
+                {
+                    writer.WriteAll(ORIGINAL_FILES_PATH, "*", SearchOption.AllDirectories);
+                }  
+            }
+            using (Stream stream = File.OpenRead(Path.Combine(SCRATCH_FILES_PATH, "Zip.pkware.zip")))
+            using (var reader = ZipReader.Open(stream, new ReaderOptions()
+                                                       {
+                                                           Password = "test"
+                                                       }))
+            {
+                while (reader.MoveToNextEntry())
+                {
+                    if (!reader.Entry.IsDirectory)
+                    {
+                        Assert.Equal(CompressionType.BZip2, reader.Entry.CompressionType);
+                        reader.WriteEntryToDirectory(SCRATCH_FILES_PATH, new ExtractionOptions()
+                                                                         {
+                                                                             ExtractFullPath = true,
+                                                                             Overwrite = true
+                                                                         });
+                    }
+                }
+            }
+            VerifyFiles();
+        }
     }
 }