Esempio n. 1
0
        public void ZipFileInfoNullParams()
        {
            Exception caughtEx;
            ZipInfo   zipInfo = new ZipInfo("test.zip");
            int       txtSize = 10240;

            CompressionTestUtil.GenerateRandomFile("test00.txt", 0, txtSize);
            CompressionTestUtil.GenerateRandomFile("test01.txt", 1, txtSize);
            zipInfo.PackFiles(null, new string[] { "test00.txt", "test01.txt" }, null);
            ZipFileInfo zfi = new ZipFileInfo(zipInfo, "test01.txt");

            caughtEx = null;
            try
            {
                new ZipFileInfo(null, "test00.txt");
            }
            catch (Exception ex) { caughtEx = ex; }
            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException));
            caughtEx = null;
            try
            {
                new ZipFileInfo(zipInfo, null);
            }
            catch (Exception ex) { caughtEx = ex; }
            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException));
            caughtEx = null;
            try
            {
                zfi.CopyTo(null);
            }
            catch (Exception ex) { caughtEx = ex; }
            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException));
        }
Esempio n. 2
0
        public void ZipInfoNullParams()
        {
            int    fileCount = 10, fileSize = 1024;
            string dirA = String.Format("{0}-{1}-A", fileCount, fileSize);

            if (Directory.Exists(dirA))
            {
                Directory.Delete(dirA, true);
            }
            Directory.CreateDirectory(dirA);
            string dirB = String.Format("{0}-{1}-B", fileCount, fileSize);

            if (Directory.Exists(dirB))
            {
                Directory.Delete(dirB, true);
            }
            Directory.CreateDirectory(dirB);

            string[] files = new string[fileCount];
            for (int iFile = 0; iFile < fileCount; iFile++)
            {
                files[iFile] = "zipinfo-" + iFile + ".txt";
                CompressionTestUtil.GenerateRandomFile(Path.Combine(dirA, files[iFile]), iFile, fileSize);
            }

            ZipInfo zipInfo = new ZipInfo("testnull.zip");

            CompressionTestUtil.TestArchiveInfoNullParams(zipInfo, dirA, dirB, files);
        }
Esempio n. 3
0
        public void ZipInfoGetFiles()
        {
            IList <ZipFileInfo> fileInfos;
            ZipInfo             zipInfo = new ZipInfo("testgetfiles.zip");

            int txtSize = 10240;

            CompressionTestUtil.GenerateRandomFile("testinfo0.txt", 0, txtSize);
            CompressionTestUtil.GenerateRandomFile("testinfo1.txt", 1, txtSize);
            CompressionTestUtil.GenerateRandomFile("testinfo2.ini", 2, txtSize);
            zipInfo.PackFiles(null, new string[] { "testinfo0.txt", "testinfo1.txt", "testinfo2.ini" }, null);

            fileInfos = zipInfo.GetFiles();
            Assert.IsNotNull(fileInfos);
            Assert.AreEqual <int>(3, fileInfos.Count);
            Assert.AreEqual <string>("testinfo0.txt", fileInfos[0].Name);
            Assert.AreEqual <string>("testinfo1.txt", fileInfos[1].Name);
            Assert.AreEqual <string>("testinfo2.ini", fileInfos[2].Name);

            fileInfos = zipInfo.GetFiles("*.txt");
            Assert.IsNotNull(fileInfos);
            Assert.AreEqual <int>(2, fileInfos.Count);
            Assert.AreEqual <string>("testinfo0.txt", fileInfos[0].Name);
            Assert.AreEqual <string>("testinfo1.txt", fileInfos[1].Name);

            fileInfos = zipInfo.GetFiles("testinfo1.txt");
            Assert.IsNotNull(fileInfos);
            Assert.AreEqual <int>(1, fileInfos.Count);
            Assert.AreEqual <string>("testinfo1.txt", fileInfos[0].Name);
            Assert.IsTrue(DateTime.Now - fileInfos[0].LastWriteTime < TimeSpan.FromMinutes(1),
                          "Checking ZipFileInfo.LastWriteTime is current.");
        }
Esempio n. 4
0
        public void ZipTruncatedArchive()
        {
            ZipInfo zipInfo = new ZipInfo("test-t.zip");

            CompressionTestUtil.GenerateRandomFile("ziptest-0.txt", 0, 5);
            CompressionTestUtil.GenerateRandomFile("ziptest-1.txt", 1, 5);
            zipInfo.PackFiles(null, new string[] { "ziptest-0.txt", "ziptest-1.txt" }, null);

            CompressionTestUtil.TestTruncatedArchive(zipInfo, typeof(ZipException));
        }
