public void ZOS_Create_DuplicateEntry()
{
string zipFileToCreate = "ZOS_Create_DuplicateEntry.zip";
string entryName = Path.GetRandomFileName();
using (var fs = File.Create(zipFileToCreate))
{
using (var output = new ZipOutputStream(fs))
{
output.PutNextEntry(entryName);
output.PutNextEntry(entryName);
}
}
}
public void Password_UnsetEncryptionAfterSetPassword_wi13909_ZOS()
{
// Verify that unsetting the Encryption property after
// setting a Password results in no encryption being used.
// This method tests ZipOutputStream.
string unusedPassword = TestUtilities.GenerateRandomPassword();
int numTotalEntries = _rnd.Next(46)+653;
string zipFileToCreate = "UnsetEncryption.zip";
using (FileStream fs = File.Create(zipFileToCreate))
{
using (var zos = new ZipOutputStream(fs))
{
zos.Password = unusedPassword;
zos.Encryption = EncryptionAlgorithm.None;
for (int i=0; i < numTotalEntries; i++)
{
if (_rnd.Next(7)==0)
{
string entryName = String.Format("{0:D5}/", i);
zos.PutNextEntry(entryName);
}
else
{
string entryName = String.Format("{0:D5}.txt", i);
zos.PutNextEntry(entryName);
if (_rnd.Next(12)==0)
{
var block = TestUtilities.GenerateRandomAsciiString() + " ";
string contentBuffer = String.Format("This is the content for entry {0}", i);
int n = _rnd.Next(6) + 2;
for (int j=0; j < n; j++)
contentBuffer += block;
byte[] buffer = System.Text.Encoding.ASCII.GetBytes(contentBuffer);
zos.Write(buffer, 0, buffer.Length);
}
}
}
}
}
BasicVerifyZip(zipFileToCreate);
}
public void ZOS_Create_EmptyEntries()
{
for (int i = 0; i < crypto.Length; i++)
{
for (int j = 0; j < compLevels.Length; j++)
{
string password = Path.GetRandomFileName();
for (int k = 0; k < 2; k++)
{
string zipFileToCreate = String.Format("ZOS_Create_EmptyEntries.Encryption.{0}.{1}.{2}.zip",
crypto[i].ToString(), compLevels[j].ToString(), k);
using (var fs = File.Create(zipFileToCreate))
{
using (var output = new ZipOutputStream(fs))
{
byte[] buffer;
output.Password = password;
output.Encryption = crypto[i];
output.CompressionLevel = compLevels[j];
output.PutNextEntry("entry1.txt");
if (k == 0)
{
buffer = Encoding.ASCII.GetBytes("This is the content for entry #1.");
output.Write(buffer, 0, buffer.Length);
}
output.PutNextEntry("entry2.txt"); // this will be zero length
output.PutNextEntry("entry3.txt");
if (k == 0)
{
buffer = Encoding.ASCII.GetBytes("This is the content for entry #3.");
output.Write(buffer, 0, buffer.Length);
}
output.PutNextEntry("entry4.txt"); // this will be zero length
output.PutNextEntry("entry5.txt"); // this will be zero length
}
}
BasicVerifyZip(zipFileToCreate, password);
Assert.AreEqual<int>(5, TestUtilities.CountEntries(zipFileToCreate),
"Trial ({0},{1}): The zip file created has the wrong number of entries.", i, j);
}
}
}
}
public void ZOS_Create_Encrypt_wi12815()
{
string zipFileToCreate =
"ZOS_Create_Encrypt_wi12815.zip";
var content = new byte[1789];
unchecked
{
byte b = 0;
for (var i = 0; i < content.Length; i++, b++)
{
content[i] = b;
}
}
var checkBuffer = new Action<String>(stage =>
{
byte b = 0;
TestContext.WriteLine("Checking buffer ({0})", stage);
for (var i = 0; i < content.Length; i++, b++)
{
Assert.IsTrue((content[i] == b),
"Buffer was modified.");
}
});
checkBuffer("before");
using (var fileStream = File.OpenWrite(zipFileToCreate))
{
using (var zipStream = new ZipOutputStream(fileStream, true))
{
zipStream.CompressionLevel = Alienlab.Zlib.CompressionLevel.None;
zipStream.Password = "******";
zipStream.Encryption = EncryptionAlgorithm.WinZipAes256;
zipStream.PutNextEntry("myentry.myext");
zipStream.Write(content, 0, content.Length);
}
}
checkBuffer("after");
}
private void _ZOS_z64Over65534Entries
(Zip64Option z64option,
EncryptionAlgorithm encryption,
Alienlab.Zlib.CompressionLevel compression)
{
TestContext.WriteLine("_ZOS_z64Over65534Entries hello: {0}",
DateTime.Now.ToString("G"));
int fileCount = _rnd.Next(14616) + 65536;
//int fileCount = _rnd.Next(146) + 5536;
TestContext.WriteLine("entries: {0}", fileCount);
var txrxLabel =
String.Format("ZOS #{0} 64({3}) E({1}) C({2})",
fileCount,
encryption.ToString(),
compression.ToString(),
z64option.ToString());
TestContext.WriteLine("label: {0}", txrxLabel);
string zipFileToCreate =
String.Format("ZOS.Zip64.over65534.{0}.{1}.{2}.zip",
z64option.ToString(), encryption.ToString(),
compression.ToString());
TestContext.WriteLine("zipFileToCreate: {0}", zipFileToCreate);
_txrx = TestUtilities.StartProgressMonitor(zipFileToCreate,
txrxLabel, "starting up...");
TestContext.WriteLine("generating {0} entries ", fileCount);
_txrx.Send("pb 0 max 3"); // 2 stages: Write, Count, Verify
_txrx.Send("pb 0 value 0");
string password = Path.GetRandomFileName();
string statusString = String.Format("status Encryption:{0} Compression:{1}",
encryption.ToString(),
compression.ToString());
_txrx.Send(statusString);
int dirCount = 0;
using (FileStream fs = File.Create(zipFileToCreate))
{
using (var output = new ZipOutputStream(fs))
{
_txrx.Send("test " + txrxLabel);
System.Threading.Thread.Sleep(400);
_txrx.Send("pb 1 max " + fileCount);
_txrx.Send("pb 1 value 0");
output.Password = password;
output.Encryption = encryption;
output.CompressionLevel = compression;
output.EnableZip64 = z64option;
for (int k = 0; k < fileCount; k++)
{
if (_rnd.Next(7) == 0)
{
// make it a directory
string entryName = String.Format("{0:D4}/", k);
output.PutNextEntry(entryName);
dirCount++;
}
else
{
string entryName = String.Format("{0:D4}.txt", k);
output.PutNextEntry(entryName);
// only a few entries are non-empty
if (_rnd.Next(18) == 0)
{
var block = TestUtilities.GenerateRandomAsciiString();
string content = String.Format("This is the content for entry #{0}.\n", k);
int n = _rnd.Next(4) + 1;
for (int j=0; j < n; j++)
content+= block;
byte[] buffer = Encoding.ASCII.GetBytes(content);
output.Write(buffer, 0, buffer.Length);
}
}
if (k % 1024 == 0)
_txrx.Send(String.Format("status saving ({0}/{1}) {2:N0}%",
k, fileCount,
((double)k) / (0.01 * fileCount)));
else if (k % 256 == 0)
_txrx.Send("pb 1 value " + k);
}
}
}
_txrx.Send("pb 1 max 1");
_txrx.Send("pb 1 value 1");
_txrx.Send("pb 0 step");
System.Threading.Thread.Sleep(400);
TestContext.WriteLine("Counting entries ... " + DateTime.Now.ToString("G"));
_txrx.Send("status Counting entries...");
Assert.AreEqual<int>
(fileCount - dirCount,
TestUtilities.CountEntries(zipFileToCreate),
"{0}: The zip file created has the wrong number of entries.",
zipFileToCreate);
_txrx.Send("pb 0 step");
System.Threading.Thread.Sleep(140);
// basic verify. The output is really large, so we pass emitOutput=false .
_txrx.Send("status Verifying...");
TestContext.WriteLine("Verifying ... " + DateTime.Now.ToString("G"));
_numExtracted = 0;
_numFilesToExtract = fileCount;
_txrx.Send("pb 1 max " + fileCount);
System.Threading.Thread.Sleep(200);
_txrx.Send("pb 1 value 0");
BasicVerifyZip(zipFileToCreate, password, false, Streams_ExtractProgress);
_txrx.Send("pb 0 step");
System.Threading.Thread.Sleep(800);
TestContext.WriteLine("Done ... " + DateTime.Now.ToString("G"));
}
public void ZOS_Create_Directories_Write()
{
for (int k = 0; k < 2; k++)
{
string zipFileToCreate = String.Format("ZOS_Create_Directories.{0}.zip", k);
using (var fs = File.Create(zipFileToCreate))
{
using (var output = new ZipOutputStream(fs))
{
byte[] buffer;
output.Encryption = EncryptionAlgorithm.None;
output.CompressionLevel = Alienlab.Zlib.CompressionLevel.BestCompression;
output.PutNextEntry("entry1/");
if (k == 0)
{
buffer = Encoding.ASCII.GetBytes("This is the content for entry #1.");
// this should fail
output.Write(buffer, 0, buffer.Length);
}
output.PutNextEntry("entry2/"); // this will be a directory
output.PutNextEntry("entry3.txt");
if (k == 0)
{
buffer = Encoding.ASCII.GetBytes("This is the content for entry #3.");
output.Write(buffer, 0, buffer.Length);
}
output.PutNextEntry("entry4.txt"); // this will be zero length
output.PutNextEntry("entry5.txt"); // this will be zero length
}
}
}
}
public void ZOS_Create_ZeroByteEntry_wi12964()
{
using (var zip = new Alienlab.Zip.ZipOutputStream(new MemoryStream()))
{
zip.PutNextEntry("EmptyFile.txt");
zip.Write(new byte[1], 0, 0);
}
}
public void ZOS_Create_WithComment_wi10339()
{
string zipFileToCreate = "ZOS_Create_WithComment_wi10339.zip";
using (var fs = File.Create(zipFileToCreate))
{
using (var output = new ZipOutputStream(fs))
{
output.CompressionLevel = Alienlab.Zlib.CompressionLevel.None;
output.Comment = "Cheeso is the man!";
string entryName = String.Format("entry{0:D4}.txt", _rnd.Next(10000));
output.PutNextEntry(entryName);
string content = "This is the content for the entry.";
byte[] buffer = Encoding.ASCII.GetBytes(content);
output.Write(buffer, 0, buffer.Length);
}
}
}
public void ZIS_ZOS_VaryCompression()
{
string testBin = TestUtilities.GetTestBinDir(CurrentDir);
string resourceDir = Path.Combine(testBin, "Resources");
var filesToAdd = Directory.GetFiles(resourceDir);
Func<int, int, bool> chooseCompression = (ix, cycle) => {
var name = Path.GetFileName(filesToAdd[ix]);
switch (cycle)
{
case 0:
return !(name.EndsWith(".zip") ||
name.EndsWith(".docx") ||
name.EndsWith(".xslx"));
case 1:
return ((ix%2)==0);
default:
return (ix == filesToAdd.Length - 1);
}
};
// Three cycles - three different ways to vary compression
for (int k=0; k < 3; k++)
{
string zipFileToCreate = String.Format("VaryCompression-{0}.zip", k);
TestContext.WriteLine("");
TestContext.WriteLine("Creating zip, cycle {0}", k);
using (var fileStream = File.OpenWrite(zipFileToCreate))
{
using (var zos = new ZipOutputStream(fileStream, true))
{
for (int i=0; i < filesToAdd.Length; i++)
{
var file = filesToAdd[i];
var shortName = Path.GetFileName(file);
bool compress = chooseCompression(i, k);
if (compress)
zos.CompressionLevel = Alienlab.Zlib.CompressionLevel.Default;
else
zos.CompressionLevel = Alienlab.Zlib.CompressionLevel.None;
zos.PutNextEntry(shortName);
using (var input = File.OpenRead(file))
{
CopyStream(input, zos);
}
}
}
}
TestContext.WriteLine("");
TestContext.WriteLine("Extracting cycle {0}", k);
string extractDir = "extract-" + k;
Directory.CreateDirectory(extractDir);
using (var raw = File.OpenRead(zipFileToCreate))
{
using (var input = new ZipInputStream(raw))
{
ZipEntry e;
while ((e = input.GetNextEntry()) != null)
{
TestContext.WriteLine("entry: {0}", e.FileName);
string outputPath = Path.Combine(extractDir, e.FileName);
if (e.IsDirectory)
{
// create the directory
Directory.CreateDirectory(outputPath);
}
else
{
// create the file
using (var output = File.Create(outputPath))
{
CopyStream(input,output);
}
}
}
}
}
string[] filesUnzipped = Directory.GetFiles(extractDir);
Assert.AreEqual<int>(filesToAdd.Length, filesUnzipped.Length,
"Incorrect number of files extracted.");
}
}
public void ZipOutputStream_Parallel()
{
int _sizeBase = 1024 * 1024;
int _sizeRange = 256 * 1024;
//int _sizeBase = 1024 * 256;
//int _sizeRange = 256 * 12;
var sw = new System.Diagnostics.Stopwatch();
byte[] buffer = new byte[0x8000];
int n = 0;
TimeSpan[] ts = new TimeSpan[2];
int nFiles = _rnd.Next(8) + 8;
//int nFiles = 2;
string[] filenames = new string[nFiles];
string dirToZip = Path.Combine(TopLevelDir, "dirToZip");
string channel = String.Format("ZOS_Parallel{0:000}", _rnd.Next(1000));
string txrxLabel = "ZipOutputStream Parallel";
_txrx = TestUtilities.StartProgressMonitor(channel, txrxLabel, "starting up...");
TestContext.WriteLine("Creating {0} fodder files...", nFiles);
Directory.CreateDirectory(dirToZip);
_txrx.Send(String.Format("pb 0 max {0}", nFiles));
_txrx.Send("pb 0 value 0");
sw.Start();
for (int x = 0; x < nFiles; x++)
{
string status = String.Format("status Creating file {0}/{1}", x + 1, nFiles);
_txrx.Send(status);
filenames[x] = Path.Combine(dirToZip, String.Format("file{0:000}.txt", x));
using (var output = File.Create(filenames[x]))
{
using (Stream input = new Alienlab.Zip.Tests.Utilities.RandomTextInputStream(_sizeBase + _rnd.Next(_sizeRange)))
{
while ((n = input.Read(buffer, 0, buffer.Length)) != 0)
{
output.Write(buffer, 0, n);
}
}
}
_txrx.Send("pb 0 step");
}
sw.Stop();
TestContext.WriteLine("file generation took {0}", sw.Elapsed);
_txrx.Send(String.Format("pb 0 max {0}", crypto.Length));
_txrx.Send("pb 0 value 0");
for (int i = 0; i < crypto.Length; i++)
{
//int c = i;
int c = (i + 2) % crypto.Length;
_txrx.Send(String.Format("pb 1 max {0}", compLevels.Length));
_txrx.Send("pb 1 value 0");
for (int j = 0; j < compLevels.Length; j++)
{
string password = Path.GetRandomFileName();
// I wanna do 2 cycles if there is compression, so I can compare MT
// vs 1T compression. The first cycle will ALWAYS use the threaded
// compression, the 2nd will NEVER use it. If
// CompressionLevel==None, then just do one cycle.
//
int kCycles = (compLevels[j] == Alienlab.Zlib.CompressionLevel.None)
? 1
: 2;
for (int k = 0; k < kCycles; k++)
{
// Also, I use Stopwatch to time the compression, and compare.
// In light of that, I wanna do one warmup, and then one timed
// trial (for t==0..2). But here again, if CompressionLevel==None, then I
// don't want to do a timing comparison, so I don't need 2 trials.
// Therefore, in that case, the "warmup" is the only trial I want to do.
// So when k==1 and Compression==None, do no cycles at all.
//
int tCycles = (compLevels[j] == Alienlab.Zlib.CompressionLevel.None)
? ((k == 0) ? 1 : 0)
: 2;
if (k == 0)
{
_txrx.Send(String.Format("pb 2 max {0}", kCycles * tCycles));
_txrx.Send("pb 2 value 0");
}
for (int t = 0; t < tCycles; t++)
{
TestContext.WriteLine(new String('-', 72));
string zipFileToCreate = String.Format("ZipOutputStream_Parallel.E-{0}.C-{1}.{2}.{3}timed.zip",
crypto[c].ToString(), compLevels[j].ToString(),
(compLevels[j] == Alienlab.Zlib.CompressionLevel.None)
? "NA"
: (k == 0) ? "1T" : "MT",
(t == 0) ? "not-" : "");
TestContext.WriteLine("Trial {0}.{1}.{2}.{3}", i, j, k, t);
TestContext.WriteLine("Create zip file {0}", zipFileToCreate);
_txrx.Send("status " + zipFileToCreate);
sw.Reset();
sw.Start();
using (var output = new ZipOutputStream(zipFileToCreate))
{
if (k == 0)
output.ParallelDeflateThreshold = -1L; // never
else
output.ParallelDeflateThreshold = 0L; // always
output.Password = password;
output.Encryption = crypto[c]; // maybe "None"
output.CompressionLevel = compLevels[j];
_txrx.Send(String.Format("pb 3 max {0}", nFiles));
_txrx.Send("pb 3 value 0");
for (int x = 0; x < nFiles; x++)
{
output.PutNextEntry(Path.GetFileName(filenames[x]));
using (var input = File.OpenRead(filenames[x]))
{
while ((n = input.Read(buffer, 0, buffer.Length)) > 0)
{
output.Write(buffer, 0, n);
}
}
_txrx.Send("pb 3 step");
}
}
sw.Stop();
ts[k] = sw.Elapsed;
TestContext.WriteLine("compression took {0}", ts[k]);
//if (t==0)
BasicVerifyZip(zipFileToCreate, password);
Assert.AreEqual<int>(nFiles, TestUtilities.CountEntries(zipFileToCreate),
"Trial ({0}.{1}.{2}.{3}): The zip file created has the wrong number of entries.", i, j, k, t);
_txrx.Send("pb 2 step");
}
}
#if NOT_DEBUGGING
// parallel is not always faster!
if (_sizeBase > 256 * 1024 &&
compLevels[j] != Alienlab.Zlib.CompressionLevel.None &&
compLevels[j] != Alienlab.Zlib.CompressionLevel.BestSpeed &&
crypto[c] != EncryptionAlgorithm.WinZipAes256 &&
crypto[c] != EncryptionAlgorithm.WinZipAes128 )
Assert.IsTrue(ts[0]>ts[1], "Whoops! Cycle {0}.{1} (crypto({4}) Comp({5})): Parallel deflate is slower ({2}<{3})",
i, j, ts[0], ts[1],
crypto[c],
compLevels[j]);
#endif
_txrx.Send("pb 1 step");
}
_txrx.Send("pb 0 step");
}
_txrx.Send("stop");
}
public void Unicode_Create_ZOS_wi12634()
{
TestContext.WriteLine("==Unicode_Create_ZOS_wi12634()=");
var filesToZip = _CreateUnicodeFiles();
byte[] buffer = new byte[2048];
int n;
// using those files create a zipfile twice. First cycle uses Unicode,
// 2nd cycle does not.
for (int j = 0; j < 2; j++)
{
// select the name of the zip file
var bpath = String.Format("wi12634-{0}.zip", j);
string zipFileToCreate = Path.Combine(TopLevelDir, bpath);
TestContext.WriteLine("========");
TestContext.WriteLine("Trial {0}", j);
Assert.IsFalse(File.Exists(zipFileToCreate),
"The zip file '{0}' already exists.",
zipFileToCreate);
TestContext.WriteLine("file {0}", zipFileToCreate);
int excCount = 0;
// create using ZOS
using (var ofs = File.Open(zipFileToCreate, FileMode.Create, FileAccess.ReadWrite))
{
using (var zos = new ZipOutputStream(ofs))
{
#pragma warning disable 618
if (j == 0)
zos.ProvisionalAlternateEncoding = System.Text.Encoding.UTF8;
#pragma warning restore 618
try
{
foreach (var fileToZip in filesToZip)
{
var ename = Path.GetFileName(fileToZip);
TestContext.WriteLine("adding entry '{0}'", ename);
zos.PutNextEntry(ename); // with no path
using (var ifs = File.OpenRead(fileToZip))
{
while ((n = ifs.Read(buffer, 0, buffer.Length)) > 0)
{
zos.Write(buffer, 0, n);
}
}
}
}
catch (System.Exception exc1)
{
TestContext.WriteLine("Exception #{0}", excCount);
TestContext.WriteLine("{0}", exc1.ToString());
excCount++;
}
}
}
Assert.IsTrue(excCount==0,
"Exceptions occurred during zip creation.");
// Verify the number of files in the zip
Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), filesToZip.Count,
"Incorrect number of entries in the zip file.");
_CheckUnicodeZip(zipFileToCreate, j);
TestContext.WriteLine("Trial {0} file checks ok", j);
}
}