public void UpdateZip_AddFile_ExistingFile_Error() { // select the name of the zip file string zipFileToCreate = Path.Combine(TopLevelDir, "UpdateZip_AddFile_ExistingFile_Error.zip"); // create the subdirectory string subdir = Path.Combine(TopLevelDir, "A"); Directory.CreateDirectory(subdir); // create the files int fileCount = _rnd.Next(3) + 4; string filename = null; int entriesAdded = 0; for (int j = 0; j < fileCount; j++) { filename = Path.Combine(subdir, String.Format("file{0:D3}.txt", j)); TestUtilities.CreateAndFillFileText(filename, _rnd.Next(34000) + 5000); entriesAdded++; } // Add the files to the zip, save the zip Directory.SetCurrentDirectory(TopLevelDir); using (ZipFile zip = new ZipFile()) { String[] filenames = Directory.GetFiles("A"); foreach (String f in filenames) zip.AddFile(f, ""); zip.Comment = "UpdateTests::UpdateZip_AddFile_ExistingFile_Error(): This archive will be updated."; zip.Save(zipFileToCreate); } // create and file a new file with text data int FileToUpdate = _rnd.Next(fileCount); filename = String.Format("file{0:D3}.txt", FileToUpdate); string repeatedLine = String.Format("**UPDATED** This file ({0}) was updated at {1}.", filename, System.DateTime.Now.ToString("G")); TestUtilities.CreateAndFillFileText(filename, repeatedLine, _rnd.Next(21567) + 23872); // Try to again add that file in the zip archive. This // should fail. using (ZipFile z = ZipFile.Read(zipFileToCreate)) { // Try Adding a file again. THIS SHOULD THROW. ZipEntry e = z.AddFile(filename, ""); z.Comment = "UpdateTests::UpdateZip_AddFile_ExistingFile_Error(): This archive has been updated."; z.Save(); } }
public void Password_Extract_WrongPassword() { string ZipFileToCreate = Path.Combine(TopLevelDir, "MultipleEntriesDifferentPasswords.zip"); Assert.IsFalse(File.Exists(ZipFileToCreate), "The temporary zip file '{0}' already exists.", ZipFileToCreate); string SourceDir = CurrentDir; for (int i = 0; i < 3; i++) SourceDir = Path.GetDirectoryName(SourceDir); Directory.SetCurrentDirectory(TopLevelDir); string[] filenames = { Path.Combine(SourceDir, "Tools\\Zipit\\bin\\Debug\\Zipit.exe"), Path.Combine(SourceDir, "Zip\\bin\\Debug\\Ionic.Zip.xml"), }; string[] passwords = { "12345678", "0987654321", }; int j = 0; using (ZipFile zip = new ZipFile(ZipFileToCreate)) { for (j = 0; j < filenames.Length; j++) { zip.Password = passwords[j]; zip.AddFile(filenames[j], ""); } zip.Save(); } // now try to extract using (ZipFile zip = new ZipFile(ZipFileToCreate)) { for (j = 0; j < filenames.Length; j++) zip[Path.GetFileName(filenames[j])].ExtractWithPassword("unpack", ExtractExistingFileAction.OverwriteSilently, "WrongPassword"); } }
public void Password_BasicAddAndExtract() { int i; string[] Passwords = { null, "Password!", TestUtilities.GenerateRandomPassword(), "A" }; Alienlab.Zlib.CompressionLevel[] compressionLevelOptions = { Alienlab.Zlib.CompressionLevel.None, Alienlab.Zlib.CompressionLevel.BestSpeed, Alienlab.Zlib.CompressionLevel.Default, Alienlab.Zlib.CompressionLevel.BestCompression, }; for (int k = 0; k < compressionLevelOptions.Length; k++) { for (int j = 0; j < Passwords.Length; j++) { TestContext.WriteLine("\n\n===================\nTrial ({0}) pw({1})", j, Passwords[j]); string ZipFileToCreate = Path.Combine(TopLevelDir, String.Format("Password_BasicAddAndExtract-{0}-{1}.zip", k, j)); Assert.IsFalse(File.Exists(ZipFileToCreate), "The temporary zip file '{0}' already exists.", ZipFileToCreate); Directory.SetCurrentDirectory(TopLevelDir); string DirToZip = String.Format("zipthis-{0}-{1}", k, j); Directory.CreateDirectory(DirToZip); TestContext.WriteLine("\n---------------------creating files and computing checksums..."); int NumFilesToCreate = _rnd.Next(10) + 10; string[] filenames = new string[NumFilesToCreate]; var checksums = new Dictionary<string, string>(); for (i = 0; i < NumFilesToCreate; i++) { filenames[i] = Path.Combine(DirToZip, String.Format("file{0:D3}.txt", i)); int sz = _rnd.Next(22000) + 3000; //int sz = 1000; var repeatedLine = String.Format("Line to Repeat... {0} {1} {2} filename: {3}", i, k, j, filenames[i]); TestUtilities.CreateAndFillFileText(filenames[i], repeatedLine, sz); string key = Path.GetFileName(filenames[i]); checksums.Add(key, TestUtilities.GetCheckSumString(filenames[i])); TestContext.WriteLine(" chk[{0}]={1}", key, checksums[key]); } TestContext.WriteLine("\n---------------------adding files to the archive..."); var sw = new StringWriter(); using (ZipFile zip = new ZipFile(ZipFileToCreate, sw)) { zip.CompressionLevel = compressionLevelOptions[k]; zip.Password = Passwords[j]; zip.AddDirectory(Path.GetFileName(DirToZip)); zip.Save(); } TestContext.WriteLine(sw.ToString()); Assert.AreEqual<int>(TestUtilities.CountEntries(ZipFileToCreate), NumFilesToCreate, "The Zip file has an unexpected number of entries."); TestContext.WriteLine("\n---------------------verifying checksums..."); using (ZipFile zip = ZipFile.Read(ZipFileToCreate)) { foreach (ZipEntry e in zip) TestContext.WriteLine("found entry: {0}", e.FileName); var extractDir = String.Format("extract-{0}-{1}", k, j); TestContext.WriteLine(" Extract with pw({0})", Passwords[j]); foreach (ZipEntry e in zip) { e.ExtractWithPassword(extractDir, ExtractExistingFileAction.OverwriteSilently, Passwords[j]); if (!e.IsDirectory) { byte[] c2 = TestUtilities.ComputeChecksum(Path.Combine(extractDir, e.FileName)); Assert.AreEqual<string>(checksums[e.FileName], TestUtilities.CheckSumToString(c2), "The checksum of the extracted file is incorrect."); } } } TestContext.WriteLine("\n"); } } }
public void Progress_ReadFile() { Directory.SetCurrentDirectory(TopLevelDir); string zipFileToCreate = Path.Combine(TopLevelDir, "Progress_ReadFile.zip"); string dirToZip = Path.GetFileNameWithoutExtension(Path.GetRandomFileName()); var files = TestUtilities.GenerateFilesFlat(dirToZip); using (ZipFile zip = new ZipFile()) { zip.AddFiles(files); zip.Save(zipFileToCreate); } int count = TestUtilities.CountEntries(zipFileToCreate); Assert.IsTrue(count>0); var options = new ReadOptions { StatusMessageWriter = new StringWriter(), ReadProgress = ReadProgress1 }; using (ZipFile zip = ZipFile.Read(zipFileToCreate, options)) { // this should be fine zip.RemoveEntry(zip[1]); zip.Save(); } TestContext.WriteLine(options.StatusMessageWriter.ToString()); Assert.AreEqual<Int32>(count, TestUtilities.CountEntries(zipFileToCreate)+1); }
public void Password_UnsetEncryptionAfterSetPassword_wi13909_ZF() { // Verify that unsetting the Encryption property after // setting a Password results in no encryption being used. // This method tests ZipFile. string unusedPassword = TestUtilities.GenerateRandomPassword(); int numTotalEntries = _rnd.Next(46)+653; string zipFileToCreate = "UnsetEncryption.zip"; using (var zip = new ZipFile()) { zip.Password = unusedPassword; zip.Encryption = EncryptionAlgorithm.None; for (int i=0; i < numTotalEntries; i++) { if (_rnd.Next(7)==0) { string entryName = String.Format("{0:D5}", i); zip.AddDirectoryByName(entryName); } else { string entryName = String.Format("{0:D5}.txt", i); 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); zip.AddEntry(entryName, contentBuffer); } else zip.AddEntry(entryName, Stream.Null); } } zip.Save(zipFileToCreate); } BasicVerifyZip(zipFileToCreate); }
public void _Internal_Streams_ZipInput_Encryption(int fodderOption, int fileReadOption) { byte[] buffer = new byte[2048]; int n; int[] fileCounts = { 1, 2, _rnd.Next(8) + 6, _rnd.Next(18) + 16, _rnd.Next(48) + 56 }; for (int m = 0; m < fileCounts.Length; m++) { string password = TestUtilities.GenerateRandomPassword(); string dirToZip = String.Format("trial{0:D2}", m); if (!Directory.Exists(dirToZip)) Directory.CreateDirectory(dirToZip); int fileCount = fileCounts[m]; TestContext.WriteLine("====="); TestContext.WriteLine("Trial {0} filecount={1}", m, fileCount); var files = (new Func<string[]>( () => { if (fodderOption == 0) { // zero length files var a = new string[fileCount]; for (int i = 0; i < fileCount; i++) a[i] = CreateZeroLengthFile(i, dirToZip); return a; } if (fodderOption == 1) return TestUtilities.GenerateFilesFlat(dirToZip, fileCount, 100, 72000); // mixed = some zero and some not var b = new string[fileCount]; for (int i = 0; i < fileCount; i++) { if (_rnd.Next(3) == 0) b[i] = CreateZeroLengthFile(i, dirToZip); else { b[i] = Path.Combine(dirToZip, String.Format("nonzero{0:D4}.txt", i)); TestUtilities.CreateAndFillFileText(b[i], _rnd.Next(60000) + 100); } } return b; }))(); for (int i = 0; i < crypto.Length; i++) { EncryptionAlgorithm c = crypto[i]; string zipFileToCreate = Path.Combine(TopLevelDir, String.Format("ZIS_Crypto.{0}.count.{1:D2}.{2}.zip", c.ToString(), fileCounts[m], fodderOption)); // Create the zip archive using (var zip = new ZipFile()) { zip.Password = password; zip.Encryption = c; if (fodderOption > 2) { zip.AddDirectoryByName("subdir"); zip.AddDirectory(dirToZip, "subdir"); } else zip.AddDirectory(dirToZip); zip.Save(zipFileToCreate); } // Verify the number of files in the zip Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), files.Length, "Incorrect number of entries in the zip file."); // extract the files string extractDir = String.Format("extract{0:D2}.{1:D2}", m, i); TestContext.WriteLine("Extract to: {0}", extractDir); Directory.CreateDirectory(extractDir); var input = (new Func<ZipInputStream>( () => { if (fileReadOption == 0) { var raw = File.OpenRead(zipFileToCreate); return new ZipInputStream(raw); } return new ZipInputStream(zipFileToCreate); }))(); using (input) { // set password if necessary if (crypto[i] != EncryptionAlgorithm.None) input.Password = password; 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 { // emit the file using (var output = File.Create(outputPath)) { while ((n = input.Read(buffer, 0, buffer.Length)) > 0) { output.Write(buffer, 0, n); } } } } } string[] filesUnzipped = (fodderOption > 2) ? Directory.GetFiles(Path.Combine(extractDir, "subdir")) : Directory.GetFiles(extractDir); // Verify the number of files extracted Assert.AreEqual<int>(files.Length, filesUnzipped.Length, "Incorrect number of files extracted. ({0}!={1})", files.Length, filesUnzipped.Length); } } }
private void _Internal_AddEntry_WriteDelegate(string[] files, EncryptionAlgorithm crypto, bool seekable, int cycle, string format, int ignored) { int bufferSize = 2048; byte[] buffer = new byte[bufferSize]; int n; for (int k = 0; k < compLevels.Length; k++) { string zipFileToCreate = Path.Combine(TopLevelDir, String.Format(format, compLevels[k].ToString())); string password = TestUtilities.GenerateRandomPassword(); using (var zip = new ZipFile()) { TestContext.WriteLine("================================="); TestContext.WriteLine("Creating {0}...", Path.GetFileName(zipFileToCreate)); TestContext.WriteLine("Encryption({0}) Compression({1}) pw({2})", crypto.ToString(), compLevels[k].ToString(), password); zip.Password = password; zip.Encryption = crypto; zip.CompressionLevel = compLevels[k]; foreach (var file in files) { zip.AddEntry(file, (name, output) => { using (var input = File.OpenRead(name)) { while ((n = input.Read(buffer, 0, buffer.Length)) != 0) { output.Write(buffer, 0, n); } } }); } if (!seekable) { // conditionally use a non-seekable output stream using (var raw = File.Create(zipFileToCreate)) { using (var ns = new Alienlab.Zip.Tests.NonSeekableOutputStream(raw)) { zip.Save(ns); } } } else zip.Save(zipFileToCreate); } BasicVerifyZip(Path.GetFileName(zipFileToCreate), password); Assert.AreEqual<int>(files.Length, TestUtilities.CountEntries(zipFileToCreate), "Trial ({0},{1}): The zip file created has the wrong number of entries.", cycle, k); } }
public void UpdateZip_AddNewDirectory() { string zipFileToCreate = Path.Combine(TopLevelDir, "UpdateZip_AddNewDirectory.zip"); String CommentOnArchive = "BasicTests::UpdateZip_AddNewDirectory(): This archive will be overwritten."; string newComment = "This comment has been OVERWRITTEN." + DateTime.Now.ToString("G"); string dirToZip = Path.Combine(TopLevelDir, "zipup"); int i, j; int entries = 0; string subdir = null; String filename = null; int subdirCount = _rnd.Next(4) + 4; for (i = 0; i < subdirCount; i++) { subdir = Path.Combine(dirToZip, "Directory." + i); Directory.CreateDirectory(subdir); int fileCount = _rnd.Next(3) + 3; for (j = 0; j < fileCount; j++) { filename = Path.Combine(subdir, "file" + j + ".txt"); TestUtilities.CreateAndFillFileText(filename, _rnd.Next(12000) + 5000); entries++; } } using (ZipFile zip = new ZipFile()) { zip.AddDirectory(dirToZip); zip.Comment = CommentOnArchive; zip.Save(zipFileToCreate); } Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entries, "The created Zip file has an unexpected number of entries."); BasicVerifyZip(zipFileToCreate); // Now create a new subdirectory and add that one subdir = Path.Combine(TopLevelDir, "NewSubDirectory"); Directory.CreateDirectory(subdir); filename = Path.Combine(subdir, "newfile.txt"); TestUtilities.CreateAndFillFileText(filename, _rnd.Next(12000) + 5000); entries++; using (ZipFile zip = new ZipFile(zipFileToCreate)) { zip.AddDirectory(subdir); zip.Comment = newComment; // this will add entries into the existing zip file zip.Save(); } Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entries, "The overwritten Zip file has the wrong number of entries."); using (ZipFile readzip = new ZipFile(zipFileToCreate)) { Assert.AreEqual<string>(newComment, readzip.Comment, "The zip comment is incorrect."); } }
public void UpdateZip_UpdateEntryComment() { for (int k = 0; k < 2; k++) { int j; int entriesToBeAdded = 0; string filename = null; string repeatedLine = null; // select the name of the zip file string zipFileToCreate = Path.Combine(TopLevelDir, String.Format("UpdateZip_UpdateEntryComment-{0}.zip", k)); // create the subdirectory string subdir = Path.Combine(TopLevelDir, String.Format("A{0}", k)); Directory.CreateDirectory(subdir); // create a bunch of files //int numFilesToCreate = _rnd.Next(15) + 18; int numFilesToCreate = _rnd.Next(5) + 3; TestContext.WriteLine("\n-----------------------------\r\n{0}: Trial {1}, adding {2} files into '{3}'...", DateTime.Now.ToString("HH:mm:ss"), k, numFilesToCreate, zipFileToCreate); for (j = 0; j < numFilesToCreate; j++) { filename = String.Format("file{0:D3}.txt", j); repeatedLine = String.Format("This line is repeated over and over and over in file {0}", filename); int filesize = _rnd.Next(34000) + 800; TestUtilities.CreateAndFillFileText(Path.Combine(subdir, filename), repeatedLine, filesize); entriesToBeAdded++; } // Add the files to the zip, save the zip Directory.SetCurrentDirectory(TopLevelDir); using (ZipFile zip1 = new ZipFile()) { String[] filenames = Directory.GetFiles(String.Format("A{0}", k)); foreach (String f in filenames) zip1.AddFile(f, ""); zip1.Comment = "UpdateTests::UpdateZip_UpdateEntryComment(): This archive will be updated."; zip1.Save(zipFileToCreate); } // Verify the files are in the zip Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entriesToBeAdded, "the Zip file has the wrong number of entries."); // update the comments for a few files in the zip archive int updateCount = 0; using (ZipFile zip2 = ZipFile.Read(zipFileToCreate)) { do { foreach (ZipEntry e in zip2) { if (_rnd.Next(2) == 1) { if (String.IsNullOrEmpty(e.Comment)) { e.Comment = "This is a new comment on entry " + e.FileName; updateCount++; } } } } while (updateCount < 2); zip2.Comment = String.Format("This archive has been modified. Comments on {0} entries have been inserted.", updateCount); zip2.Save(); } // Extract all files, verify that none have been removed, // and verify the contents of those that remain. int commentCount = 0; using (ZipFile zip3 = ZipFile.Read(zipFileToCreate)) { foreach (string s1 in zip3.EntryFileNames) { string dir = String.Format("extract{0}", k); zip3[s1].Extract(dir); repeatedLine = String.Format("This line is repeated over and over and over in file {0}", s1); // verify the content of the updated file. var sr = new StreamReader(Path.Combine(dir, s1)); string sLine = sr.ReadLine(); sr.Close(); Assert.AreEqual<string>(repeatedLine, sLine, String.Format("The content of the originally added file ({0}) in the zip archive is incorrect.", s1)); if (!String.IsNullOrEmpty(zip3[s1].Comment)) { commentCount++; } } } Assert.AreEqual<int>(updateCount, commentCount, "The updated Zip file has the wrong number of entries with comments."); // Verify the files are in the zip Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entriesToBeAdded, "The updated Zip file has the wrong number of entries."); } }
public void Update_FromRoot_wi11988() { string zipFileToCreate = "FromRoot.zip"; string dirToZip = "Fodder"; var files = TestUtilities.GenerateFilesFlat(dirToZip); string windir = System.Environment.GetEnvironmentVariable("Windir"); string substExe = Path.Combine(Path.Combine(windir, "system32"), "subst.exe"); Assert.IsTrue(File.Exists(substExe), "subst.exe does not exist ({0})", substExe); try { // create a subst drive this.Exec(substExe, "G: " + dirToZip); using (var zip = new ZipFile()) { zip.UpdateSelectedFiles("*.*", "G:\\", "", true); zip.Save(zipFileToCreate); } Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), files.Length); Assert.IsTrue(files.Length > 3); BasicVerifyZip(zipFileToCreate); } finally { // remove the virt drive this.Exec(substExe, "/D G:"); } }
public void UpdateZip_RenameEntry() { string dirToZip = Path.GetFileNameWithoutExtension(Path.GetRandomFileName()); var files = TestUtilities.GenerateFilesFlat(dirToZip, _rnd.Next(13) + 24, 42 * 1024 + _rnd.Next(20000)); // Two passes: in pass 1, simply rename the file; // in pass 2, rename it so that it has a directory. // This shouldn't matter, but we test it anyway. for (int k = 0; k < 2; k++) { string zipFileToCreate = String.Format("UpdateZip_RenameEntry-{0}.zip", k); TestContext.WriteLine("-----------------------------"); TestContext.WriteLine("{0}: Trial {1}, adding {2} files into '{3}'...", DateTime.Now.ToString("HH:mm:ss"), k, files.Length, zipFileToCreate); // Add the files to the zip, save the zip Directory.SetCurrentDirectory(TopLevelDir); using (ZipFile zip1 = new ZipFile()) { foreach (String f in files) zip1.AddFile(f, ""); zip1.Comment = "This archive will be updated."; zip1.Save(zipFileToCreate); } // Verify the number of files in the zip Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), files.Length, "the Zip file has the wrong number of entries."); // selectively rename a few files in the zip archive int renameCount = 0; using (ZipFile zip2 = ZipFile.Read(zipFileToCreate)) { var toRename = new List<ZipEntry>(); while (toRename.Count < 2) { foreach (ZipEntry e in zip2) { if (_rnd.Next(2) == 1) toRename.Add(e); } } foreach (ZipEntry e in toRename) { var newname = (k == 0) ? e.FileName + "-renamed" : "renamed_files\\" + e.FileName; TestContext.WriteLine(" renaming {0} to {1}", e.FileName, newname); e.FileName = newname; e.Comment = "renamed"; renameCount++; } zip2.Comment = String.Format("This archive has been modified. {0} files have been renamed.", renameCount); zip2.Save(); } // Extract all the files, verify that none have been removed, // and verify the names of the entries. int renameCount2 = 0; using (ZipFile zip3 = ZipFile.Read(zipFileToCreate)) { foreach (string s1 in zip3.EntryFileNames) { string dir = String.Format("extract{0}", k); zip3[s1].Extract(dir); string origFilename = Path.GetFileName((s1.Contains("renamed")) ? s1.Replace("-renamed", "") : s1); if (zip3[s1].Comment == "renamed") renameCount2++; } } Assert.AreEqual<int>(renameCount, renameCount2, "The updated Zip file has the wrong number of renamed entries."); Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), files.Length, "Wrong number of entries."); } }
public void Update_MultipleSavesWithRename_wi10544() { // select the name of the zip file string zipFileToCreate = Path.Combine(TopLevelDir, "Update_MultipleSaves_wi10319.zip"); string entryName = "Entry1.txt"; TestContext.WriteLine("Creating zip file... "); using (var zip = new ZipFile()) { string firstline = "This is the first line in the Entry.\n"; byte[] a = System.Text.Encoding.ASCII.GetBytes(firstline.ToCharArray()); zip.AddEntry(entryName, a); zip.Save(zipFileToCreate); } int N = _rnd.Next(34) + 59; for (int i = 0; i < N; i++) { string tempZipFile = "AppendToEntry.zip.tmp" + i; TestContext.WriteLine("Update cycle {0}... ", i); using (var zip1 = ZipFile.Read(zipFileToCreate)) { using (var zip = new ZipFile()) { zip.AddEntry(entryName, (name, stream) => { var src = zip1[name].OpenReader(); int n; byte[] b = new byte[2048]; while ((n = src.Read(b, 0, b.Length)) > 0) stream.Write(b, 0, n); string update = String.Format("Updating zip file {0} at {1}\n", i, DateTime.Now.ToString("G")); byte[] a = System.Text.Encoding.ASCII.GetBytes(update.ToCharArray()); stream.Write(a, 0, a.Length); }); zip.Save(tempZipFile); } } File.Delete(zipFileToCreate); System.Threading.Thread.Sleep(1400); File.Move(tempZipFile, zipFileToCreate); } }
public void Update_MultipleSaves_wi10694() { string zipFileToCreate = "Update_MultipleSaves_wi10694.zip"; var shortDir = "fodder"; string subdir = Path.Combine(TopLevelDir, shortDir); string[] filesToZip = TestUtilities.GenerateFilesFlat(subdir); using (ZipFile zip1 = new ZipFile()) { zip1.AddFiles(filesToZip, "Download"); zip1.AddFiles(filesToZip, "other"); zip1.Save(zipFileToCreate); } Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), 2 * filesToZip.Length, "Incorrect number of entries in the zip file."); using (var zip2 = ZipFile.Read(zipFileToCreate)) { var entries = zip2.Entries.Where(e => e.FileName.Contains("Download")).ToArray(); //PART1 - Add directory and save zip2.AddDirectoryByName("XX"); zip2.Save(); //PART2 - Rename paths (not related to XX directory from above) and save foreach (var zipEntry in entries) { zipEntry.FileName = zipEntry.FileName.Replace("Download", "Download2"); } zip2.Save(); } Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), 2 * filesToZip.Length, "Incorrect number of entries in the zip file."); }
public void Update_MultipleSaves_wi10319() { string zipFileToCreate = "MultipleSaves_wi10319.zip"; using (ZipFile _zipFile = new ZipFile(zipFileToCreate)) { using (MemoryStream data = new MemoryStream()) { using (StreamWriter writer = new StreamWriter(data)) { writer.Write("Dit is een test string."); writer.Flush(); data.Seek(0, SeekOrigin.Begin); _zipFile.AddEntry("test.txt", data); _zipFile.Save(); _zipFile.AddEntry("test2.txt", "Esta es un string de test"); _zipFile.Save(); _zipFile.AddEntry("test3.txt", "this is some content for the entry."); _zipFile.Save(); } } } using (ZipFile _zipFile = new ZipFile(zipFileToCreate)) { using (MemoryStream data = new MemoryStream()) { using (StreamWriter writer = new StreamWriter(data)) { writer.Write("Dit is een andere test string."); writer.Flush(); data.Seek(0, SeekOrigin.Begin); _zipFile.UpdateEntry("test.txt", data); _zipFile.Save(); _zipFile.UpdateEntry("test2.txt", "Esta es un otro string de test"); _zipFile.Save(); _zipFile.UpdateEntry("test3.txt", "This is another string for content."); _zipFile.Save(); } } } }
[TestMethod, Timeout(30 * 60 * 1000)] // in ms. 30*60*100 == 30min public void ZipFile_PDOS_LeakTest_wi10030() { // Test memory growth over many many cycles. // There was a leak in the ParallelDeflateOutputStream, where // the PDOS was not being GC'd. This test checks for that. // // If the error is present, this test will either timeout or // throw an InsufficientMemoryException (or whatever). The // timeout occurs because GC begins to get verrrrry // sloooooow. IF the error is not present, this test will // complete successfully, in about 20 minutes. // string zipFileToCreate = "ZipFile_PDOS_LeakTest_wi10030.zip"; int nCycles = 4096; int nFiles = 3; int sizeBase = 384 * 1024; int sizeRange = 32 * 1024; int count = 0; byte[] buffer = new byte[1024]; int n; // fill a couple memory streams with random text MemoryStream[] ms = new MemoryStream[nFiles]; for (int i = 0; i < ms.Length; i++) { ms[i] = new MemoryStream(); int sz = sizeBase + _rnd.Next(sizeRange); using (Stream rtg = new Alienlab.Zip.Tests.Utilities.RandomTextInputStream(sz)) { while ((n = rtg.Read(buffer, 0, buffer.Length)) > 0) { ms[i].Write(buffer, 0, n); } } } buffer = null; OpenDelegate opener = (x) => { Stream s = ms[count % ms.Length]; s.Seek(0L, SeekOrigin.Begin); count++; return s; }; CloseDelegate closer = (e, s) => { //s.Close(); }; string txrxLabel = "PDOS Leak Test"; _txrx = TestUtilities.StartProgressMonitor("ZipFile_PDOS_LeakTest_wi10030", txrxLabel, "starting up..."); TestContext.WriteLine("Testing for leaks...."); _txrx.Send(String.Format("pb 0 max {0}", nCycles)); _txrx.Send("pb 0 value 0"); for (int x = 0; x < nCycles; x++) { if (x != 0 && x % 16 == 0) { TestContext.WriteLine("Cycle {0}...", x); string status = String.Format("status Cycle {0}/{1} {2:N0}%", x + 1, nCycles, ((x+1)/(0.01 * nCycles))); _txrx.Send(status); } using (ZipFile zip = new ZipFile()) { zip.ParallelDeflateThreshold = 128 * 1024; zip.CompressionLevel = Alienlab.Zlib.CompressionLevel.BestCompression; //zip.SaveProgress += streams_SaveProgress; for (int y = 0; y < nFiles; y++) { zip.AddEntry("Entry" + y + ".txt", opener, closer); } zip.Comment = "Produced at " + System.DateTime.UtcNow.ToString("G"); zip.Save(zipFileToCreate); } _txrx.Send("pb 0 step"); } for (int i = 0; i < ms.Length; i++) { ms[i].Dispose(); ms[i] = null; } ms = null; }
public void UpdateZip_RemoveEntry_ByFilename() { for (int k = 0; k < 2; k++) { int j; int entriesToBeAdded = 0; string filename = null; string repeatedLine = null; // select the name of the zip file string zipFileToCreate = Path.Combine(TopLevelDir, String.Format("UpdateZip_RemoveEntry_ByFilename-{0}.zip", k)); // create the subdirectory string subdir = Path.Combine(TopLevelDir, String.Format("A{0}", k)); Directory.CreateDirectory(subdir); // create a bunch of files int numFilesToCreate = _rnd.Next(13) + 24; for (j = 0; j < numFilesToCreate; j++) { filename = String.Format("file{0:D3}.txt", j); repeatedLine = String.Format("This line is repeated over and over and over in file {0}", filename); TestUtilities.CreateAndFillFileText(Path.Combine(subdir, filename), repeatedLine, _rnd.Next(34000) + 5000); entriesToBeAdded++; } // Add the files to the zip, save the zip. // in pass 2, remove one file, then save again. Directory.SetCurrentDirectory(TopLevelDir); using (ZipFile zip1 = new ZipFile()) { String[] filenames = Directory.GetFiles(String.Format("A{0}", k)); foreach (String f in filenames) zip1.AddFile(f, ""); zip1.Comment = "UpdateTests::UpdateZip_RemoveEntry_ByFilename(): This archive will be updated."; zip1.Save(zipFileToCreate); // conditionally remove a single entry, on the 2nd trial if (k == 1) { int chosen = _rnd.Next(filenames.Length); zip1.RemoveEntry(zip1[chosen]); zip1.Save(); } } // Verify the files are in the zip Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entriesToBeAdded - k, "Trial {0}: the Zip file has the wrong number of entries.", k); if (k == 0) { // selectively remove a few files in the zip archive var filesToRemove = new List<string>(); int numToRemove = _rnd.Next(numFilesToCreate - 4) + 1; using (ZipFile zip2 = ZipFile.Read(zipFileToCreate)) { for (j = 0; j < numToRemove; j++) { // select a new, uniquely named file to create do { filename = String.Format("file{0:D3}.txt", _rnd.Next(numFilesToCreate)); } while (filesToRemove.Contains(filename)); // add this file to the list filesToRemove.Add(filename); zip2.RemoveEntry(filename); } zip2.Comment = "This archive has been modified. Some files have been removed."; zip2.Save(); } // extract all files, verify none should have been removed, // and verify the contents of those that remain using (ZipFile zip3 = ZipFile.Read(zipFileToCreate)) { foreach (string s1 in zip3.EntryFileNames) { Assert.IsFalse(filesToRemove.Contains(s1), String.Format("File ({0}) was not expected.", s1)); zip3[s1].Extract("extract"); repeatedLine = String.Format("This line is repeated over and over and over in file {0}", s1); // verify the content of the updated file. var sr = new StreamReader(Path.Combine("extract", s1)); string sLine = sr.ReadLine(); sr.Close(); Assert.AreEqual<string>(repeatedLine, sLine, String.Format("The content of the originally added file ({0}) in the zip archive is incorrect.", s1)); } } // Verify the files are in the zip Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entriesToBeAdded - filesToRemove.Count, "The updated Zip file has the wrong number of entries."); } } }
public void ReadZip_OpenReader() { string[] passwords = { null, Path.GetRandomFileName(), "EE", "***()" }; for (int j = 0; j < compLevels.Length; j++) { for (int k = 0; k < passwords.Length; k++) { string zipFileToCreate = String.Format("ReadZip_OpenReader-{0}-{1}.zip", j, k); //int entriesAdded = 0; //String filename = null; string dirToZip = String.Format("dirToZip.{0}.{1}", j, k); var files = TestUtilities.GenerateFilesFlat(dirToZip); using (ZipFile zip1 = new ZipFile()) { zip1.CompressionLevel = compLevels[j]; zip1.Password = passwords[k]; zip1.AddDirectory(dirToZip,dirToZip); zip1.Save(zipFileToCreate); } // Verify the files are in the zip Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), files.Length, String.Format("Trial ({0},{1})", j, k)); int i = 0; ZipEntry e1 = null; Func<Ionic.Crc.CrcCalculatorStream> opener = () => { if (i == 0) return e1.OpenReader(); if (i == 1) return e1.OpenReader(passwords[k]); e1.Password = passwords[k]; return e1.OpenReader(); }; // now extract the files and verify their contents using (ZipFile zip2 = ZipFile.Read(zipFileToCreate)) { for (i = 0; i < 3; i++) { // try once with Password set on ZipFile, // another with password on the entry, and // a third time with password passed into the OpenReader() method. if (i == 0) zip2.Password = passwords[k]; foreach (string eName in zip2.EntryFileNames) { e1 = zip2[eName]; if (e1.IsDirectory) continue; using (var s = opener()) { string outFile = String.Format("{0}.{1}.out", eName, i); int totalBytesRead = 0; using (var output = File.Create(outFile)) { byte[] buffer = new byte[4096]; int n; while ((n = s.Read(buffer, 0, buffer.Length)) > 0) { totalBytesRead += n; output.Write(buffer, 0, n); } } TestContext.WriteLine("CRC expected({0:X8}) actual({1:X8})", e1.Crc, s.Crc); Assert.AreEqual<Int32>(s.Crc, e1.Crc, string.Format("{0} :: CRC Mismatch", eName)); Assert.AreEqual<Int32>(totalBytesRead, (int)e1.UncompressedSize, string.Format("We read an unexpected number of bytes. ({0})", eName)); } } } } } } }
public void UpdateZip_RemoveEntry_ViaIndexer_WithPassword() { string password = TestUtilities.GenerateRandomPassword(); string filename = null; int entriesToBeAdded = 0; string repeatedLine = null; int j; // select the name of the zip file string zipFileToCreate = Path.Combine(TopLevelDir, "UpdateZip_RemoveEntry_ViaIndexer_WithPassword.zip"); // create the subdirectory string subdir = Path.Combine(TopLevelDir, "A"); Directory.CreateDirectory(subdir); // create the files int numFilesToCreate = _rnd.Next(13) + 14; for (j = 0; j < numFilesToCreate; j++) { filename = String.Format("file{0:D3}.txt", j); repeatedLine = String.Format("This line is repeated over and over and over in file {0}", filename); TestUtilities.CreateAndFillFileText(Path.Combine(subdir, filename), repeatedLine, _rnd.Next(34000) + 5000); entriesToBeAdded++; } // Add the files to the zip, save the zip Directory.SetCurrentDirectory(TopLevelDir); using (ZipFile zip = new ZipFile()) { String[] filenames = Directory.GetFiles("A"); zip.Password = password; foreach (String f in filenames) zip.AddFile(f, ""); zip.Comment = "UpdateTests::UpdateZip_OpenForUpdate_Password_RemoveViaIndexer(): This archive will be updated."; zip.Save(zipFileToCreate); } // Verify the files are in the zip Assert.AreEqual<int>(entriesToBeAdded, TestUtilities.CountEntries(zipFileToCreate), "The Zip file has the wrong number of entries."); // selectively remove a few files in the zip archive var filesToRemove = new List<string>(); int numToRemove = _rnd.Next(numFilesToCreate - 4); using (ZipFile zip2 = ZipFile.Read(zipFileToCreate)) { for (j = 0; j < numToRemove; j++) { // select a new, uniquely named file to create do { filename = String.Format("file{0:D3}.txt", _rnd.Next(numFilesToCreate)); } while (filesToRemove.Contains(filename)); // add this file to the list filesToRemove.Add(filename); // remove the file from the zip archive zip2.RemoveEntry(filename); } zip2.Comment = "This archive has been modified. Some files have been removed."; zip2.Save(); } // extract all files, verify none should have been removed, // and verify the contents of those that remain using (ZipFile zip3 = ZipFile.Read(zipFileToCreate)) { foreach (string s1 in zip3.EntryFileNames) { Assert.IsFalse(filesToRemove.Contains(s1), String.Format("File ({0}) was not expected.", s1)); zip3[s1].ExtractWithPassword("extract", password); repeatedLine = String.Format("This line is repeated over and over and over in file {0}", s1); // verify the content of the updated file. var sr = new StreamReader(Path.Combine("extract", s1)); string sLine = sr.ReadLine(); sr.Close(); Assert.AreEqual<string>(repeatedLine, sLine, String.Format("The content of the originally added file ({0}) in the zip archive is incorrect.", s1)); } } // Verify the files are in the zip Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entriesToBeAdded - filesToRemove.Count, "The updated Zip file has the wrong number of entries."); }
public void AddEntry_JitProvided() { for (int i = 0; i < crypto.Length; i++) { for (int k = 0; k < compLevels.Length; k++) { string zipFileToCreate = String.Format("AddEntry_JitProvided.{0}.{1}.zip", i, k); string dirToZip = Path.GetFileNameWithoutExtension(Path.GetRandomFileName()); var files = TestUtilities.GenerateFilesFlat(dirToZip); string password = Path.GetRandomFileName(); using (var zip = new ZipFile()) { TestContext.WriteLine("================================="); TestContext.WriteLine("Creating {0}...", Path.GetFileName(zipFileToCreate)); TestContext.WriteLine("Encryption({0}) Compression({1}) pw({2})", crypto[i].ToString(), compLevels[k].ToString(), password); zip.Password = password; zip.Encryption = crypto[i]; zip.CompressionLevel = compLevels[k]; foreach (var file in files) zip.AddEntry(file, (name) => File.OpenRead(name), (name, stream) => stream.Close() ); zip.Save(zipFileToCreate); } if (crypto[i] == EncryptionAlgorithm.None) BasicVerifyZip(zipFileToCreate); else BasicVerifyZip(zipFileToCreate, password); Assert.AreEqual<int>(files.Length, TestUtilities.CountEntries(zipFileToCreate), "Trial ({0},{1}): The zip file created has the wrong number of entries.", i, k); } } }
public void UpdateZip_RemoveAllEntries() { string password = "******" + TestUtilities.GenerateRandomLowerString(7); string filename = null; int entriesToBeAdded = 0; string repeatedLine = null; int j; // select the name of the zip file string zipFileToCreate = Path.Combine(TopLevelDir, "UpdateZip_RemoveAllEntries.zip"); // create the subdirectory string subdir = Path.Combine(TopLevelDir, "A"); Directory.CreateDirectory(subdir); // create the files int numFilesToCreate = _rnd.Next(13) + 14; for (j = 0; j < numFilesToCreate; j++) { filename = String.Format("file{0:D3}.txt", j); repeatedLine = String.Format("This line is repeated over and over and over in file {0}", filename); TestUtilities.CreateAndFillFileText(Path.Combine(subdir, filename), repeatedLine, _rnd.Next(34000) + 5000); entriesToBeAdded++; } // Add the files to the zip, save the zip Directory.SetCurrentDirectory(TopLevelDir); using (ZipFile zip = new ZipFile()) { String[] filenames = Directory.GetFiles("A"); zip.Password = password; foreach (String f in filenames) zip.AddFile(f, ""); zip.Comment = "UpdateTests::UpdateZip_RemoveAllEntries(): This archive will be updated."; zip.Save(zipFileToCreate); } // Verify the files are in the zip Assert.AreEqual<int>(entriesToBeAdded, TestUtilities.CountEntries(zipFileToCreate), "The Zip file has the wrong number of entries."); // remove all the entries from the zip archive using (ZipFile zip2 = ZipFile.Read(zipFileToCreate)) { zip2.RemoveSelectedEntries("*.*"); zip2.Comment = "This archive has been modified. All the entries have been removed."; zip2.Save(); } // Verify the files are in the zip Assert.AreEqual<int>(0, TestUtilities.CountEntries(zipFileToCreate), "The Zip file has the wrong number of entries."); }
public void Progress_AddFiles() { Directory.SetCurrentDirectory(TopLevelDir); string zipFileToCreate = Path.Combine(TopLevelDir, "Progress_AddFiles.zip"); string dirToZip = Path.GetFileNameWithoutExtension(Path.GetRandomFileName()); var files = TestUtilities.GenerateFilesFlat(dirToZip); var sw = new StringWriter(); using (ZipFile zip = new ZipFile(zipFileToCreate, sw)) { zip.AddProgress += AddProgress1; zip.AddFiles(files); zip.Save(); } TestContext.WriteLine(sw.ToString()); int count = TestUtilities.CountEntries(zipFileToCreate); Assert.AreEqual<Int32>(count, files.Length); }
public void UpdateZip_AddFile_OldEntriesWithPassword() { string password = "******"; string filename = null; int entriesAdded = 0; string repeatedLine = null; int j; // select the name of the zip file string zipFileToCreate = Path.Combine(TopLevelDir, "UpdateZip_AddFile_OldEntriesWithPassword.zip"); // create the subdirectory string subdir = Path.Combine(TopLevelDir, "A"); Directory.CreateDirectory(subdir); // create the files int numFilesToCreate = _rnd.Next(10) + 8; for (j = 0; j < numFilesToCreate; j++) { filename = Path.Combine(subdir, String.Format("file{0:D3}.txt", j)); repeatedLine = String.Format("This line is repeated over and over and over in file {0}", Path.GetFileName(filename)); TestUtilities.CreateAndFillFileText(filename, repeatedLine, _rnd.Next(34000) + 5000); entriesAdded++; } // Create the zip file Directory.SetCurrentDirectory(TopLevelDir); using (ZipFile zip1 = new ZipFile()) { zip1.Password = password; String[] filenames = Directory.GetFiles("A"); foreach (String f in filenames) zip1.AddFile(f, ""); zip1.Comment = "UpdateTests::UpdateZip_AddFile_OldEntriesWithPassword(): This archive will be updated."; zip1.Save(zipFileToCreate); } // Verify the files are in the zip Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entriesAdded, "The Zip file has the wrong number of entries."); // Create a bunch of new files... var addedFiles = new List<string>(); int numToUpdate = _rnd.Next(numFilesToCreate - 4); for (j = 0; j < numToUpdate; j++) { // select a new, uniquely named file to create filename = String.Format("newfile{0:D3}.txt", j); // create a new file, and fill that new file with text data repeatedLine = String.Format("**UPDATED** This file ({0}) has been updated on {1}.", filename, System.DateTime.Now.ToString("yyyy-MM-dd")); TestUtilities.CreateAndFillFileText(Path.Combine(subdir, filename), repeatedLine, _rnd.Next(34000) + 5000); addedFiles.Add(filename); } // add each one of those new files in the zip archive using (ZipFile zip2 = ZipFile.Read(zipFileToCreate)) { foreach (string s in addedFiles) zip2.AddFile(Path.Combine(subdir, s), ""); zip2.Comment = "UpdateTests::UpdateZip_AddFile_OldEntriesWithPassword(): This archive has been updated."; zip2.Save(); } // Verify the number of files in the zip Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entriesAdded + addedFiles.Count, "The Zip file has the wrong number of entries."); // now extract the newly-added files and verify their contents using (ZipFile zip3 = ZipFile.Read(zipFileToCreate)) { foreach (string s in addedFiles) { repeatedLine = String.Format("**UPDATED** This file ({0}) has been updated on {1}.", s, System.DateTime.Now.ToString("yyyy-MM-dd")); zip3[s].Extract("extract"); // verify the content of the updated file. var sr = new StreamReader(Path.Combine("extract", s)); string sLine = sr.ReadLine(); sr.Close(); Assert.AreEqual<string>(repeatedLine, sLine, String.Format("The content of the Updated file ({0}) in the zip archive is incorrect.", s)); } } // extract all the other files and verify their contents using (ZipFile zip4 = ZipFile.Read(zipFileToCreate)) { foreach (string s1 in zip4.EntryFileNames) { bool addedLater = false; foreach (string s2 in addedFiles) { if (s2 == s1) addedLater = true; } if (!addedLater) { zip4[s1].ExtractWithPassword("extract", password); repeatedLine = String.Format("This line is repeated over and over and over in file {0}", s1); // verify the content of the updated file. var sr = new StreamReader(Path.Combine("extract", s1)); string sLine = sr.ReadLine(); sr.Close(); Assert.AreEqual<string>(repeatedLine, sLine, String.Format("The content of the originally added file ({0}) in the zip archive is incorrect.", s1)); } } } }
public void Password_CheckZipPassword_wi13664() { string[] passwords = { null, "Password!", TestUtilities.GenerateRandomPassword(), "_" }; string dirToZip = Path.Combine(TopLevelDir, "zipthis"); int subdirCount; int entries = TestUtilities.GenerateFilesOneLevelDeep (TestContext, "wi13664", dirToZip, null, out subdirCount); string[] filesToZip = Directory.GetFiles("zipthis", "*.*", SearchOption.AllDirectories); Assert.AreEqual<int>(filesToZip.Length, entries, "Incorrect number of entries in the directory."); for (int j = 0; j < passwords.Length; j++) { string zipFileToCreate = Path.Combine(TopLevelDir, String.Format("Password_CheckZipPassword_wi13664-{0}.zip", j)); // Create the zip archive using (ZipFile zip1 = new ZipFile()) { zip1.Password = passwords[j]; zip1.AddFiles(filesToZip, true, ""); zip1.Save(zipFileToCreate); } var r = ZipFile.CheckZipPassword(zipFileToCreate, passwords[j]); Assert.IsTrue(r, "Bad password in round {0}", j); } }
public void UpdateZip_UpdateItem() { string filename = null; int entriesAdded = 0; string repeatedLine = null; int j; // select the name of the zip file string zipFileToCreate = Path.Combine(TopLevelDir, "UpdateZip_UpdateItem.zip"); // create the subdirectory string subdir = Path.Combine(TopLevelDir, "A"); Directory.CreateDirectory(subdir); // create a bunch of files int numFilesToCreate = _rnd.Next(10) + 8; for (j = 0; j < numFilesToCreate; j++) { filename = Path.Combine(subdir, String.Format("file{0:D3}.txt", j)); repeatedLine = String.Format("Content for Original file {0}", Path.GetFileName(filename)); TestUtilities.CreateAndFillFileText(filename, repeatedLine, _rnd.Next(34000) + 5000); entriesAdded++; } // Create the zip file Directory.SetCurrentDirectory(TopLevelDir); using (ZipFile zip1 = new ZipFile()) { String[] filenames = Directory.GetFiles("A"); foreach (String f in filenames) zip1.AddFile(f, ""); zip1.Comment = "UpdateTests::UpdateZip_UpdateItem(): This archive will be updated."; zip1.Save(zipFileToCreate); } // Verify the files are in the zip Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entriesAdded, "The Zip file has the wrong number of entries."); // create another subdirectory subdir = Path.Combine(TopLevelDir, "B"); Directory.CreateDirectory(subdir); // create a bunch more files int newFileCount = numFilesToCreate + _rnd.Next(3) + 3; for (j = 0; j < newFileCount; j++) { filename = Path.Combine(subdir, String.Format("file{0:D3}.txt", j)); repeatedLine = String.Format("Content for the updated file {0} {1}", Path.GetFileName(filename), System.DateTime.Now.ToString("yyyy-MM-dd")); TestUtilities.CreateAndFillFileText(filename, repeatedLine, _rnd.Next(1000) + 2000); entriesAdded++; } // Update those files in the zip file Directory.SetCurrentDirectory(TopLevelDir); using (ZipFile zip1 = new ZipFile()) { String[] filenames = Directory.GetFiles("B"); foreach (String f in filenames) zip1.UpdateItem(f, ""); zip1.Comment = "UpdateTests::UpdateZip_UpdateItem(): This archive has been updated."; zip1.Save(zipFileToCreate); } // Verify the number of files in the zip Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), newFileCount, "The Zip file has the wrong number of entries."); // now extract the files and verify their contents using (ZipFile zip3 = ZipFile.Read(zipFileToCreate)) { foreach (string s in zip3.EntryFileNames) { repeatedLine = String.Format("Content for the updated file {0} {1}", s, System.DateTime.Now.ToString("yyyy-MM-dd")); zip3[s].Extract("extract"); // verify the content of the updated file. var sr = new StreamReader(Path.Combine("extract", s)); string sLine = sr.ReadLine(); sr.Close(); Assert.AreEqual<string>(repeatedLine, sLine, String.Format("The content of the Updated file ({0}) in the zip archive is incorrect.", s)); } } }
public void Password_MultipleEntriesDifferentPasswords() { string ZipFileToCreate = Path.Combine(TopLevelDir, "Password_MultipleEntriesDifferentPasswords.zip"); Assert.IsFalse(File.Exists(ZipFileToCreate), "The temporary zip file '{0}' already exists.", ZipFileToCreate); string SourceDir = CurrentDir; for (int i = 0; i < 3; i++) SourceDir = Path.GetDirectoryName(SourceDir); Directory.SetCurrentDirectory(TopLevelDir); string[] filenames = { Path.Combine(SourceDir, "Tools\\Zipit\\bin\\Debug\\Zipit.exe"), Path.Combine(SourceDir, "Zip\\bin\\Debug\\Ionic.Zip.xml"), }; string[] checksums = { TestUtilities.GetCheckSumString(filenames[0]), TestUtilities.GetCheckSumString(filenames[1]), }; string[] passwords = { "12345678", "0987654321", }; int j = 0; using (ZipFile zip = new ZipFile(ZipFileToCreate)) { for (j = 0; j < filenames.Length; j++) { zip.Password = passwords[j]; zip.AddFile(filenames[j], ""); } zip.Save(); } Assert.AreEqual<int>(TestUtilities.CountEntries(ZipFileToCreate), filenames.Length, "The zip file created has the wrong number of entries."); using (ZipFile zip = new ZipFile(ZipFileToCreate)) { for (j = 0; j < filenames.Length; j++) { zip[Path.GetFileName(filenames[j])].ExtractWithPassword("unpack", ExtractExistingFileAction.OverwriteSilently, passwords[j]); string newpath = Path.Combine("unpack", filenames[j]); string chk = TestUtilities.GetCheckSumString(newpath); Assert.AreEqual<string>(checksums[j], chk, "File checksums do not match."); } } }
public void ZipFile_JitStream_CloserTwice_wi10489() { int fileCount = 20 + _rnd.Next(20); string zipFileToCreate = "CloserTwice.zip"; string dirToZip = "fodder"; var files = TestUtilities.GenerateFilesFlat(dirToZip, fileCount, 100, 72000); OpenDelegate opener = (name) => { TestContext.WriteLine("Opening {0}", name); Stream s = File.OpenRead(Path.Combine(dirToZip,name)); return s; }; CloseDelegate closer = (e, s) => { TestContext.WriteLine("Closing {0}", e); s.Dispose(); }; TestContext.WriteLine("Creating zipfile {0}", zipFileToCreate); using (var zip = new ZipFile()) { foreach (var file in files) { zip.AddEntry(Path.GetFileName(file),opener,closer); } zip.Save(zipFileToCreate); } Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), files.Length); BasicVerifyZip(zipFileToCreate); }
public void Password_AddEntryWithPasswordToExistingZip() { string zipFileToCreate = "AddEntryWithPasswordToExistingZip.zip"; string dnzDir = CurrentDir; for (int i = 0; i < 3; i++) dnzDir = Path.GetDirectoryName(dnzDir); string[] filenames = { Path.Combine(dnzDir, "Tools\\Zipit\\bin\\Debug\\Zipit.exe"), Path.Combine(dnzDir, "Zip\\bin\\Debug\\Ionic.Zip.xml"), }; string[] checksums = { TestUtilities.GetCheckSumString(filenames[0]), TestUtilities.GetCheckSumString(filenames[1]), }; int j = 0; using (ZipFile zip = new ZipFile(zipFileToCreate)) { for (j = 0; j < filenames.Length; j++) zip.AddFile(filenames[j], ""); zip.Save(); } Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), 2, "wrong number of entries."); string fileX = Path.Combine(dnzDir, "Tools\\Unzip\\bin\\debug\\unzip.exe"); string checksumX = TestUtilities.GetCheckSumString(fileX); string password = TestUtilities.GenerateRandomPassword() + "!"; using (ZipFile zip = new ZipFile(zipFileToCreate)) { zip.Password = password; zip.AddFile(fileX, ""); zip.Save(); } Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), 3, "wrong number of entries."); string unpackDir = "unpack"; string newpath, chk, baseName; using (ZipFile zip = new ZipFile(zipFileToCreate)) { for (j = 0; j < filenames.Length; j++) { baseName = Path.GetFileName(filenames[j]); zip[baseName].Extract(unpackDir, ExtractExistingFileAction.OverwriteSilently); newpath = Path.Combine(unpackDir, filenames[j]); chk = TestUtilities.GetCheckSumString(newpath); Assert.AreEqual<string>(checksums[j], chk, "Checksums do not match."); } baseName = Path.GetFileName(fileX); zip[baseName].ExtractWithPassword(unpackDir, ExtractExistingFileAction.OverwriteSilently, password); newpath = Path.Combine(unpackDir, fileX); chk = TestUtilities.GetCheckSumString(newpath); Assert.AreEqual<string>(checksumX, chk, "Checksums do not match."); } }
public void JitStream_Update_wi13899() { int fileCount = 12 + _rnd.Next(16); string dirToZip = "fodder"; var files = TestUtilities.GenerateFilesFlat(dirToZip, fileCount, 100, 72000); OpenDelegate opener = (name) => { TestContext.WriteLine("Opening {0}", name); Stream s = File.OpenRead(Path.Combine(dirToZip,name)); return s; }; CloseDelegate closer = (e, s) => { TestContext.WriteLine("Closing {0}", e); s.Dispose(); }; // Two passes: first to call UpdateEntry() when no prior entry exists. // Second to call UpdateEntry when a prior entry exists. for (int j=0; j < 2; j++) { string zipFileToCreate = String.Format("wi13899-{0}.zip", j); TestContext.WriteLine(""); TestContext.WriteLine("Creating zipfile {0}", zipFileToCreate); if (j!=0) { using (var zip = new ZipFile(zipFileToCreate)) { foreach (var file in files) { zip.AddEntry(Path.GetFileName(file), "This is the content for file " + file); } zip.Save(); } Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), files.Length); BasicVerifyZip(zipFileToCreate); TestContext.WriteLine("Updating zipfile {0}", zipFileToCreate); } using (var zip = new ZipFile(zipFileToCreate)) { foreach (var file in files) { zip.UpdateEntry(Path.GetFileName(file), opener, closer); } zip.Save(); } BasicVerifyZip(zipFileToCreate); // verify checksum here? } }
public void SilentDeletion_wi10639() { string zipFileToCreate = "SilentDeletion.zip"; string dirToZip = "dirToZip"; string extractDir = "extracted"; string password = TestUtilities.GenerateRandomPassword(); string wrongPassword = "******"; var files = TestUtilities.GenerateFilesFlat(dirToZip); TestContext.WriteLine("Creating the zip."); using (var zip = new ZipFile()) { zip.Password = password; zip.AddFiles(files, dirToZip); zip.Save(zipFileToCreate); } TestContext.WriteLine("Extract one file with wrong password."); // pick a random entry to extract int ix = -1; string extractedFile = null; // perform two passes: first with correct password to extract the // file. 2nd with incorrect password to see if the file is // deleted. Directory.CreateDirectory(extractDir); for (int i=0; i < 2; i++) { try { using (var zip = ZipFile.Read(zipFileToCreate)) { if (i==0) { do { ix = this._rnd.Next(zip.Entries.Count); } while (zip[ix].IsDirectory); TestContext.WriteLine("Selected entry: {0}", zip[ix].FileName); extractedFile = Path.Combine(extractDir, zip[ix].FileName.Replace("/","\\")); TestContext.WriteLine("name for extracted file: {0}", extractedFile); Assert.IsFalse(File.Exists(extractedFile), "The file exists."); } TestContext.WriteLine("Cycle {0}: ExtractWithPassword()", i); zip[ix].ExtractWithPassword(extractDir, ExtractExistingFileAction.OverwriteSilently, (i==0)? password : wrongPassword); } } catch (Ionic.Zip.BadPasswordException bpe1) { // only swallow exceptions on the first go-round if (i==0) throw; } Assert.IsTrue(File.Exists(extractedFile), "Cycle {0}: The extracted file does not exist.", i); } }
public void UpdateZip_RemoveEntry_ByLastModTime() { // select the name of the zip file string zipFileToCreate = Path.Combine(TopLevelDir, "UpdateZip_RemoveEntry_ByLastModTime.zip"); // create the subdirectory string subdir = Path.Combine(TopLevelDir, "A"); Directory.CreateDirectory(subdir); // create the files int numFilesToCreate = _rnd.Next(13) + 24; string filename = null; int entriesAdded = 0; for (int j = 0; j < numFilesToCreate; j++) { filename = Path.Combine(subdir, String.Format("file{0:D3}.txt", j)); TestUtilities.CreateAndFillFileText(filename, _rnd.Next(34000) + 5000); entriesAdded++; } // Add the files to the zip, save the zip Directory.SetCurrentDirectory(TopLevelDir); int ix = 0; System.DateTime origDate = new System.DateTime(2007, 1, 15, 12, 1, 0); using (ZipFile zip1 = new ZipFile()) { String[] filenames = Directory.GetFiles("A"); foreach (String f in filenames) { ZipEntry e = zip1.AddFile(f, ""); e.LastModified = origDate + new TimeSpan(24 * 31 * ix, 0, 0); // 31 days * number of entries ix++; } zip1.Comment = "UpdateTests::UpdateZip_RemoveEntry_ByLastModTime(): This archive will soon be updated."; zip1.Save(zipFileToCreate); } // Verify the files are in the zip Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entriesAdded, "The Zip file has the wrong number of entries."); // selectively remove a few files in the zip archive var threshold = new TimeSpan(24 * 31 * (2 + _rnd.Next(ix - 12)), 0, 0); int numRemoved = 0; using (ZipFile zip2 = ZipFile.Read(zipFileToCreate)) { // We cannot remove the entry from the list, within the context of // an enumeration of said list. // So we add the doomed entry to a list to be removed // later. // pass 1: mark the entries for removal var entriesToRemove = new List<ZipEntry>(); foreach (ZipEntry e in zip2) { if (e.LastModified < origDate + threshold) { entriesToRemove.Add(e); numRemoved++; } } // pass 2: actually remove the entry. foreach (ZipEntry zombie in entriesToRemove) zip2.RemoveEntry(zombie); zip2.Comment = "UpdateTests::UpdateZip_RemoveEntry_ByLastModTime(): This archive has been updated."; zip2.Save(); } // Verify the correct number of files are in the zip Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entriesAdded - numRemoved, "Fie! The updated Zip file has the wrong number of entries."); // verify that all entries in the archive are within the threshold using (ZipFile zip3 = ZipFile.Read(zipFileToCreate)) { foreach (ZipEntry e in zip3) Assert.IsTrue((e.LastModified >= origDate + threshold), "Merde. The updated Zip file has entries that lie outside the threshold."); } }