public void StreamClosedWhenOwner()
{
var ms = new MemoryStream();
MakeZipFile(ms, false, "StreamClosedWhenOwner", 1, 10, "test");
ms.Seek(0, SeekOrigin.Begin);
var zipData = ms.ToArray();
// Stream should be closed when leaveOpen is unspecified
{
var inMemoryZip = new TrackedMemoryStream(zipData);
Assert.IsFalse(inMemoryZip.IsClosed, "Input stream should NOT be closed");
using (var zipFile = new ZipFile(inMemoryZip))
{
Assert.IsTrue(zipFile.IsStreamOwner, "Should be stream owner by default");
}
Assert.IsTrue(inMemoryZip.IsClosed, "Input stream should be closed by default");
}
// Stream should be closed when leaveOpen is false
{
var inMemoryZip = new TrackedMemoryStream(zipData);
Assert.IsFalse(inMemoryZip.IsClosed, "Input stream should NOT be closed");
using (var zipFile = new ZipFile(inMemoryZip, false))
{
Assert.IsTrue(zipFile.IsStreamOwner, "Should be stream owner when leaveOpen is false");
}
Assert.IsTrue(inMemoryZip.IsClosed, "Input stream should be closed when leaveOpen is false");
}
}
public void BaseClosedAfterFailure()
{
var ms = new TrackedMemoryStream(new byte[32]);
Assert.IsFalse(ms.IsClosed, "Underlying stream should NOT be closed initially");
bool blewUp = false;
try
{
using (ZipOutputStream stream = new ZipOutputStream(ms))
{
Assert.IsTrue(stream.IsStreamOwner, "Should be stream owner by default");
try
{
stream.PutNextEntry(new ZipEntry("Tiny"));
stream.Write(new byte[32], 0, 32);
}
finally
{
Assert.IsFalse(ms.IsClosed, "Stream should still not be closed.");
stream.Close();
Assert.Fail("Exception not thrown");
}
}
}
catch
{
blewUp = true;
}
Assert.IsTrue(blewUp, "Should have failed to write to stream");
Assert.IsTrue(ms.IsClosed, "Underlying stream should be closed");
}
public void OutputStreamOwnership()
{
TrackedMemoryStream memStream = new TrackedMemoryStream();
GZipOutputStream s = new GZipOutputStream(memStream);
Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
s.Close();
Assert.IsTrue(memStream.IsClosed, "Should be closed after parent owner close");
Assert.IsTrue(memStream.IsDisposed, "Should be disposed after parent owner close");
memStream = new TrackedMemoryStream();
s = new GZipOutputStream(memStream);
Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
s.IsStreamOwner = false;
s.Close();
Assert.IsFalse(memStream.IsClosed, "Should not be closed after parent owner close");
Assert.IsFalse(memStream.IsDisposed, "Should not be disposed after parent owner close");
}
public void StreamClosedOnError()
{
// test paths
string tempFilePath = GetTempFilePath();
Assert.IsNotNull(tempFilePath, "No permission to execute this test?");
var tempFolderPath = Path.Combine(tempFilePath, Path.GetRandomFileName());
Assert.That(Directory.Exists(tempFolderPath), Is.False, "Temp folder path should not exist");
// memory that isn't a valid zip
var ms = new TrackedMemoryStream(new byte[32]);
Assert.IsFalse(ms.IsClosed, "Underlying stream should NOT be closed initially");
// Try to extract
var fastZip = new FastZip();
fastZip.CreateEmptyDirectories = true;
Assert.Throws <ZipException>(() => fastZip.ExtractZip(ms, tempFolderPath, FastZip.Overwrite.Always, null, "a", "b", false, true), "Should throw when extracting an invalid file");
Assert.IsTrue(ms.IsClosed, "inputStream stream should be closed when isStreamOwner is true");
// test folder should not have been created on error
Assert.That(Directory.Exists(tempFolderPath), Is.False, "Temp folder path should still not exist");
}
public void CreateZipShouldLeaveOutputStreamOpenIfRequested(bool leaveOpen)
{
const string tempFileName = "a(2).dat";
using (var tempFolder = new Utils.TempDir())
{
// Create test input file
string addFile = Path.Combine(tempFolder.Fullpath, tempFileName);
MakeTempFile(addFile, 16);
// Create the zip with fast zip
var target = new TrackedMemoryStream();
var fastZip = new FastZip();
fastZip.CreateZip(target, tempFolder.Fullpath, false, @"a\(2\)\.dat", null, leaveOpen: leaveOpen);
// Check that the output stream was disposed (or not) as expected
Assert.That(target.IsDisposed, Is.Not.EqualTo(leaveOpen), "IsDisposed should be the opposite of leaveOpen");
// Check that the file contents are correct in both cases
var archive = new MemoryStream(target.ToArray());
using (ZipFile zf = new ZipFile(archive))
{
Assert.AreEqual(1, zf.Count);
ZipEntry entry = zf[0];
Assert.AreEqual(tempFileName, entry.Name);
Assert.AreEqual(16, entry.Size);
Assert.IsTrue(zf.TestArchive(true));
}
}
}
public void DoubleClose()
{
var memStream = new TrackedMemoryStream();
var s = new GZipOutputStream(memStream);
s.Finish();
#if NET451
s.Close();
#elif NETCOREAPP1_0
s.Dispose();
#endif
#if NET451
s.Close();
#elif NETCOREAPP1_0
s.Dispose();
#endif
memStream = new TrackedMemoryStream();
using (GZipOutputStream no2 = new GZipOutputStream(memStream)) {
#if NET451
s.Close();
#elif NETCOREAPP1_0
s.Dispose();
#endif
}
}
private byte[] MakeLocalHeader(string asciiName, short versionToExtract, short flags, short method,
int dostime, int crc, int compressedSize, int size)
{
using (TrackedMemoryStream ms = new TrackedMemoryStream())
{
ms.WriteByte((byte)'P');
ms.WriteByte((byte)'K');
ms.WriteByte(3);
ms.WriteByte(4);
ms.WriteLEShort(versionToExtract);
ms.WriteLEShort(flags);
ms.WriteLEShort(method);
ms.WriteLEInt(dostime);
ms.WriteLEInt(crc);
ms.WriteLEInt(compressedSize);
ms.WriteLEInt(size);
byte[] rawName = Encoding.ASCII.GetBytes(asciiName);
ms.WriteLEShort((short)rawName.Length);
ms.WriteLEShort(0);
ms.Write(rawName, 0, rawName.Length);
return(ms.ToArray());
}
}
public void InflatorStreamOwnership()
{
var memStream = new TrackedMemoryStream();
var s = new InflaterInputStream(memStream);
Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
#if NET451
s.Close();
#elif NETCOREAPP1_0
s.Dispose();
#endif
Assert.IsTrue(memStream.IsClosed, "Should be closed after parent owner close");
Assert.IsTrue(memStream.IsDisposed, "Should be disposed after parent owner close");
memStream = new TrackedMemoryStream();
s = new InflaterInputStream(memStream);
Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
s.IsStreamOwner = false;
#if NET451
s.Close();
#elif NETCOREAPP1_0
s.Dispose();
#endif
Assert.IsFalse(memStream.IsClosed, "Should not be closed after parent owner close");
Assert.IsFalse(memStream.IsDisposed, "Should not be disposed after parent owner close");
}
public void CreateZipShouldLeaveOutputStreamOpenIfRequested(bool leaveOpen)
{
const string tempFileName = "a(2).dat";
using var tempFolder = Utils.GetTempDir();
// Create test input file
tempFolder.CreateDummyFile(tempFileName, size: 16);
// Create the zip with fast zip
var target = new TrackedMemoryStream();
var fastZip = new FastZip();
fastZip.CreateZip(target, tempFolder, recurse: false, @"a\(2\)\.dat", directoryFilter: null, leaveOpen);
// Check that the output stream was disposed (or not) as expected
Assert.That(target.IsDisposed, Is.Not.EqualTo(leaveOpen), "IsDisposed should be the opposite of leaveOpen");
// Check that the file contents are correct in both cases
var archive = new MemoryStream(target.ToArray());
using var zf = new ZipFile(archive);
Assert.AreEqual(expected: 1, zf.Count);
var entry = zf[0];
Assert.AreEqual(tempFileName, entry.Name);
Assert.AreEqual(expected: 16, entry.Size);
Assert.IsTrue(zf.TestArchive(testData: true));
}
/// <summary>
/// Builds a pooled memory stream.
/// </summary>
/// <param name="capacity">The capacity of the backing stream.</param>
public PooledMemoryStream(int capacity)
{
_trackedMemoryStream = new TrackedMemoryStream(capacity)
{
Parent = this
};
}
public void InputStreamOwnership()
{
var memStream = new TrackedMemoryStream();
var s = new TarInputStream(memStream, null);
Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
s.Close();
Assert.IsTrue(memStream.IsClosed, "Should be closed after parent owner close");
Assert.IsTrue(memStream.IsDisposed, "Should be disposed after parent owner close");
memStream = new TrackedMemoryStream();
s = new TarInputStream(memStream, null);
Assert.IsFalse(memStream.IsClosed, "Shouldnt be closed initially");
Assert.IsFalse(memStream.IsDisposed, "Shouldnt be disposed initially");
s.IsStreamOwner = false;
s.Close();
Assert.IsFalse(memStream.IsClosed, "Should not be closed after parent owner close");
Assert.IsFalse(memStream.IsDisposed, "Should not be disposed after parent owner close");
}
public void StreamNotClosedWhenNotOwner()
{
var ms = new TrackedMemoryStream();
MakeZipFile(ms, false, "StreamNotClosedWhenNotOwner", 1, 10, "test");
ms.Seek(0, SeekOrigin.Begin);
Assert.IsFalse(ms.IsClosed, "Input stream should NOT be closed");
// Stream should not be closed when leaveOpen is true
{
using (var zipFile = new ZipFile(ms, true))
{
Assert.IsFalse(zipFile.IsStreamOwner, "Should NOT be stream owner when leaveOpen is true");
}
Assert.IsFalse(ms.IsClosed, "Input stream should NOT be closed when leaveOpen is true");
}
ms.Seek(0, SeekOrigin.Begin);
// Stream should not be closed when IsStreamOwner is set to false after opening
{
using (var zipFile = new ZipFile(ms, false))
{
Assert.IsTrue(zipFile.IsStreamOwner, "Should be stream owner when leaveOpen is false");
zipFile.IsStreamOwner = false;
Assert.IsFalse(zipFile.IsStreamOwner, "Should be able to set IsStreamOwner to false");
}
Assert.IsFalse(ms.IsClosed, "Input stream should NOT be closed when IsStreamOwner is false");
}
}
/// <summary>
/// Builds a pooled memory stream.
/// </summary>
/// <param name="capacity">The capacity of the backing stream.</param>
public PooledMemoryStream(int capacity)
{
_trackedMemoryStream = new TrackedMemoryStream(capacity)
{
Parent = this
};
OnValidateObject += (ctx) =>
{
if (ctx.Direction == PooledObjectDirection.Outbound)
{
// We validate only inbound objects, because when they are in the pool they
// cannot change their state.
return(true);
}
if (!_trackedMemoryStream.CanRead || !_trackedMemoryStream.CanWrite || !_trackedMemoryStream.CanSeek)
{
if (Log.IsWarnEnabled())
{
Log.Warn("[ObjectPool] Memory stream has already been disposed");
}
return(false);
}
var memoryStreamPool = PooledObjectInfo.Handle as IMemoryStreamPool;
if (_trackedMemoryStream.Capacity < memoryStreamPool.MinimumMemoryStreamCapacity)
{
if (Log.IsWarnEnabled())
{
Log.Warn($"[ObjectPool] Memory stream capacity is {_trackedMemoryStream.Capacity}, while minimum required capacity is {memoryStreamPool.MinimumMemoryStreamCapacity}");
}
return(false);
}
if (_trackedMemoryStream.Capacity > memoryStreamPool.MaximumMemoryStreamCapacity)
{
if (Log.IsWarnEnabled())
{
Log.Warn($"[ObjectPool] Memory stream capacity is {_trackedMemoryStream.Capacity}, while maximum allowed capacity is {memoryStreamPool.MaximumMemoryStreamCapacity}");
}
return(false);
}
return(true); // Object is valid.
};
OnResetState += () =>
{
_trackedMemoryStream.Position = 0L;
_trackedMemoryStream.SetLength(0L);
};
OnReleaseResources += () =>
{
_trackedMemoryStream.Parent = null;
_trackedMemoryStream.Dispose();
};
}
public void WriteAfterClose()
{
var memStream = new TrackedMemoryStream();
var s = new GZipOutputStream(memStream);
s.Close();
Assert.Throws <InvalidOperationException>(() => s.WriteByte(value: 7), "Write should fail");
}
public void DoubleFooter()
{
var memStream = new TrackedMemoryStream();
var s = new GZipOutputStream(memStream);
s.Finish();
Int64 length = memStream.Length;
s.Close();
Assert.AreEqual(length, memStream.ToArray().Length);
}
public void BaseNotClosedWhenNotOwner()
{
var ms = new TrackedMemoryStream();
Assert.IsFalse(ms.IsClosed, "Underlying stream should NOT be closed");
using (ZipOutputStream stream = new ZipOutputStream(ms)) {
Assert.IsTrue(stream.IsStreamOwner, "Should be stream owner by default");
stream.IsStreamOwner = false;
}
Assert.IsFalse(ms.IsClosed, "Underlying stream should still NOT be closed");
}
public void WriteAfterClose()
{
var memStream = new TrackedMemoryStream();
var s = new GZipOutputStream(memStream);
s.Close();
try {
s.WriteByte(7);
Assert.Fail("Write should fail");
} catch {
}
}
public void DoubleClose()
{
var memStream = new TrackedMemoryStream();
var s = new GZipOutputStream(memStream);
s.Finish();
s.Close();
s.Close();
memStream = new TrackedMemoryStream();
using (GZipOutputStream no2 = new GZipOutputStream(memStream)) {
s.Close();
}
}
public void DoubleFooter()
{
var memStream = new TrackedMemoryStream();
var s = new GZipOutputStream(memStream);
s.Finish();
Int64 length = memStream.Length;
#if NET451
s.Close();
#elif NETCOREAPP1_0
s.Dispose();
#endif
Assert.AreEqual(length, memStream.ToArray().Length);
}
public void WriteAfterFinish()
{
TrackedMemoryStream memStream = new TrackedMemoryStream();
GZipOutputStream s = new GZipOutputStream(memStream);
s.Finish();
try
{
s.WriteByte(7);
Assert.Fail("Write should fail");
}
catch
{
}
}
private static TrackedMemoryStream CreateFastZipTestArchiveWithAnEntry(FastZip fastZip, Action <FileInfo> alterFile = null)
{
var target = new TrackedMemoryStream();
using (var tempFolder = new Utils.TempDir())
{
// Create test input file
var addFile = Path.Combine(tempFolder.Fullpath, SingleEntryFileName);
MakeTempFile(addFile, 16);
var fi = new FileInfo(addFile);
alterFile?.Invoke(fi);
fastZip.CreateZip(target, tempFolder.Fullpath, false, SingleEntryFileName, null, leaveOpen: true);
}
return(target);
}
public void WriteAfterClose()
{
var memStream = new TrackedMemoryStream();
var s = new GZipOutputStream(memStream);
#if NET451
s.Close();
#elif NETCOREAPP1_0
s.Dispose();
#endif
try
{
s.WriteByte(7);
Assert.Fail("Write should fail");
} catch {
}
}
public void StreamNotClosedOnError()
{
var ms = new TrackedMemoryStream(new byte[32]);
Assert.IsFalse(ms.IsClosed, "Underlying stream should NOT be closed initially");
bool blewUp = false;
try
{
using (var zipFile = new ZipFile(ms, true))
{
Assert.Fail("Exception not thrown");
}
}
catch
{
blewUp = true;
}
Assert.IsTrue(blewUp, "Should have failed to load the file");
Assert.IsFalse(ms.IsClosed, "Underlying stream should NOT be closed");
}