Esempio n. 5
0
        public void ZipBadPackStreamContexts()
        {
            string[] testFiles = new string[] { "test.txt" };
            CompressionTestUtil.GenerateRandomFile(testFiles[0], 0, 20000);

            using (ZipEngine zipEngine = new ZipEngine())
            {
                zipEngine.CompressionLevel = CompressionLevel.None;

                CompressionTestUtil.TestBadPackStreamContexts(zipEngine, "test.zip", testFiles);
            }
        }
Esempio n. 6
0
        public void ZipEngineNullParams()
        {
            string[] testFiles = new string[] { "test.txt" };
            ArchiveFileStreamContext streamContext = new ArchiveFileStreamContext("test.zip", null, null);

            using (ZipEngine zipEngine = new ZipEngine())
            {
                zipEngine.CompressionLevel = CompressionLevel.None;

                CompressionTestUtil.TestCompressionEngineNullParams(zipEngine, streamContext, testFiles);
            }
        }
Esempio n. 7
0
        public void ZipBadUnpackStreamContexts()
        {
            int     txtSize = 40960;
            ZipInfo zipInfo = new ZipInfo("test2.zip");

            CompressionTestUtil.GenerateRandomFile("ziptest-0.txt", 0, txtSize);
            CompressionTestUtil.GenerateRandomFile("ziptest-1.txt", 1, txtSize);
            zipInfo.PackFiles(null, new string[] { "ziptest-0.txt", "ziptest-1.txt" }, null);

            using (ZipEngine zipEngine = new ZipEngine())
            {
                CompressionTestUtil.TestBadUnpackStreamContexts(zipEngine, "test2.zip");
            }
        }
Esempio n. 8
0
        public static bool CompareDirectories(string dirA, string dirB)
        {
            bool difference = false;

            Console.WriteLine("Comparing directories {0}, {1}", dirA, dirB);

            string[] filesA = Directory.GetFiles(dirA);
            string[] filesB = Directory.GetFiles(dirB);
            for (int iA = 0; iA < filesA.Length; iA++)
            {
                filesA[iA] = Path.GetFileName(filesA[iA]);
            }
            for (int iB = 0; iB < filesB.Length; iB++)
            {
                filesB[iB] = Path.GetFileName(filesB[iB]);
            }
            Array.Sort(filesA);
            Array.Sort(filesB);

            for (int iA = 0, iB = 0; iA < filesA.Length || iB < filesB.Length;)
            {
                int comp;
                if (iA == filesA.Length)
                {
                    comp = 1;
                }
                else if (iB == filesB.Length)
                {
                    comp = -1;
                }
                else
                {
                    comp = String.Compare(filesA[iA], filesB[iB]);
                }
                if (comp < 0)
                {
                    Console.WriteLine("< " + filesA[iA]);
                    difference = true;
                    iA++;
                }
                else if (comp > 0)
                {
                    Console.WriteLine("> " + filesB[iB]);
                    difference = true;
                    iB++;
                }
                else
                {
                    string fileA = Path.Combine(dirA, filesA[iA]);
                    string fileB = Path.Combine(dirB, filesB[iB]);

                    byte[] hashA;
                    byte[] hashB;

                    lock (CompressionTestUtil.md5)
                    {
                        using (Stream fileAStream = File.OpenRead(fileA))
                        {
                            hashA = CompressionTestUtil.md5.ComputeHash(fileAStream);
                        }
                        using (Stream fileBStream = File.OpenRead(fileB))
                        {
                            hashB = CompressionTestUtil.md5.ComputeHash(fileBStream);
                        }
                    }

                    for (int i = 0; i < hashA.Length; i++)
                    {
                        if (hashA[i] != hashB[i])
                        {
                            Console.WriteLine("~  " + filesA[iA]);
                            difference = true;
                            break;
                        }
                    }

                    iA++;
                    iB++;
                }
            }

            string[] dirsA = Directory.GetDirectories(dirA);
            string[] dirsB = Directory.GetDirectories(dirB);
            for (int iA = 0; iA < dirsA.Length; iA++)
            {
                dirsA[iA] = Path.GetFileName(dirsA[iA]);
            }
            for (int iB = 0; iB < dirsB.Length; iB++)
            {
                dirsB[iB] = Path.GetFileName(dirsB[iB]);
            }
            Array.Sort(dirsA);
            Array.Sort(dirsB);

            for (int iA = 0, iB = 0; iA < dirsA.Length || iB < dirsB.Length;)
            {
                int comp;
                if (iA == dirsA.Length)
                {
                    comp = 1;
                }
                else if (iB == dirsB.Length)
                {
                    comp = -1;
                }
                else
                {
                    comp = String.Compare(dirsA[iA], dirsB[iB]);
                }
                if (comp < 0)
                {
                    Console.WriteLine("< {0}\\", dirsA[iA]);
                    difference = true;
                    iA++;
                }
                else if (comp > 0)
                {
                    Console.WriteLine("> {1}\\", dirsB[iB]);
                    difference = true;
                    iB++;
                }
                else
                {
                    string subDirA = Path.Combine(dirA, dirsA[iA]);
                    string subDirB = Path.Combine(dirB, dirsB[iB]);
                    if (!CompressionTestUtil.CompareDirectories(subDirA, subDirB))
                    {
                        difference = true;
                    }
                    iA++;
                    iB++;
                }
            }

            return(!difference);
        }
Esempio n. 9
0
        private IList <ArchiveFileInfo> RunZipPackUnpack(int fileCount, long fileSize,
                                                         long maxArchiveSize, CompressionLevel compLevel)
        {
            Console.WriteLine("Creating zip archive with {0} files of size {1}",
                              fileCount, fileSize);
            Console.WriteLine("MaxArchiveSize={0}, CompressionLevel={1}", maxArchiveSize, compLevel);

            string dirA = String.Format("{0}-{1}-A", fileCount, fileSize);

            if (Directory.Exists(dirA))
            {
                Directory.Delete(dirA, true);
            }
            Directory.CreateDirectory(dirA);
            string dirB = String.Format("{0}-{1}-B", fileCount, fileSize);

            if (Directory.Exists(dirB))
            {
                Directory.Delete(dirB, true);
            }
            Directory.CreateDirectory(dirB);

            string[] files = new string[fileCount];
            for (int iFile = 0; iFile < fileCount; iFile++)
            {
                files[iFile] = TEST_FILENAME_PREFIX + iFile + ".txt";
                CompressionTestUtil.GenerateRandomFile(Path.Combine(dirA, files[iFile]), iFile, fileSize);
            }

            string[] archiveNames = new string[1000];
            for (int i = 0; i < archiveNames.Length; i++)
            {
                if (i < 100)
                {
                    archiveNames[i] = String.Format(
                        (i == 0 ? "{0}-{1}.zip" : "{0}-{1}.z{2:d02}"),
                        fileCount, fileSize, i);
                }
                else
                {
                    archiveNames[i] = String.Format(
                        "{0}-{1}.{2:d03}", fileCount, fileSize, i);
                }
            }

            string progressTextFile      = String.Format("progress_{0}-{1}.txt", fileCount, fileSize);
            CompressionTestUtil testUtil = new CompressionTestUtil(progressTextFile);

            IList <ArchiveFileInfo> fileInfo;

            using (ZipEngine zipEngine = new ZipEngine())
            {
                zipEngine.CompressionLevel = compLevel;

                File.AppendAllText(progressTextFile,
                                   "\r\n\r\n====================================================\r\nCREATE\r\n\r\n");
                zipEngine.Progress += testUtil.PrintArchiveProgress;

                OptionStreamContext streamContext = new OptionStreamContext(archiveNames, dirA, null);
                streamContext.OptionHandler =
                    delegate(string optionName, object[] parameters)
                {
                    // For testing purposes, force zip64 for only moderately large files.
                    switch (optionName)
                    {
                    case  "forceZip64":
                        return(fileSize > UInt16.MaxValue);

                    default:
                        return(null);
                    }
                };

                zipEngine.Pack(streamContext, files, maxArchiveSize);

                string checkArchiveName = archiveNames[0];
                if (File.Exists(archiveNames[1]))
                {
                    checkArchiveName = archiveNames[1];
                }
                using (Stream archiveStream = File.OpenRead(checkArchiveName))
                {
                    bool isArchive = zipEngine.IsArchive(archiveStream);
                    Assert.IsTrue(isArchive, "Checking that created archive appears valid.");
                }

                IList <string> createdArchiveNames = new List <string>(archiveNames.Length);
                for (int i = 0; i < archiveNames.Length; i++)
                {
                    if (File.Exists(archiveNames[i]))
                    {
                        createdArchiveNames.Add(archiveNames[i]);
                    }
                    else
                    {
                        break;
                    }
                }

                Assert.AreNotEqual <int>(0, createdArchiveNames.Count);

                Console.WriteLine("Listing zip archive with {0} files of size {1}",
                                  fileCount, fileSize);
                File.AppendAllText(progressTextFile, "\r\n\r\nLIST\r\n\r\n");
                fileInfo = zipEngine.GetFileInfo(
                    new ArchiveFileStreamContext(createdArchiveNames, null, null), null);

                Assert.AreEqual <int>(fileCount, fileInfo.Count);

                Console.WriteLine("Extracting zip archive with {0} files of size {1}",
                                  fileCount, fileSize);
                File.AppendAllText(progressTextFile, "\r\n\r\nEXTRACT\r\n\r\n");
                zipEngine.Unpack(new ArchiveFileStreamContext(createdArchiveNames, dirB, null), null);
            }

            bool directoryMatch = CompressionTestUtil.CompareDirectories(dirA, dirB);

            Assert.IsTrue(directoryMatch,
                          "Testing whether zip output directory matches input directory.");

            return(fileInfo);
        }