// BasicTests.cs
// ------------------------------------------------------------------
//
// Copyright (c) 2009-2011 Dino Chiesa
// All rights reserved.
//
// This code module is part of DotNetZip, a zipfile class library.
//
// ------------------------------------------------------------------
//
// This code is licensed under the Microsoft Public License.
// See the file License.txt for the license details.
// More info on: http://dotnetzip.codeplex.com
//
// ------------------------------------------------------------------
//
// last saved (in emacs):
// Time-stamp: <2011-July-26 11:39:21>
//
// ------------------------------------------------------------------
//
// This module defines basic unit tests for DotNetZip.
//
// ------------------------------------------------------------------

using System;
using System.Text;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using RE = System.Text.RegularExpressions;

using Ionic.Zip;
using Ionic.Zip.Tests.Utilities;
using System.IO;

namespace Ionic.Zip.Tests.Basic
{
    /// <summary>
    /// Summary description for UnitTest1
    /// </summary>
    [TestClass]
    public class BasicTests : IonicTestClass
    {
        EncryptionAlgorithm[] crypto =
        {
            EncryptionAlgorithm.None,
            EncryptionAlgorithm.PkzipWeak,
            EncryptionAlgorithm.WinZipAes128,
            EncryptionAlgorithm.WinZipAes256,
        };


        public BasicTests() : base() { }


        [TestMethod]
        public void CreateZip_AddItem_WithDirectory()
        {
            // select the name of the zip file
            string zipFileToCreate = "CreateZip_AddItem.zip";

            // create a bunch of files
            string subdir = "files";
            string[] filesToZip = TestUtilities.GenerateFilesFlat(subdir);

            // Create the zip archive
            using (ZipFile zip1 = new ZipFile())
            {
                //zip.StatusMessageTextWriter = System.Console.Out;
                for (int i = 0; i < filesToZip.Length; i++)
                    zip1.AddItem(filesToZip[i], "files");
                zip1.Save(zipFileToCreate);
            }

            // Verify the number of files in the zip
            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),
                                 filesToZip.Length);
        }

        [TestMethod]
        public void CreateZip_AddItem_NoDirectory()
        {
            string zipFileToCreate = "CreateZip_AddItem.zip";
            string[] filesToZip = TestUtilities.GenerateFilesFlat(".");

            // Create the zip archive
            using (ZipFile zip1 = new ZipFile())
            {
                foreach (var f in filesToZip)
                    zip1.AddItem(f);
                zip1.Save(zipFileToCreate);
            }

            // Verify the number of files in the zip
            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),
                                 filesToZip.Length);
        }


        [TestMethod]
        [ExpectedException(typeof(Ionic.Zip.ZipException))]
        public void FileNotAvailableFails_wi10387()
        {
            string zipFileToCreate = Path.Combine(TopLevelDir, "FileNotAvailableFails.zip");
            using (var zip1 = new ZipFile(zipFileToCreate)) { zip1.Save(); }
            try
            {
                using (new FileStream(zipFileToCreate, FileMode.Open,
                                      FileAccess.ReadWrite,
                                      FileShare.None))
                {
                    using (new ZipFile(zipFileToCreate)) { }
                }
            }
            finally
            {
            }
        }


        [TestMethod]
        public void CreateZip_AddFile()
        {
            int i;
            string zipFileToCreate = "CreateZip_AddFile.zip";
            string subdir = "files";
            string[] filesToZip = TestUtilities.GenerateFilesFlat(subdir);

            using (ZipFile zip1 = new ZipFile())
            {
                for (i = 0; i < filesToZip.Length; i++)
                    zip1.AddFile(filesToZip[i], "files");
                zip1.Save(zipFileToCreate);
            }
            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),
                                 filesToZip.Length);
        }

        [TestMethod]
        public void CreateZip_AddFile_CharCase_wi13481()
        {
            string zipFileToCreate = "AddFile.zip";
            string subdir = "files";
            string[] filesToZip = TestUtilities.GenerateFilesFlat(subdir);
            Directory.SetCurrentDirectory(subdir);
            Array.ForEach(filesToZip, x => { File.Move(Path.GetFileName(x),Path.GetFileName(x).ToUpper()); });
            Directory.SetCurrentDirectory(TopLevelDir);
            filesToZip= Directory.GetFiles(subdir);

            using (ZipFile zip1 = new ZipFile())
            {
                for (int i = 0; i < filesToZip.Length; i++)
                    zip1.AddFile(filesToZip[i], "files");
                zip1.Save(zipFileToCreate);
            }
            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),
                                 filesToZip.Length);

            int nEntries = 0;
            // now, verify that we have not downcased the filenames
            using (ZipFile zip2 = new ZipFile(zipFileToCreate))
            {
                foreach (var entry in zip2.Entries)
                {
                    var fname1 = Path.GetFileName(entry.FileName);
                    var fnameLower = fname1.ToLower();
                    Assert.IsFalse(fname1.Equals(fnameLower),
                                   "{0} is all lowercase.", fname1);
                    nEntries++;
                }
            }
            Assert.IsFalse(nEntries < 2, "not enough entries");
        }


        [TestMethod]
        public void CreateZip_AddFileInDirectory()
        {
            string subdir = "fodder";
            TestUtilities.GenerateFilesFlat(subdir);
            for (int m = 0; m < 2; m++)
            {
                string directoryName = "";
                for (int k = 0; k < 4; k++)
                {
                    // select the name of the zip file
                    string zipFileToCreate = String.Format("CreateZip_AddFileInDirectory-trial{0}.{1}.zip", m, k);
                    TestContext.WriteLine("=====================");
                    TestContext.WriteLine("Trial {0}", k);
                    TestContext.WriteLine("Zipfile: {0}", zipFileToCreate);

                    directoryName = Path.Combine(directoryName,
                                                 String.Format("{0:D2}", k));

                    string[] filesToSelectFrom =
                        Directory.GetFiles(subdir, "*.*", SearchOption.AllDirectories);

                    TestContext.WriteLine("using dirname: {0}", directoryName);

                    int n = _rnd.Next(filesToSelectFrom.Length / 2) + 2;
                    TestContext.WriteLine("Zipping {0} files", n);

                    // Create the zip archive
                    var addedFiles = new List<String>();
                    using (ZipFile zip1 = new ZipFile())
                    {
                        // add n files
                        int j=0;
                        for (int i = 0; i < n; i++)
                        {
                            // select files at random
                            while (addedFiles.Contains(filesToSelectFrom[j]))
                                j = _rnd.Next(filesToSelectFrom.Length);
                            zip1.AddFile(filesToSelectFrom[j], directoryName);
                            addedFiles.Add(filesToSelectFrom[j]);
                        }
                        zip1.Save(zipFileToCreate);
                    }

                    // Verify the number of files in the zip
                    Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), n,
                                         "Wrong number of entries in the zip file {0}",
                                         zipFileToCreate);

                    using (ZipFile zip2 = ZipFile.Read(zipFileToCreate))
                    {
                        foreach (var e in zip2)
                        {
                            TestContext.WriteLine("Check entry: {0}", e.FileName);
                            Assert.AreEqual<String>(directoryName,
                                                    Path.GetDirectoryName(e.FileName),
                                                    "Wrong directory on zip entry {0}",
                                                    e.FileName);
                        }
                    }
                }

                // add progressively more files to the fodder directory
                TestUtilities.GenerateFilesFlat(subdir);
            }

        }


        [TestMethod]
        public void CreateZip_AddFile_LeadingDot()
        {
            // select the name of the zip file
            string zipFileToCreate = "CreateZip_AddFile_LeadingDot.zip";
            string[] filesToZip = TestUtilities.GenerateFilesFlat(".");
            using (ZipFile zip1 = new ZipFile())
            {
                for (int i = 0; i < filesToZip.Length; i++)
                {
                    zip1.AddFile(filesToZip[i]);
                }
                zip1.Save(zipFileToCreate);
            }

            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),
                                 filesToZip.Length);
        }




        [TestMethod]
        public void CreateZip_AddFiles_LeadingDot_Array()
        {
            // select the name of the zip file
            string zipFileToCreate = "CreateZip_AddFiles_LeadingDot_Array.zip";
            string[] filesToZip = TestUtilities.GenerateFilesFlat(".");

            // Create the zip archive
            using (ZipFile zip1 = new ZipFile())
            {
                zip1.AddFiles(filesToZip);
                zip1.Save(zipFileToCreate);
            }

            // Verify the number of files in the zip
            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),
                                 filesToZip.Length);
        }



        [TestMethod]
        public void CreateZip_AddFiles_PreserveDirHierarchy()
        {
            // select the name of the zip file
            string zipFileToCreate = "CreateZip_AddFiles_PreserveDirHierarchy.zip";
            string dirToZip = "zipthis";

            // create a bunch of files
            int subdirCount;
            int entries = TestUtilities.GenerateFilesOneLevelDeep(TestContext, "PreserveDirHierarchy", dirToZip, null, out subdirCount);

            string[] filesToZip = Directory.GetFiles(".", "*.*", SearchOption.AllDirectories);

            Assert.AreEqual<int>(filesToZip.Length, entries);

            // Create the zip archive
            using (ZipFile zip1 = new ZipFile())
            {
                zip1.AddFiles(filesToZip, true, "");
                zip1.Save(zipFileToCreate);
            }

            // Verify the number of files in the zip
            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),
                                 filesToZip.Length);
        }

        private bool ArraysAreEqual(byte[] b1, byte[] b2)
        {
            return (CompareArrays(b1, b2) == 0);
        }


        private int CompareArrays(byte[] b1, byte[] b2)
        {
            if (b1 == null && b2 == null) return 0;
            if (b1 == null || b2 == null) return 0;
            if (b1.Length > b2.Length) return 1;
            if (b1.Length < b2.Length) return -1;
            for (int i = 0; i < b1.Length; i++)
            {
                if (b1[i] > b2[i]) return 1;
                if (b1[i] < b2[i]) return -1;
            }
            return 0;
        }


        [TestMethod]
        public void CreateZip_AddEntry_ByteArray()
        {
            // select the name of the zip file
            string zipFileToCreate = "CreateZip_AddEntry_ByteArray.zip";
            int entriesToCreate = _rnd.Next(42) + 12;
            var dict = new Dictionary<string, byte[]>();

            // Create the zip archive
            using (ZipFile zip1 = new ZipFile())
            {
                for (int i = 0; i < entriesToCreate; i++)
                {
                    var b = new byte[_rnd.Next(1000) + 1000];
                    _rnd.NextBytes(b);
                    string filename = String.Format("Filename{0:D3}.bin", i);
                    var e = zip1.AddEntry(Path.Combine("data", filename), b);
                    dict.Add(e.FileName, b);
                }
                zip1.Save(zipFileToCreate);
            }

            // Verify the number of files in the zip
            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),
                                 entriesToCreate);

            using (ZipFile zip1 = ZipFile.Read(zipFileToCreate))
            {
                foreach (var e in zip1)
                {
                    // extract to a stream
                    using (var ms1 = new MemoryStream())
                    {
                        e.Extract(ms1);
                        Assert.IsTrue(ArraysAreEqual(ms1.ToArray(), dict[e.FileName]));
                    }
                }
            }
        }




        [TestMethod]
        public void CreateZip_AddFile_AddItem()
        {
            string zipFileToCreate = "CreateZip_AddFile_AddItem.zip";
            string subdir = "files";
            string[] filesToZip = TestUtilities.GenerateFilesFlat(subdir);

            // use the parameterized ctor
            using (ZipFile zip1 = new ZipFile(zipFileToCreate))
            {
                for (int i = 0; i < filesToZip.Length; i++)
                {
                    if (_rnd.Next(2) == 0)
                        zip1.AddFile(filesToZip[i], "files");
                    else
                        zip1.AddItem(filesToZip[i], "files");
                }
                zip1.Save();
            }

            // Verify the number of files in the zip
            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),
                                 filesToZip.Length);
        }


        private void DumpZipFile(ZipFile z)
        {
            TestContext.WriteLine("found {0} entries", z.Entries.Count);
            TestContext.WriteLine("RequiresZip64: '{0}'", z.RequiresZip64.HasValue ? z.RequiresZip64.Value.ToString() : "not set");
            TestContext.WriteLine("listing the entries in {0}...", String.IsNullOrEmpty(z.Name) ? "(zipfile)" : z.Name);
            foreach (var e in z)
            {
                TestContext.WriteLine("{0}", e.FileName);
            }
        }



        [TestMethod]
        public void CreateZip_ZeroEntries()
        {
            // select the name of the zip file
            string zipFileToCreate = "CreateZip_ZeroEntries.zip";

            using (ZipFile zip1 = new ZipFile())
            {
                zip1.Save(zipFileToCreate);
                DumpZipFile(zip1);
            }

            // workitem 7685
            using (ZipFile zip1 = new ZipFile(zipFileToCreate))
            {
                DumpZipFile(zip1);
            }

            using (ZipFile zip1 = ZipFile.Read(zipFileToCreate))
            {
                DumpZipFile(zip1);
            }

            // Verify the number of files in the zip
            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), 0);
        }



        [TestMethod]
        public void CreateZip_Basic_ParameterizedSave()
        {
            string zipFileToCreate = "CreateZip_Basic_ParameterizedSave.zip";
            string subdir = "files";
            int numFilesToCreate = _rnd.Next(23) + 14;
            string[] filesToZip = TestUtilities.GenerateFilesFlat(subdir, numFilesToCreate);

            using (ZipFile zip1 = new ZipFile())
            {
                //zip.StatusMessageTextWriter = System.Console.Out;
                for (int i = 0; i < filesToZip.Length; i++)
                {
                    if (_rnd.Next(2) == 0)
                        zip1.AddFile(filesToZip[i], "files");
                    else
                        zip1.AddItem(filesToZip[i], "files");
                }
                zip1.Save(zipFileToCreate);
            }

            // Verify the number of files in the zip
            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),
                                 filesToZip.Length);
        }


        [TestMethod]
        public void CreateZip_AddFile_OnlyZeroLengthFiles()
        {
            _Internal_ZeroLengthFiles(_rnd.Next(33) + 3, "CreateZip_AddFile_OnlyZeroLengthFiles", null);
        }

        [TestMethod]
        public void CreateZip_AddFile_OnlyZeroLengthFiles_Password()
        {
            _Internal_ZeroLengthFiles(_rnd.Next(33) + 3, "CreateZip_AddFile_OnlyZeroLengthFiles", Path.GetRandomFileName());
        }

        [TestMethod]
        public void CreateZip_AddFile_OneZeroLengthFile()
        {
            _Internal_ZeroLengthFiles(1, "CreateZip_AddFile_OneZeroLengthFile", null);
        }


        [TestMethod]
        public void CreateZip_AddFile_OneZeroLengthFile_Password()
        {
            _Internal_ZeroLengthFiles(1, "CreateZip_AddFile_OneZeroLengthFile_Password", Path.GetRandomFileName());
        }


        private void _Internal_ZeroLengthFiles(int fileCount, string nameStub, string password)
        {
            string zipFileToCreate = Path.Combine(TopLevelDir, nameStub + ".zip");

            int i;
            string[] filesToZip = new string[fileCount];
            for (i = 0; i < fileCount; i++)
                filesToZip[i] = TestUtilities.CreateUniqueFile("zerolength", TopLevelDir);

            var sw = new StringWriter();
            using (ZipFile zip = new ZipFile())
            {
                zip.StatusMessageTextWriter = sw;
                zip.Password = password;
                for (i = 0; i < filesToZip.Length; i++)
                    zip.AddFile(filesToZip[i]);
                zip.Save(zipFileToCreate);
            }

            string status = sw.ToString();
            TestContext.WriteLine("save output: " + status);

            BasicVerifyZip(zipFileToCreate, password);

            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), filesToZip.Length,
                                 "The zip file created has the wrong number of entries.");
        }


        [TestMethod]
        public void CreateZip_UpdateDirectory()
        {
            int i, j;

            string zipFileToCreate = "CreateZip_UpdateDirectory.zip";
            string dirToZip = "zipthis";
            Directory.CreateDirectory(dirToZip);

            TestContext.WriteLine("\n------------\nCreating files ...");

            int entries = 0;
            int subdirCount = _rnd.Next(17) + 14;
            //int subdirCount = _rnd.Next(3) + 2;
            var FileCount = new Dictionary<string, int>();
            var checksums = new Dictionary<string, byte[]>();

            for (i = 0; i < subdirCount; i++)
            {
                string subdirShort = String.Format("dir{0:D4}", i);
                string subdir = Path.Combine(dirToZip, subdirShort);
                Directory.CreateDirectory(subdir);

                int filecount = _rnd.Next(11) + 17;
                //int filecount = _rnd.Next(2) + 2;
                FileCount[subdirShort] = filecount;
                for (j = 0; j < filecount; j++)
                {
                    string filename = String.Format("file{0:D4}.x", j);
                    string fqFilename = Path.Combine(subdir, filename);
                    TestUtilities.CreateAndFillFile(fqFilename, _rnd.Next(1000) + 100);

                    var chk = TestUtilities.ComputeChecksum(fqFilename);
                    var t1 = Path.GetFileName(dirToZip);
                    var t2 = Path.Combine(t1, subdirShort);
                    var key = Path.Combine(t2, filename);
                    key = TestUtilities.TrimVolumeAndSwapSlashes(key);
                    TestContext.WriteLine("chk[{0}]= {1}", key,
                                          TestUtilities.CheckSumToString(chk));
                    checksums.Add(key, chk);
                    entries++;
                }
            }

            Directory.SetCurrentDirectory(TopLevelDir);

            TestContext.WriteLine("\n------------\nAdding files into the Zip...");

            // add all the subdirectories into a new zip
            using (ZipFile zip1 = new ZipFile())
            {
                zip1.AddDirectory(dirToZip, "zipthis");
                zip1.Save(zipFileToCreate);
            }

            TestContext.WriteLine("\n");

            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entries,
                                 "The Zip file has an unexpected number of entries.");

            TestContext.WriteLine("\n------------\nExtracting and validating checksums...");

            // validate all the checksums
            using (ZipFile zip2 = ZipFile.Read(zipFileToCreate))
            {
                foreach (ZipEntry e in zip2)
                {
                    e.Extract("unpack");
                    string pathToExtractedFile = Path.Combine("unpack", e.FileName);

                    // if it is a file....
                    if (checksums.ContainsKey(e.FileName))
                    {
                        // verify the checksum of the file is correct
                        string expectedCheckString = TestUtilities.CheckSumToString(checksums[e.FileName]);
                        string actualCheckString = TestUtilities.GetCheckSumString(pathToExtractedFile);
                        Assert.AreEqual<String>
                            (expectedCheckString,
                             actualCheckString,
                             "Unexpected checksum on extracted filesystem file ({0}).",
                             pathToExtractedFile);
                    }
                }
            }

            TestContext.WriteLine("\n------------\nCreating some new files ...");

            // now, update some of the existing files
            dirToZip = Path.Combine(TopLevelDir, "updates");
            Directory.CreateDirectory(dirToZip);

            for (i = 0; i < subdirCount; i++)
            {
                string subdirShort = String.Format("dir{0:D4}", i);
                string subdir = Path.Combine(dirToZip, subdirShort);
                Directory.CreateDirectory(subdir);

                int filecount = FileCount[subdirShort];
                for (j = 0; j < filecount; j++)
                {
                    if (_rnd.Next(2) == 1)
                    {
                        string filename = String.Format("file{0:D4}.x", j);
                        TestUtilities.CreateAndFillFile(Path.Combine(subdir, filename),
                                                        _rnd.Next(1000) + 100);
                        string fqFilename = Path.Combine(subdir, filename);

                        var chk = TestUtilities.ComputeChecksum(fqFilename);
                        //var t1 = Path.GetFileName(dirToZip);
                        var t2 = Path.Combine("zipthis", subdirShort);
                        var key = Path.Combine(t2, filename);
                        key = TestUtilities.TrimVolumeAndSwapSlashes(key);

                        TestContext.WriteLine("chk[{0}]= {1}", key,
                                              TestUtilities.CheckSumToString(chk));

                        checksums.Remove(key);
                        checksums.Add(key, chk);
                    }
                }
            }


            TestContext.WriteLine("\n------------\nUpdating some of the files in the zip...");
            // add some new content
            using (ZipFile zip3 = ZipFile.Read(zipFileToCreate))
            {
                zip3.UpdateDirectory(dirToZip, "zipthis");
                //String[] dirs = Directory.GetDirectories(dirToZip);

                //foreach (String d in dirs)
                //{
                //    string dir = Path.Combine(Path.GetFileName(dirToZip), Path.GetFileName(d));
                //    //string root = Path.Combine("zipthis", Path.GetFileName(d));
                //    zip3.UpdateDirectory(dir, "zipthis");
                //}
                zip3.Save();
            }

            TestContext.WriteLine("\n------------\nValidating the checksums for all of the files ...");

            // validate all the checksums again
            using (ZipFile zip4 = ZipFile.Read(zipFileToCreate))
            {
                foreach (ZipEntry e in zip4)
                    TestContext.WriteLine("Found entry: {0}", e.FileName);

                foreach (ZipEntry e in zip4)
                {
                    e.Extract("unpack2");
                    if (!e.IsDirectory)
                    {
                        string pathToExtractedFile = Path.Combine("unpack2", e.FileName);

                        // verify the checksum of the file is correct
                        string expectedCheckString = TestUtilities.CheckSumToString(checksums[e.FileName]);
                        string actualCheckString = TestUtilities.GetCheckSumString(pathToExtractedFile);
                        Assert.AreEqual<String>
                            (expectedCheckString,
                             actualCheckString,
                             "Unexpected checksum on extracted filesystem file ({0}).",
                             pathToExtractedFile);
                    }
                }
            }
        }



        [TestMethod]
        public void CreateZip_AddDirectory_OnlyZeroLengthFiles()
        {
            string zipFileToCreate = "CreateZip_AddDirectory_OnlyZeroLengthFiles.zip";
            string dirToZip = "zipthis";
            Directory.CreateDirectory(dirToZip);

            int entries = 0;
            int subdirCount = _rnd.Next(8) + 8;
            for (int i = 0; i < subdirCount; i++)
            {
                string subdir = Path.Combine(dirToZip, "dir" + i);
                Directory.CreateDirectory(subdir);
                int n = _rnd.Next(6) + 2;
                for (int j=0; j < n; j++)
                {
                    TestUtilities.CreateUniqueFile("bin", subdir);
                    entries++;
                }
            }

            using (var zip = new ZipFile())
            {
                zip.AddDirectory(Path.GetFileName(dirToZip));
                zip.Save(zipFileToCreate);
            }

            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entries);
        }



        [TestMethod]
        public void CreateZip_AddDirectory_OneZeroLengthFile()
        {
            string zipFileToCreate = "CreateZip_AddDirectory_OneZeroLengthFile.zip";
            string dirToZip = "zipthis";
            Directory.CreateDirectory(dirToZip);

            // one empty file
            string file = TestUtilities.CreateUniqueFile("ZeroLengthFile.txt", dirToZip);

            using (ZipFile zip = new ZipFile())
            {
                zip.AddDirectory(Path.GetFileName(dirToZip));
                zip.Save(zipFileToCreate);
            }

            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), 1);
        }


        [TestMethod]
        public void CreateZip_AddDirectory_OnlyEmptyDirectories()
        {
            string zipFileToCreate = "CreateZip_AddDirectory_OnlyEmptyDirectories.zip";
            string dirToZip = "zipthis";
            Directory.CreateDirectory(dirToZip);

            int subdirCount = _rnd.Next(28) + 18;
            for (int i = 0; i < subdirCount; i++)
            {
                string subdir = Path.Combine(dirToZip, "EmptyDir" + i);
                Directory.CreateDirectory(subdir);
            }

            using (ZipFile zip = new ZipFile())
            {
                zip.AddDirectory(Path.GetFileName(dirToZip));
                zip.Save(zipFileToCreate);
            }

            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), 0);
        }


        [TestMethod]
        public void CreateZip_AddDirectory_OneEmptyDirectory()
        {
            string zipFileToCreate = "CreateZip_AddDirectory_OneEmptyDirectory.zip";
            string dirToZip = "zipthis";
            Directory.CreateDirectory(dirToZip);

            using (ZipFile zip = new ZipFile())
            {
                zip.AddDirectory(Path.GetFileName(dirToZip));
                zip.Save(zipFileToCreate);
            }

            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), 0);
            BasicVerifyZip(zipFileToCreate);
        }


        [TestMethod]
        public void CreateZip_WithEmptyDirectory()
        {
            string zipFileToCreate = "Create_WithEmptyDirectory.zip";
            string subdir = "EmptyDirectory";
            Directory.CreateDirectory(subdir);
            using (ZipFile zip = new ZipFile())
            {
                zip.AddDirectory(subdir, "");
                zip.Save(zipFileToCreate);
            }
            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), 0);
            BasicVerifyZip(zipFileToCreate);
        }



        [TestMethod]
        public void CreateZip_AddDirectory_CheckStatusTextWriter()
        {
            string zipFileToCreate = "CreateZip_AddDirectory_CheckStatusTextWriter.zip";
            string dirToZip = "zipthis";
            Directory.CreateDirectory(dirToZip);

            int entries = 0;
            int subdirCount = _rnd.Next(8) + 8;
            for (int i = 0; i < subdirCount; i++)
            {
                string subdir = Path.Combine(dirToZip, "Dir" + i);
                Directory.CreateDirectory(subdir);
                // a few files per subdir
                int fileCount = _rnd.Next(12) + 4;
                for (int j = 0; j < fileCount; j++)
                {
                    string file = Path.Combine(subdir, "File" + j);
                    TestUtilities.CreateAndFillFile(file, 1020);
                    entries++;
                }
            }

            var sw = new StringWriter();
            using (ZipFile zip = new ZipFile())
            {
                zip.StatusMessageTextWriter = sw;
                zip.AddDirectory(Path.GetFileName(dirToZip));
                zip.Save(zipFileToCreate);
            }

            string status = sw.ToString();
            TestContext.WriteLine("save output: " + status);

            Assert.IsTrue(status.Length > 24 * entries, "status messages? ({0}!>{1})",
                          status.Length, 24 * entries);

            int n = TestUtilities.CountEntries(zipFileToCreate);
            Assert.AreEqual<int>(n, entries,
                                 "wrong number of entries. ({0}!={1})", n, entries);

            BasicVerifyZip(zipFileToCreate);
        }


        struct TestTrial
        {
            public string arg;
            public string re;
        }


        [TestMethod]
        public void CreateZip_AddDirectory()
        {
            TestTrial[] trials = {
                new TestTrial { arg=null, re="^file(\\d+).ext$"},
                new TestTrial { arg="", re="^file(\\d+).ext$"},
                new TestTrial { arg=null, re="^file(\\d+).ext$"},
                new TestTrial { arg="Xabf", re="(?s)^Xabf/(file(\\d+).ext)?$"},
                new TestTrial { arg="AAAA/BBB", re="(?s)^AAAA/BBB/(file(\\d+).ext)?$"}
            };

            for (int k = 0; k < trials.Length; k++)
            {
                TestContext.WriteLine("\n--------------------------------\n\n\n");
                string zipFileToCreate = Path.Combine(TopLevelDir, String.Format("CreateZip_AddDirectory-{0}.zip", k));

                Assert.IsFalse(File.Exists(zipFileToCreate), "The temporary zip file '{0}' already exists.", zipFileToCreate);

                string dirToZip = String.Format("DirectoryToZip.{0}.test", k);
                Directory.CreateDirectory(dirToZip);

                int fileCount = _rnd.Next(5) + 4;
                for (int i = 0; i < fileCount; i++)
                {
                    String file = Path.Combine(dirToZip, String.Format("file{0:D3}.ext", i));
                    TestUtilities.CreateAndFillFile(file, _rnd.Next(2000) + 500);
                }

                var sw = new StringWriter();
                using (ZipFile zip = new ZipFile())
                {
                    zip.StatusMessageTextWriter = sw;
                    if (k == 0)
                        zip.AddDirectory(dirToZip);
                    else
                        zip.AddDirectory(dirToZip, trials[k].arg);
                    zip.Save(zipFileToCreate);
                }
                TestContext.WriteLine(sw.ToString());
                Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), fileCount,
                                     String.Format("The zip file created in cycle {0} has the wrong number of entries.", k));

                //TestContext.WriteLine("");
                // verify that the entries in the zip are in the top level directory!!
                using (ZipFile zip2 = ZipFile.Read(zipFileToCreate))
                {
                    foreach (ZipEntry e in zip2)
                        TestContext.WriteLine("found entry: {0}", e.FileName);
                    foreach (ZipEntry e in zip2)
                    {
                        //Assert.IsFalse(e.FileName.StartsWith("dir"),
                        //       String.Format("The Zip entry '{0}' is not rooted in top level directory.", e.FileName));

                        // check the filename:
                        //RE.Match m0 = RE.Regex.Match(e.FileName, fnameRegex[k]);
                        // Assert.IsTrue(m0 != null, "No match");
                        // Assert.AreEqual<int>(m0.Groups.Count, 2,
                        //    String.Format("In cycle {0}, Matching {1} against {2}, Wrong number of matches ({3})",
                        //        k, e.FileName, fnameRegex[k], m0.Groups.Count));

                        Assert.IsTrue(RE.Regex.IsMatch(e.FileName, trials[k].re),
                                      String.Format("In cycle {0}, Matching {1} against {2}", k, e.FileName, trials[k].re));
                    }
                }
            }
        }


        [TestMethod]
        public void CreateZip_AddDirectory_Nested()
        {
            // Each trial provides a directory name into which to add
            // files, and a regex, used for verification after the zip
            // is created, to match the names on any added entries.
            TestTrial[] trials = {
                new TestTrial { arg=null, re="^dir(\\d){3}/(file(\\d+).ext)?$"},
                new TestTrial { arg="", re="^dir(\\d){3}/(file(\\d+).ext)?$"},
                new TestTrial { arg=null, re="^dir(\\d){3}/(file(\\d+).ext)?$"},
                new TestTrial { arg="rtdha", re="(?s)^rtdha/(dir(\\d){3}/(file(\\d+).ext)?)?$"},
                new TestTrial { arg="sdfjk/BBB", re="(?s)^sdfjk/BBB/(dir(\\d){3}/(file(\\d+).ext)?)?$"}
            };

            for (int k = 0; k < trials.Length; k++)
            {
                TestContext.WriteLine("\n--------------------------------\n\n\n");
                string zipFileToCreate = Path.Combine(TopLevelDir, String.Format("CreateZip_AddDirectory_Nested-{0}.zip", k));

                Assert.IsFalse(File.Exists(zipFileToCreate), "The temporary zip file '{0}' already exists.", zipFileToCreate);

                string dirToZip = String.Format("DirectoryToZip.{0}.test", k);
                Directory.CreateDirectory(dirToZip);

                int i, j;
                int entries = 0;

                int subdirCount = _rnd.Next(23) + 7;
                for (i = 0; i < subdirCount; i++)
                {
                    string subdir = Path.Combine(dirToZip, String.Format("dir{0:D3}", i));
                    Directory.CreateDirectory(subdir);

                    int fileCount = _rnd.Next(8);  // sometimes zero
                    for (j = 0; j < fileCount; j++)
                    {
                        String file = Path.Combine(subdir, String.Format("file{0:D3}.ext", j));
                        TestUtilities.CreateAndFillFile(file, _rnd.Next(10750) + 50);
                        entries++;
                    }
                }

                var sw = new StringWriter();
                using (ZipFile zip = new ZipFile())
                {
                    zip.StatusMessageTextWriter = sw;
                    if (k == 0)
                        zip.AddDirectory(dirToZip);
                    else
                        zip.AddDirectory(dirToZip, trials[k].arg);
                    zip.Save(zipFileToCreate);
                }
                TestContext.WriteLine(sw.ToString());

                Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entries,
                                     String.Format("The zip file created in cycle {0} has the wrong number of entries.", k));

                // verify that the entries in the zip are in the top level directory!!
                using (ZipFile zip2 = ZipFile.Read(zipFileToCreate))
                {
                    foreach (ZipEntry e in zip2)
                        TestContext.WriteLine("found entry: {0}", e.FileName);
                    foreach (ZipEntry e in zip2)
                    {
                        Assert.IsTrue(RE.Regex.IsMatch(e.FileName, trials[k].re),
                                      String.Format("In cycle {0}, Matching {1} against {2}", k, e.FileName, trials[k].re));
                    }

                }
            }
        }


        [TestMethod]
        public void Basic_SaveToFileStream()
        {
            // from small numbers of files to larger numbers of files
            for (int k = 0; k < 3; k++)
            {
                string zipFileToCreate = String.Format("SaveToFileStream-t{0}.zip", k);
                string dirToZip =  Path.GetRandomFileName();
                Directory.CreateDirectory(dirToZip);

                int filesToAdd = _rnd.Next(k * 10 + 3) + k * 10 + 3;
                for (int i = 0; i < filesToAdd; i++)
                {
                    var s = Path.Combine(dirToZip, String.Format("tempfile-{0}.bin", i));
                    int sz = _rnd.Next(10000) + 5000;
                    TestContext.WriteLine("  Creating file: {0} sz({1})", s, sz);
                    TestUtilities.CreateAndFillFileBinary(s, sz);
                }

                using (var fileStream = File.Create(zipFileToCreate))
                {
                    using (ZipFile zip1 = new ZipFile())
                    {
                        zip1.AddDirectory(dirToZip);
                        zip1.Comment = "This is a Comment On the Archive (AM/PM)";
                        zip1.Save(fileStream);
                    }
                }

                // Verify the files are in the zip
                Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),
                                     filesToAdd,
                                     "Trial {0}: file {1} wrong number of entries.",
                                     k, zipFileToCreate);
            }
        }



        [TestMethod]
        public void Basic_IsText()
        {
            // from small numbers of files to larger numbers of files
            for (int k = 0; k < 3; k++)
            {
                string zipFileToCreate = String.Format("Basic_IsText-trial{0}.zip", k);
                string dirToZip = Path.GetRandomFileName();
                Directory.CreateDirectory(dirToZip);

                int filesToAdd = _rnd.Next(33) + 11;
                for (int i = 0; i < filesToAdd; i++)
                {
                    var s = Path.Combine(dirToZip, String.Format("tempfile-{0}.txt", i));
                    int sz = _rnd.Next(10000) + 5000;
                    TestContext.WriteLine("  Creating file: {0} sz({1})", s, sz);
                    TestUtilities.CreateAndFillFileText(s, sz);
                }

                using (ZipFile zip1 = new ZipFile())
                {
                    int count = 0;
                    var filesToZip = Directory.GetFiles(dirToZip);
                    foreach (var f in filesToZip)
                    {
                        var e = zip1.AddFile(f, "files");
                        switch (k)
                        {
                            case 0: break;
                            case 1: if ((count % 2) == 0) e.IsText = true; break;
                            case 2: if ((count % 2) != 0) e.IsText = true; break;
                            case 3: e.IsText = true; break;
                        }
                        count++;
                    }
                    zip1.Comment = "This is a Comment On the Archive (AM/PM)";
                    zip1.Save(zipFileToCreate);
                }

                // Verify the files are in the zip
                Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),
                                     filesToAdd,
                                     "trial {0}: file {1} number of entries.",
                                     k, zipFileToCreate);

                // verify the isText setting
                using (ZipFile zip2 = ZipFile.Read(zipFileToCreate))
                {
                    int count = 0;
                    foreach (var e in zip2)
                    {
                        switch (k)
                        {
                            case 0: Assert.IsFalse(e.IsText); break;
                            case 1: Assert.AreEqual<bool>((count % 2) == 0, e.IsText); break;
                            case 2: Assert.AreEqual<bool>((count % 2) != 0, e.IsText); break;
                            case 3: Assert.IsTrue(e.IsText); break;
                        }
                        count++;
                    }
                }
            }
        }


        [TestMethod]
        public void CreateZip_VerifyThatStreamRemainsOpenAfterSave()
        {
            Ionic.Zlib.CompressionLevel[] compressionLevelOptions = {
                Ionic.Zlib.CompressionLevel.None,
                Ionic.Zlib.CompressionLevel.BestSpeed,
                Ionic.Zlib.CompressionLevel.Default,
                Ionic.Zlib.CompressionLevel.BestCompression,
            };

            string[] Passwords = { null, Path.GetRandomFileName() };

            for (int j = 0; j < Passwords.Length; j++)
            {
                for (int k = 0; k < compressionLevelOptions.Length; k++)
                {
                    TestContext.WriteLine("\n\n---------------------------------\n" +
                                          "Trial ({0},{1}):  Password='{2}' Compression={3}\n",
                                          j, k, Passwords[j], compressionLevelOptions[k]);
                    string dirToZip = Path.GetRandomFileName();
                    Directory.CreateDirectory(dirToZip);

                    int filesAdded = _rnd.Next(3) + 3;
                    for (int i = 0; i < filesAdded; i++)
                    {
                        var s = Path.Combine(dirToZip, String.Format("tempfile-{0}-{1}-{2}.bin", j, k, i));
                        int sz = _rnd.Next(10000) + 5000;
                        TestContext.WriteLine("  Creating file: {0} sz({1})", s, sz);
                        TestUtilities.CreateAndFillFileBinary(s, sz);
                    }

                    TestContext.WriteLine("\n");

                    //string dirToZip = Path.GetFileName(TopLevelDir);
                    var ms = new MemoryStream();
                    Assert.IsTrue(ms.CanSeek, String.Format("Trial {0}: The output MemoryStream does not do Seek.", k));
                    using (ZipFile zip1 = new ZipFile())
                    {
                        zip1.CompressionLevel = compressionLevelOptions[k];
                        zip1.Password = Passwords[j];
                        zip1.Comment = String.Format("Trial ({0},{1}):  Password='{2}' Compression={3}\n",
                                                     j, k, Passwords[j], compressionLevelOptions[k]);
                        zip1.AddDirectory(dirToZip);
                        zip1.Save(ms);
                    }

                    Assert.IsTrue(ms.CanSeek, String.Format("Trial {0}: After writing, the OutputStream does not do Seek.", k));
                    Assert.IsTrue(ms.CanRead, String.Format("Trial {0}: The OutputStream cannot be Read.", k));

                    // seek to the beginning
                    ms.Seek(0, SeekOrigin.Begin);
                    int filesFound = 0;
                    using (ZipFile zip2 = ZipFile.Read(ms))
                    {
                        foreach (ZipEntry e in zip2)
                        {
                            TestContext.WriteLine("  Found entry: {0} isDir({1}) sz_c({2}) sz_unc({3})", e.FileName, e.IsDirectory, e.CompressedSize, e.UncompressedSize);
                            if (!e.IsDirectory)
                                filesFound++;
                        }
                    }
                    Assert.AreEqual<int>(filesFound, filesAdded,
                                         "Trial {0}", k);
                }
            }
        }


        [TestMethod]
        public void CreateZip_AddFile_VerifyCrcAndContents()
        {
            string filename = null;
            int entriesAdded = 0;
            string repeatedLine = null;
            int j;

            string zipFileToCreate = "CreateZip_AddFile_VerifyCrcAndContents.zip";
            string subdir = "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++;
            }

            using (ZipFile zip1 = new ZipFile())
            {
                String[] filenames = Directory.GetFiles("A");
                foreach (String f in filenames)
                    zip1.AddFile(f, "");
                zip1.Comment = "UpdateTests::CreateZip_AddFile_VerifyCrcAndContents(): This archive will be updated.";
                zip1.Save(zipFileToCreate);
            }

            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),entriesAdded);

            // now extract the files and verify their contents
            using (ZipFile zip2 = ZipFile.Read(zipFileToCreate))
            {
                foreach (string s in zip2.EntryFileNames)
                {
                    repeatedLine = String.Format("This line is repeated over and over and over in file {0}", s);
                    zip2[s].Extract("extract");

                    // verify the content of the updated file.
                    var sr = new StreamReader(Path.Combine("extract", s));
                    string actualLine = sr.ReadLine();
                    sr.Close();

                    Assert.AreEqual<string>(repeatedLine, actualLine,
                                            "Updated file ({0}) is incorrect.", s);
                }
            }
        }




        [TestMethod]
        public void Extract_IntoMemoryStream()
        {
            string filename = null;
            int entriesAdded = 0;
            string repeatedLine = null;
            int j;

            string zipFileToCreate = "Extract_IntoMemoryStream.zip";
            string subdir = "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
            using (ZipFile zip1 = new ZipFile())
            {
                String[] filenames = Directory.GetFiles("A");
                foreach (String f in filenames)
                    zip1.AddFile(f, "");
                zip1.Comment = "BasicTests::Extract_IntoMemoryStream()";
                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.");

            // now extract the files into memory streams, checking only the length of the file.
            using (ZipFile zip2 = ZipFile.Read(zipFileToCreate))
            {
                foreach (string s in zip2.EntryFileNames)
                {
                    using (MemoryStream ms = new MemoryStream())
                    {
                        zip2[s].Extract(ms);
                        byte[] a = ms.ToArray();
                        string f = Path.Combine(subdir, s);
                        var fi = new FileInfo(f);
                        Assert.AreEqual<int>((int)(fi.Length), a.Length, "Unequal file lengths.");
                    }
                }
            }
        }


        [TestMethod]
        public void Retrieve_ViaIndexer2_wi11056()
        {
            string fileName = "wi11056.dwf";
            string entryName = @"com.autodesk.dwf.ePlot_5VFMLy3OdEetAPFe7uWXYg\descriptor.xml";
            string SourceDir = CurrentDir;
            for (int i = 0; i < 3; i++)
                SourceDir = Path.GetDirectoryName(SourceDir);

            TestContext.WriteLine("Current Dir: {0}", CurrentDir);

            string filename = Path.Combine(SourceDir, "Zip Tests\\bin\\Debug\\zips\\" + fileName);

            TestContext.WriteLine("Reading zip file: '{0}'", filename);
            using (ZipFile zip = ZipFile.Read(filename))
            {
                var e = zip[entryName];
                Assert.IsFalse(e == null,
                               "Retrieval by stringindex failed.");
            }
        }



        [TestMethod]
        public void Retrieve_ViaIndexer()
        {
            // select the name of the zip file
            string zipFileToCreate = Path.Combine(TopLevelDir, "Retrieve_ViaIndexer.zip");
            string filename = null;
            int entriesAdded = 0;
            string repeatedLine = null;
            int j;

            // create the subdirectory
            string subdir = "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(23000) + 4000);
                entriesAdded++;
            }

            // Create the zip file
            using (ZipFile zip1 = new ZipFile())
            {
                String[] filenames = Directory.GetFiles("A");
                foreach (String f in filenames)
                    zip1.AddFile(f, "");
                zip1.Comment = "BasicTests::Retrieve_ViaIndexer()";
                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.");

            // now extract the files into memory streams, checking only the length of the file.
            // We do 4 combinations:  case-sensitive on or off, and filename conversion on or off.
            for (int m = 0; m < 2; m++)
            {
                for (int n = 0; n < 2; n++)
                {
                    using (ZipFile zip2 = ZipFile.Read(zipFileToCreate))
                    {
                        if (n == 1) zip2.CaseSensitiveRetrieval = true;
                        foreach (string s in zip2.EntryFileNames)
                        {
                            var s2 = (m == 1) ? s.ToUpper() : s;
                            using (MemoryStream ms = new MemoryStream())
                            {
                                try
                                {
                                    zip2[s2].Extract(ms);
                                    byte[] a = ms.ToArray();
                                    string f = Path.Combine(subdir, s2);
                                    var fi = new FileInfo(f);
                                    Assert.AreEqual<int>((int)(fi.Length), a.Length, "Unequal file lengths.");
                                }
                                catch
                                {
                                    Assert.AreEqual<int>(1, n * m, "Indexer retrieval failed unexpectedly.");
                                }
                            }
                        }
                    }
                }
            }
        }




        [TestMethod]
        public void CreateZip_SetFileComments()
        {
            string zipFileToCreate = "FileComments.zip";
            string FileCommentFormat = "Comment Added By Test to file '{0}'";
            string commentOnArchive = "Comment added by FileComments() method.";

            int fileCount = _rnd.Next(3) + 3;
            string[] filesToZip = new string[fileCount];
            for (int i = 0; i < fileCount; i++)
            {
                filesToZip[i] = Path.Combine(TopLevelDir, String.Format("file{0:D3}.bin", i));
                TestUtilities.CreateAndFillFile(filesToZip[i], _rnd.Next(10000) + 5000);
            }

            using (ZipFile zip = new ZipFile())
            {
                //zip.StatusMessageTextWriter = System.Console.Out;
                for (int i = 0; i < filesToZip.Length; i++)
                {
                    // use the local filename (not fully qualified)
                    ZipEntry e = zip.AddFile(Path.GetFileName(filesToZip[i]));
                    e.Comment = String.Format(FileCommentFormat, e.FileName);
                }
                zip.Comment = commentOnArchive;
                zip.Save(zipFileToCreate);
            }

            int entries = 0;
            using (ZipFile z2 = ZipFile.Read(zipFileToCreate))
            {
                Assert.AreEqual<String>(commentOnArchive, z2.Comment, "Unexpected comment on ZipFile.");
                foreach (ZipEntry e in z2)
                {
                    string expectedComment = String.Format(FileCommentFormat, e.FileName);
                    Assert.AreEqual<string>(expectedComment, e.Comment, "Unexpected comment on ZipEntry.");
                    entries++;
                }
            }
            Assert.AreEqual<int>(entries, filesToZip.Length, "Unexpected file count. Expected {0}, got {1}.",
                                 filesToZip.Length, entries);
        }


        [TestMethod]
        public void CreateZip_SetFileLastModified()
        {
            //int fileCount = _rnd.Next(13) + 23;
            int fileCount = _rnd.Next(3) + 2;
            string[] filesToZip = new string[fileCount];
            for (int i = 0; i < fileCount; i++)
            {
                filesToZip[i] = Path.Combine(TopLevelDir, String.Format("file{0:D3}.bin", i));
                TestUtilities.CreateAndFillFileBinary(filesToZip[i], _rnd.Next(10000) + 5000);
            }
            DateTime[] timestamp =
                {
                    new System.DateTime(2007, 9, 1, 15, 0, 0),
                    new System.DateTime(2007, 4, 2, 14, 0, 0),
                    new System.DateTime(2007, 5, 18, 19, 0, 0),
                };

            // try Kind = unspecified, local, and UTC
            DateTimeKind[] kinds =
                {
                    DateTimeKind.Unspecified,
                    DateTimeKind.Local,
                    DateTimeKind.Utc,
                };

            for (int m = 0; m < timestamp.Length; m++)
            {
                for (int n = 0; n < 3; n++)
                {
                    for (int k = 0; k < 2; k++)
                    {
                        string zipFileToCreate = Path.Combine(TopLevelDir, String.Format("CreateZip-SetFileLastModified-{0}.{1}.{2}.zip", m, n, k));
                        TestContext.WriteLine("Cycle {0}.{1}.{2}", m, n, k);
                        TestContext.WriteLine("zipfile {0}", zipFileToCreate);
                        DateTime t = DateTime.SpecifyKind(timestamp[m], kinds[n]);

                        using (ZipFile zip = new ZipFile())
                        {
                            zip.EmitTimesInWindowsFormatWhenSaving = (k != 0);

                            for (int i = 0; i < filesToZip.Length; i++)
                            {
                                // use the local filename (not fully qualified)
                                ZipEntry e = zip.AddFile(Path.GetFileName(filesToZip[i]));
                                e.LastModified = t;
                            }
                            zip.Comment = "All files in this archive have the same LastModified value.";
                            zip.Save(zipFileToCreate);
                        }

                        // NB: comparing two DateTime variables will return "not
                        // equal" if they are not of the same "Kind", even if they
                        // represent the same point in time.  To counteract that,
                        // we compare using UniversalTime.

                        var x1 = t.ToUniversalTime().ToString("u");

                        string unpackDir = String.Format("unpack{0}.{1}.{2}", m, n, k);
                        int entries = 0;
                        using (ZipFile z2 = ZipFile.Read(zipFileToCreate))
                        {
                            foreach (ZipEntry e in z2)
                            {
                                var t2 = e.LastModified;
                                var x2 = t2.ToUniversalTime().ToString("u");
                                Assert.AreEqual<String>(x1, x2,
                                                        "cycle {0}.{1}.{2}: Unexpected LastModified value on ZipEntry.", m, n, k);
                                entries++;
                                // now verify that the LastMod time on the filesystem file is set correctly
                                e.Extract(unpackDir);
                                DateTime ActualFilesystemLastMod = File.GetLastWriteTime(Path.Combine(unpackDir, e.FileName));
                                ActualFilesystemLastMod = AdjustTime_Win32ToDotNet(ActualFilesystemLastMod);

                                //Assert.AreEqual<DateTime>(t, ActualFilesystemLastMod,
                                x2 = ActualFilesystemLastMod.ToUniversalTime().ToString("u");
                                Assert.AreEqual<String>(x1, x2,
                                                        "cycle {0}.{1}.{2}: Unexpected LastWriteTime on extracted filesystem file.", m, n, k);
                            }
                        }
                        Assert.AreEqual<int>(entries, filesToZip.Length, "Unexpected file count. Expected {0}, got {1}.",
                                             filesToZip.Length, entries);
                    }
                }
            }
        }


        [TestMethod]
        public void CreateAndExtract_VerifyAttributes()
        {

            try
            {
                string zipFileToCreate = "CreateAndExtract_VerifyAttributes.zip";
                string subdir = "A";
                Directory.CreateDirectory(subdir);

                //int fileCount = _rnd.Next(13) + 23;
                FileAttributes[] attributeCombos = {
                    FileAttributes.ReadOnly,
                    FileAttributes.ReadOnly | FileAttributes.System,
                    FileAttributes.ReadOnly | FileAttributes.System | FileAttributes.Hidden,
                    FileAttributes.ReadOnly | FileAttributes.System | FileAttributes.Hidden | FileAttributes.Archive,
                    FileAttributes.ReadOnly | FileAttributes.Hidden,
                    FileAttributes.ReadOnly | FileAttributes.Hidden| FileAttributes.Archive,
                    FileAttributes.ReadOnly | FileAttributes.Archive,
                    FileAttributes.System,
                    FileAttributes.System | FileAttributes.Hidden,
                    FileAttributes.System | FileAttributes.Hidden | FileAttributes.Archive,
                    FileAttributes.System | FileAttributes.Archive,
                    FileAttributes.Hidden,
                    FileAttributes.Hidden | FileAttributes.Archive,
                    FileAttributes.Archive,
                    FileAttributes.Normal,
                    FileAttributes.NotContentIndexed | FileAttributes.ReadOnly,
                    FileAttributes.NotContentIndexed | FileAttributes.System,
                    FileAttributes.NotContentIndexed | FileAttributes.Hidden,
                    FileAttributes.NotContentIndexed | FileAttributes.Archive,
                    FileAttributes.Temporary,
                    FileAttributes.Temporary | FileAttributes.Archive,
                };
                int fileCount = attributeCombos.Length;
                string[] filesToZip = new string[fileCount];
                TestContext.WriteLine("============\nCreating.");
                for (int i = 0; i < fileCount; i++)
                {
                    filesToZip[i] = Path.Combine(subdir, String.Format("file{0:D3}.bin", i));
                    TestUtilities.CreateAndFillFileBinary(filesToZip[i], _rnd.Next(10000) + 5000);
                    TestContext.WriteLine("Creating {0}    [{1}]", filesToZip[i], attributeCombos[i].ToString());
                    File.SetAttributes(filesToZip[i], attributeCombos[i]);
                }

                TestContext.WriteLine("============\nZipping.");
                using (ZipFile zip = new ZipFile())
                {
                    for (int i = 0; i < filesToZip.Length; i++)
                    {
                        // use the local filename (not fully qualified)
                        ZipEntry e = zip.AddFile(filesToZip[i], "");
                    }
                    zip.Save(zipFileToCreate);
                }

                int entries = 0;
                TestContext.WriteLine("============\nExtracting.");
                using (ZipFile z2 = ZipFile.Read(zipFileToCreate))
                {
                    foreach (ZipEntry e in z2)
                    {
                        TestContext.WriteLine("Extracting {0}", e.FileName);
                        Assert.AreEqual<FileAttributes>
                            (attributeCombos[entries],
                             e.Attributes,
                             "unexpected attribute {0} 0x{1:X4}",
                             e.FileName,
                             (int)e.Attributes);
                        entries++;
                        e.Extract("unpack");
                        // now verify that the attributes are set
                        // correctly in the filesystem
                        var attrs = File.GetAttributes(Path.Combine("unpack", e.FileName));
                        Assert.AreEqual<FileAttributes>(attrs, e.Attributes,
                                                        "Unexpected attributes on the extracted filesystem file {0}.", e.FileName);
                    }
                }
                Assert.AreEqual<int>(entries,
                                     filesToZip.Length,
                                     "Bad file count. Expected {0}, got {1}.",
                                     filesToZip.Length, entries);
            }
            catch (Exception ex1)
            {
                TestContext.WriteLine("Exception: " + ex1);
                throw;
            }
        }



        [TestMethod]
        public void CreateAndExtract_SetAndVerifyAttributes()
        {
            string zipFileToCreate = "CreateAndExtract_SetAndVerifyAttributes.zip";

            // Here, we build a list of combinations of FileAttributes
            // to try.  We cannot simply do an exhaustive combination
            // because (a) not all combinations are valid, and (b) if
            // you SetAttributes(file,Compressed) (also with Encrypted,
            // ReparsePoint) it does not "work."  So those attributes
            // must be excluded.
            FileAttributes[] attributeCombos = {
                FileAttributes.ReadOnly,
                FileAttributes.ReadOnly | FileAttributes.System,
                FileAttributes.ReadOnly | FileAttributes.System | FileAttributes.Hidden,
                FileAttributes.ReadOnly | FileAttributes.System | FileAttributes.Hidden | FileAttributes.Archive,
                FileAttributes.ReadOnly | FileAttributes.Hidden,
                FileAttributes.ReadOnly | FileAttributes.Hidden| FileAttributes.Archive,
                FileAttributes.ReadOnly | FileAttributes.Archive,
                FileAttributes.System,
                FileAttributes.System | FileAttributes.Hidden,
                FileAttributes.System | FileAttributes.Hidden | FileAttributes.Archive,
                FileAttributes.System | FileAttributes.Archive,
                FileAttributes.Hidden,
                FileAttributes.Hidden | FileAttributes.Archive,
                FileAttributes.Archive,
                FileAttributes.Normal,
                FileAttributes.NotContentIndexed | FileAttributes.ReadOnly,
                FileAttributes.NotContentIndexed | FileAttributes.System,
                FileAttributes.NotContentIndexed | FileAttributes.Hidden,
                FileAttributes.NotContentIndexed | FileAttributes.Archive,
                FileAttributes.Temporary,
                FileAttributes.Temporary | FileAttributes.Archive,
            };
            int fileCount = attributeCombos.Length;

            TestContext.WriteLine("============\nZipping.");
            using (ZipFile zip = new ZipFile())
            {
                for (int i = 0; i < fileCount; i++)
                {
                    // use the local filename (not fully qualified)
                    ZipEntry e = zip.AddEntry("file" + i.ToString(),
                                              "FileContent: This file has these attributes: " + attributeCombos[i].ToString());
                    TestContext.WriteLine("Adding {0}    [{1}]", e.FileName, attributeCombos[i].ToString());
                    e.Attributes = attributeCombos[i];
                }
                zip.Save(zipFileToCreate);
            }

            int entries = 0;
            TestContext.WriteLine("============\nExtracting.");
            using (ZipFile z2 = ZipFile.Read(zipFileToCreate))
            {
                foreach (ZipEntry e in z2)
                {
                    TestContext.WriteLine("Extracting {0}", e.FileName);
                    Assert.AreEqual<FileAttributes>
                        (attributeCombos[entries], e.Attributes,
                         "unexpected attributes value in the entry {0} 0x{1:X4}",
                         e.FileName,
                         (int)e.Attributes);
                    entries++;
                    e.Extract("unpack");

                    // now verify that the attributes are set correctly in the filesystem
                    var attrs = File.GetAttributes(Path.Combine("unpack", e.FileName));
                    Assert.AreEqual<FileAttributes>
                        (e.Attributes, attrs,
                         "Unexpected attributes on the extracted filesystem file {0}.",
                         e.FileName);
                }
            }
            Assert.AreEqual<int>(fileCount, entries, "Unexpected file count.");
        }


        [TestMethod]
        [Timeout(1000 * 240)]  // timeout in ms.  240s = 4 mins
        public void CreateZip_VerifyFileLastModified()
        {
            string zipFileToCreate = "CreateZip_VerifyFileLastModified.zip";
            string envTemp = Environment.GetEnvironmentVariable("TEMP");
            String[] candidateFileNames = Directory.GetFiles(envTemp);
            var checksums = new Dictionary<string, byte[]>();
            var timestamps = new Dictionary<string, DateTime>();
            var actualFilenames = new List<string>();
            var excludedFilenames = new List<string>();

            int maxFiles = _rnd.Next(candidateFileNames.Length / 2) + candidateFileNames.Length / 3;
            maxFiles = Math.Min(maxFiles, 145);
            //maxFiles = Math.Min(maxFiles, 15);
            TestContext.WriteLine("\n-----------------------------\r\n{1}: Finding files in '{0}'...",
                                  envTemp,
                                  DateTime.Now.ToString("HH:mm:ss"));
            do
            {
                string filename = null;
                bool foundOne = false;
                while (!foundOne)
                {
                    filename = candidateFileNames[_rnd.Next(candidateFileNames.Length)];
                    if (excludedFilenames.Contains(filename)) continue;
                    var fi = new FileInfo(filename);

                    if (Path.GetFileName(filename)[0] == '~'
                        || actualFilenames.Contains(filename)
                        || fi.Length > 10000000
                        || Path.GetFileName(filename) == "dd_BITS.log"
                        // There WERE some weird files on my system that cause this
                        // test to fail!  the GetLastWrite() method returns the
                        // "wrong" time - does not agree with what is shown in
                        // Explorer or in a cmd.exe dir output.  So I exclude those
                        // files here.  (This is no longer a problem?)

                        //|| filename.EndsWith(".cer")
                        //|| filename.EndsWith(".msrcincident")
                        //|| filename == "MSCERTS.ini"
                        )
                    {
                        excludedFilenames.Add(filename);
                    }
                    else
                    {
                        foundOne = true;
                    }
                }

                var key = Path.GetFileName(filename);

                // surround this in a try...catch so as to avoid grabbing a file that is open by someone else, or has disappeared
                try
                {
                    var lastWrite = File.GetLastWriteTime(filename);
                    var fi = new FileInfo(filename);

                    // Rounding to nearest even second was necessary when DotNetZip did
                    // not process NTFS times in the NTFS Extra field. Since v1.8.0.5,
                    // this is no longer the case.
                    //
                    // var tm = TestUtilities.RoundToEvenSecond(lastWrite);

                    var tm = lastWrite;
                    // hop out of the try block if the file is from TODAY.  (heuristic
                    // to avoid currently open files)
                    if ((tm.Year == DateTime.Now.Year) && (tm.Month == DateTime.Now.Month) && (tm.Day == DateTime.Now.Day))
                        throw new Exception();
                    var chk = TestUtilities.ComputeChecksum(filename);
                    checksums.Add(key, chk);
                    TestContext.WriteLine("  {4}:  {1}  {2}  {3,-9}  {0}",
                                          Path.GetFileName(filename),
                                          lastWrite.ToString("yyyy MMM dd HH:mm:ss"),
                                          tm.ToString("yyyy MMM dd HH:mm:ss"),
                                          fi.Length,
                                          DateTime.Now.ToString("HH:mm:ss"));
                    timestamps.Add(key, this.AdjustTime_Win32ToDotNet(tm));
                    actualFilenames.Add(filename);
                }
                catch
                {
                    excludedFilenames.Add(filename);
                }
            } while ((actualFilenames.Count < maxFiles) && (actualFilenames.Count < candidateFileNames.Length) &&
                     actualFilenames.Count + excludedFilenames.Count < candidateFileNames.Length);

            TestContext.WriteLine("{0}: Creating zip...", DateTime.Now.ToString("HH:mm:ss"));

            // create the zip file
            using (ZipFile zip = new ZipFile())
            {
                foreach (string s in actualFilenames)
                {
                    ZipEntry e = zip.AddFile(s, "");
                    e.Comment = File.GetLastWriteTime(s).ToString("yyyyMMMdd HH:mm:ss");
                }
                zip.Comment = "The files in this archive will be checked for LastMod timestamp and checksum.";
                TestContext.WriteLine("{0}: Saving zip....", DateTime.Now.ToString("HH:mm:ss"));
                zip.Save(zipFileToCreate);
            }

            TestContext.WriteLine("{0}: Unpacking zip....", DateTime.Now.ToString("HH:mm:ss"));

            // unpack the zip, and verify contents
            int entries = 0;
            using (ZipFile z2 = ZipFile.Read(zipFileToCreate))
            {
                foreach (ZipEntry e in z2)
                {
                    TestContext.WriteLine("{0}: Checking entry {1}....", DateTime.Now.ToString("HH:mm:ss"), e.FileName);
                    entries++;
                    // verify that the LastMod time on the filesystem file is set correctly
                    e.Extract("unpack");
                    string pathToExtractedFile = Path.Combine("unpack", e.FileName);
                    DateTime actualFilesystemLastMod = AdjustTime_Win32ToDotNet(File.GetLastWriteTime(pathToExtractedFile));
                    TimeSpan delta = timestamps[e.FileName] - actualFilesystemLastMod;

                    // get the delta as an absolute value:
                    if (delta < new TimeSpan(0, 0, 0))
                        delta = new TimeSpan(0, 0, 0) - delta;

                    TestContext.WriteLine("time delta: {0}", delta.ToString());
                    // The time delta can be at most, 1 second.
                    Assert.IsTrue(delta < new TimeSpan(0, 0, 1),
                                  "Unexpected LastMod timestamp on extracted filesystem file ({0}) expected({1}) actual({2})  delta({3}).",
                                  pathToExtractedFile,
                                  timestamps[e.FileName].ToString("F"),
                                  actualFilesystemLastMod.ToString("F"),
                                  delta.ToString()
                                  );

                    // verify the checksum of the file is correct
                    string expectedCheckString = TestUtilities.CheckSumToString(checksums[e.FileName]);
                    string actualCheckString = TestUtilities.GetCheckSumString(pathToExtractedFile);
                    Assert.AreEqual<String>
                        (expectedCheckString,
                         actualCheckString,
                         "Unexpected checksum on extracted filesystem file ({0}).",
                         pathToExtractedFile);
                }
            }
            Assert.AreEqual<int>(entries, actualFilenames.Count, "Unexpected file count.");
        }



        private DateTime AdjustTime_Win32ToDotNet(DateTime time)
        {
            // If I read a time from a file with GetLastWriteTime() (etc), I need
            // to adjust it for display in the .NET environment.
            if (time.Kind == DateTimeKind.Utc) return time;
            DateTime adjusted = time;
            if (DateTime.Now.IsDaylightSavingTime() && !time.IsDaylightSavingTime())
                adjusted = time + new System.TimeSpan(1, 0, 0);

            else if (!DateTime.Now.IsDaylightSavingTime() && time.IsDaylightSavingTime())
                adjusted = time - new System.TimeSpan(1, 0, 0);

            return adjusted;
        }



        [TestMethod]
        public void CreateZip_AddDirectory_NoFilesInRoot()
        {
            string zipFileToCreate = "CreateZip_AddDirectory_NoFilesInRoot.zip";
            string zipThis = "ZipThis";
            Directory.CreateDirectory(zipThis);

            int i, j;
            int entries = 0;

            int subdirCount = _rnd.Next(4) + 4;
            for (i = 0; i < subdirCount; i++)
            {
                string subdir = Path.Combine(zipThis, "DirectoryToZip.test." + i);
                Directory.CreateDirectory(subdir);

                int fileCount = _rnd.Next(3) + 3;
                for (j = 0; j < fileCount; j++)
                {
                    String file = Path.Combine(subdir, "file" + j);
                    TestUtilities.CreateAndFillFile(file, _rnd.Next(1000) + 1500);
                    entries++;
                }
            }

            using (ZipFile zip = new ZipFile())
            {
                zip.AddDirectory(zipThis);
                zip.Save(zipFileToCreate);
            }
            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entries,
                                 "The Zip file has the wrong number of entries.");
        }


        [TestMethod]
        public void CreateZip_AddDirectory_OneCharOverrideName()
        {
            int entries = 0;
            String filename = null;

            // set the name of the zip file to create
            string zipFileToCreate = "CreateZip_AddDirectory_OneCharOverrideName.zip";
            String commentOnArchive = "BasicTests::CreateZip_AddDirectory_OneCharOverrideName(): This archive override the name of a directory with a one-char name.";

            string subdir = "A";
            Directory.CreateDirectory(subdir);

            int numFilesToCreate = _rnd.Next(23) + 14;
            var checksums = new Dictionary<string, string>();
            for (int j = 0; j < numFilesToCreate; j++)
            {
                filename = Path.Combine(subdir, String.Format("file{0:D3}.txt", j));
                TestUtilities.CreateAndFillFileText(filename, _rnd.Next(12000) + 5000);
                var chk = TestUtilities.ComputeChecksum(filename);

                var relativePath = Path.Combine(Path.GetFileName(subdir), Path.GetFileName(filename));
                //var key = Path.Combine("A", filename);
                var key = TestUtilities.TrimVolumeAndSwapSlashes(relativePath);
                checksums.Add(key, TestUtilities.CheckSumToString(chk));

                entries++;
            }

            using (ZipFile zip1 = new ZipFile())
            {
                zip1.AddDirectory(subdir, Path.GetFileName(subdir));
                zip1.Comment = commentOnArchive;
                zip1.Save(zipFileToCreate);
            }

            Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entries);

            // validate all the checksums
            using (ZipFile zip2 = ZipFile.Read(zipFileToCreate))
            {
                foreach (ZipEntry e in zip2)
                {
                    e.Extract("unpack");
                    if (checksums.ContainsKey(e.FileName))
                    {
                        string pathToExtractedFile = Path.Combine("unpack", e.FileName);

                        // verify the checksum of the file is correct
                        string expectedCheckString = checksums[e.FileName];
                        string actualCheckString = TestUtilities.GetCheckSumString(pathToExtractedFile);
                        Assert.AreEqual<String>
                            (expectedCheckString,
                             actualCheckString,
                             "Unexpected checksum on extracted filesystem file ({0}).",
                             pathToExtractedFile);
                    }
                }
            }

        }



        [TestMethod]
        public void CreateZip_CompressionLevelZero_AllEntries()
        {
            string zipFileToCreate = "CompressionLevelZero.zip";
            String commentOnArchive = "BasicTests::CompressionLevelZero(): This archive override the name of a directory with a one-char name.";
            int entriesAdded = 0;
            String filename = null;
            string subdir = "A";
            Directory.CreateDirectory(subdir);

            int fileCount = _rnd.Next(10) + 10;
            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++;
            }

            using (ZipFile zip = new ZipFile())
            {
                zip.CompressionLevel = Ionic.Zlib.CompressionLevel.None;
                zip.AddDirectory(subdir, Path.GetFileName(subdir));
                zip.Comment = commentOnArchive;
                zip.Save(zipFileToCreate);
            }

            int entriesFound = 0;
            using (ZipFile zip = ZipFile.Read(zipFileToCreate))
            {
                foreach (ZipEntry e in zip)
                {
                    if (!e.IsDirectory) entriesFound++;
                    Assert.AreEqual<short>(0, (short)e.CompressionMethod,
                                           "compression method");
                }
            }
            Assert.AreEqual<int>(entriesAdded, entriesFound,
                                 "unexpected number of entries.");
            BasicVerifyZip(zipFileToCreate);
        }



        [TestMethod]
        public void CreateZip_ForceNoCompressionSomeEntries()
        {
            string zipFileToCreate = "ForceNoCompression.zip";
            String filename = null;
            string subdir = "A";
            Directory.CreateDirectory(subdir);
            int fileCount = _rnd.Next(13) + 13;
            for (int j = 0; j < fileCount; j++)
            {
                filename = Path.Combine(subdir, String.Format("{0}-file{1:D3}.txt", (_rnd.Next(2) == 0) ? "C":"U", j));
                TestUtilities.CreateAndFillFileText(filename, _rnd.Next(34000) + 5000);
            }

            using (ZipFile zip = new ZipFile())
            {
                String[] filenames = Directory.GetFiles("A");
                foreach (String f in filenames)
                {
                    ZipEntry e = zip.AddFile(f, "");
                    if (e.FileName.StartsWith("U"))
                        e.CompressionMethod = 0x0;
                }
                zip.Comment = "Some of these files do not use compression.";
                zip.Save(zipFileToCreate);
            }

            int entriesFound = 0;
            using (ZipFile zip = ZipFile.Read(zipFileToCreate))
            {
                foreach (ZipEntry e in zip)
                {
                    if (!e.IsDirectory) entriesFound++;
                    Assert.AreEqual<Int32>((e.FileName.StartsWith("U"))?0x00:0x08,
                                           (Int32)e.CompressionMethod,
                                           "Unexpected compression method on text file ({0}).", e.FileName);
                }
            }
            Assert.AreEqual<int>(fileCount, entriesFound, "The created Zip file has an unexpected number of entries.");

            BasicVerifyZip(zipFileToCreate);
        }



        [TestMethod]
        public void AddFile_CompressionMethod_None_wi9208()
        {
            string zipFileToCreate = "AddFile_CompressionMethod_None_wi9208.zip";
            string subdir = "A";
            Directory.CreateDirectory(subdir);
            using (ZipFile zip = new ZipFile())
            {
                string filename = Path.Combine(subdir, String.Format("FileToBeAdded-{0:D2}.txt", _rnd.Next(1000)));
                TestUtilities.CreateAndFillFileText(filename, _rnd.Next(34000) + 5000);
                var e = zip.AddFile(filename,"zipped");
                e.CompressionMethod = CompressionMethod.None;
                zip.Save(zipFileToCreate);
            }

            TestContext.WriteLine("File zipped!...");
            TestContext.WriteLine("Reading...");

            using (ZipFile zip = ZipFile.Read(zipFileToCreate))
            {
                foreach (var e in  zip)
                {
                    Assert.AreEqual<String>("None", e.CompressionMethod.ToString());
                }
            }
            BasicVerifyZip(zipFileToCreate);
        }



        [TestMethod]
        public void GetInfo()
        {
            TestContext.WriteLine("GetInfo");
            string zipFileToCreate = "GetInfo.zip";
            String filename = null;
            int n;
            string subdir = Path.Combine(TopLevelDir,
                                         TestUtilities.GenerateRandomAsciiString(9));
            Directory.CreateDirectory(subdir);

            int fileCount = _rnd.Next(27) + 23;
            TestContext.WriteLine("Creating {0} files", fileCount);
            for (int j = 0; j < fileCount; j++)
            {
                filename = Path.Combine(subdir, String.Format("file{0:D3}.txt", j));
                if (_rnd.Next(7)!=0)
                    TestUtilities.CreateAndFillFileText(filename, _rnd.Next(34000) + 5000);
                else
                {
                    // create an empty file
                    using (var fs = File.Create(filename)) { }
                }
            }

            TestContext.WriteLine("Creating a zip file");
            using (ZipFile zip = new ZipFile())
            {
                zip.Password = TestUtilities.GenerateRandomPassword(11);
                var filenames = Directory.GetFiles(subdir);
                foreach (String f in filenames)
                {
                    ZipEntry e = zip.AddFile(f, "");
                    if (_rnd.Next(3)==0)
                        e.CompressionMethod = 0x0;
                    n = _rnd.Next(crypto.Length);
                    e.Encryption = crypto[n];
                }
                zip.Save(zipFileToCreate);
            }

            TestContext.WriteLine("Calling ZipFile::Info_get");
            using (ZipFile zip = ZipFile.Read(zipFileToCreate))
            {
                string info = zip.Info;
                TestContext.WriteLine("Info: (len({0}))", info.Length);
                foreach (var line in info.Split('\n'))
                    TestContext.WriteLine(line);

                Assert.IsTrue(info.Length > 300,
                              "Suspect info string (length({0}))",
                              info.Length);
            }
        }



        [TestMethod]
        public void Create_WithChangeDirectory()
        {
            string zipFileToCreate = "Create_WithChangeDirectory.zip";
            String filename = "Testfile.txt";
            TestUtilities.CreateAndFillFileText(filename, _rnd.Next(34000) + 5000);

            string cwd = Directory.GetCurrentDirectory();
            using (var zip = new ZipFile())
            {
                zip.AddFile(filename, "");
                Directory.SetCurrentDirectory("\\");
                zip.AddFile("dev\\codeplex\\DotNetZip\\Zip Tests\\BasicTests.cs", "");
                Directory.SetCurrentDirectory(cwd);
                zip.Save(zipFileToCreate);
            }
        }




        private void VerifyEntries(string zipFile,
                                   Variance variance,
                                   int[] values,
                                   EncryptionAlgorithm[] a,
                                   int stage,
                                   int compFlavor,
                                   int encryptionFlavor)
        {
            using (var zip = ZipFile.Read(zipFile))
            {
                foreach (ZipEntry e in zip)
                {
                    var compCheck = false;
                    if (variance == Variance.Method)
                    {
                        compCheck = (e.CompressionMethod == (CompressionMethod)values[stage]);
                    }
                    else
                    {
                        // Variance.Level
                        CompressionMethod expectedMethod =
                            ((Ionic.Zlib.CompressionLevel)values[stage] == Ionic.Zlib.CompressionLevel.None)
                            ? CompressionMethod.None
                            : CompressionMethod.Deflate;
                        compCheck = (e.CompressionMethod == expectedMethod);
                    }

                    Assert.IsTrue(compCheck,
                                  "Unexpected compression method ({0}) on entry ({1}) variance({2}) flavor({3},{4}) stage({5})",
                                  e.CompressionMethod,
                                  e.FileName,
                                  variance,
                                  compFlavor, encryptionFlavor,
                                  stage
                                  );

                    var cryptoCheck = (e.Encryption == a[stage]);

                    Assert.IsTrue(cryptoCheck,
                                  "Unexpected encryption ({0}) on entry ({1}) variance({2}) flavor({3},{4}) stage({5})",
                                  e.Encryption,
                                  e.FileName,
                                  variance,
                                  compFlavor,
                                  encryptionFlavor,
                                  stage
                                  );
                }
            }
        }



        private void QuickCreateZipAndChecksums(string zipFile,
                                                Variance variance,
                                                object compressionMethodOrLevel,
                                                EncryptionAlgorithm encryption,
                                                string password,
                                                out string[] files,
                                                out Dictionary<string, byte[]> checksums
                                                )
        {
            string srcDir = TestUtilities.GetTestSrcDir(CurrentDir);
            files = Directory.GetFiles(srcDir, "*.cs", SearchOption.TopDirectoryOnly);
            checksums = new Dictionary<string, byte[]>();
            foreach (string f in  files)
            {
                var chk = TestUtilities.ComputeChecksum(f);
                var key = Path.GetFileName(f);
                checksums.Add(key, chk);
            }

            using (var zip = new ZipFile())
            {
                if (variance == Variance.Level)
                {
                    zip.CompressionLevel= (Ionic.Zlib.CompressionLevel) compressionMethodOrLevel;
                }
                else
                {
                    if ((Ionic.Zip.CompressionMethod)compressionMethodOrLevel == CompressionMethod.None)
                        zip.CompressionLevel = Ionic.Zlib.CompressionLevel.None;
                }

                if (password != null)
                {
                    zip.Password = password;
                    zip.Encryption = encryption;
                }
                zip.AddFiles(files, "");
                zip.Save(zipFile);
            }

            int count = TestUtilities.CountEntries(zipFile);
            Assert.IsTrue(count > 5,
                          "Unexpected number of entries ({0}) in the zip file.", count);
        }

        enum Variance
        {
            Method = 0 ,
            Level = 1
        }


        private string GeneratePassword()
        {
            return TestUtilities.GenerateRandomPassword();
            //return TestUtilities.GenerateRandomAsciiString(9);
            //return "Alphabet";
        }

        private void _Internal_Resave(string zipFile,
                                      Variance variance,
                                      int[] values,
                                      EncryptionAlgorithm[] cryptos,
                                      int compFlavor,
                                      int encryptionFlavor
                                      )
        {
            // Create a zip file, then re-save it with changes in compression methods,
            // compression levels, and/or encryption.  The methods/levels, cryptos are
            // for original and re-saved values. This tests whether we can update a zip
            // entry with changes in those properties.

            string[] passwords = new string[2];
            passwords[0]= (cryptos[0]==EncryptionAlgorithm.None) ? null : GeneratePassword();
            passwords[1]= passwords[0] ?? ((cryptos[1]==EncryptionAlgorithm.None) ? null : GeneratePassword());

            //TestContext.WriteLine("  crypto: '{0}'  '{1}'", crypto[0]??"-NONE-", passwords[1]??"-NONE-");
            TestContext.WriteLine("  crypto: '{0}'  '{1}'", cryptos[0], cryptos[1]);


            // first, create a zip file
            string[] filesToZip;
            Dictionary<string, byte[]> checksums;
            QuickCreateZipAndChecksums(zipFile, variance, values[0], cryptos[0], passwords[0], out filesToZip, out checksums);


            // check that the zip was constructed as expected
            VerifyEntries(zipFile, variance, values, cryptos, 0, compFlavor, encryptionFlavor);


            // modify some properties (CompressionLevel, CompressionMethod, and/or Encryption) on each entry
            using (var zip = ZipFile.Read(zipFile))
            {
                zip.Password = passwords[1];
                foreach (ZipEntry e in zip)
                {
                    if (variance == Variance.Method)
                        e.CompressionMethod = (CompressionMethod)values[1];
                    else
                        e.CompressionLevel = (Ionic.Zlib.CompressionLevel)values[1];

                    e.Encryption = cryptos[1];
                }
                zip.Save();
            }


            // Check that the zip was modified as expected
            VerifyEntries(zipFile, variance, values, cryptos, 1, compFlavor, encryptionFlavor);

            // now extract the items and verify checksums
            string extractDir = "ex";
            int c=0;
            while (Directory.Exists(extractDir + c)) c++;
            extractDir += c;

            // extract
            using (var zip = ZipFile.Read(zipFile))
            {
                zip.Password = passwords[1];
                zip.ExtractAll(extractDir);
            }

            VerifyChecksums(extractDir, filesToZip, checksums);
        }





        EncryptionAlgorithm[][] CryptoPairs = {
            new EncryptionAlgorithm[] {EncryptionAlgorithm.None, EncryptionAlgorithm.None},
            new EncryptionAlgorithm[] {EncryptionAlgorithm.None, EncryptionAlgorithm.WinZipAes128},
            new EncryptionAlgorithm[] {EncryptionAlgorithm.WinZipAes128, EncryptionAlgorithm.None},
            new EncryptionAlgorithm[] {EncryptionAlgorithm.WinZipAes128, EncryptionAlgorithm.WinZipAes128},
            new EncryptionAlgorithm[] {EncryptionAlgorithm.None, EncryptionAlgorithm.PkzipWeak},
            new EncryptionAlgorithm[] {EncryptionAlgorithm.PkzipWeak, EncryptionAlgorithm.None},
            new EncryptionAlgorithm[] {EncryptionAlgorithm.WinZipAes128, EncryptionAlgorithm.PkzipWeak},
            new EncryptionAlgorithm[] {EncryptionAlgorithm.PkzipWeak, EncryptionAlgorithm.WinZipAes128}
        };

        int[][][] VariancePairs = {
            new int[][] {
                new int[] {(int)CompressionMethod.Deflate, (int)CompressionMethod.Deflate},
                new int[] {(int)CompressionMethod.Deflate, (int)CompressionMethod.None},
                new int[] {(int)CompressionMethod.None, (int)CompressionMethod.Deflate},
                new int[] {(int)CompressionMethod.None, (int)CompressionMethod.None}
            },
            new int[][] {
                new int[] {(int)Ionic.Zlib.CompressionLevel.Default, (int)Ionic.Zlib.CompressionLevel.Default},
                new int[] {(int)Ionic.Zlib.CompressionLevel.Default, (int)Ionic.Zlib.CompressionLevel.None},
                new int[] {(int)Ionic.Zlib.CompressionLevel.None, (int)Ionic.Zlib.CompressionLevel.Default},
                new int[] {(int)Ionic.Zlib.CompressionLevel.None, (int)Ionic.Zlib.CompressionLevel.None}
            }
        };

        private void _Internal_Resave(Variance variance, int compFlavor, int encryptionFlavor)
        {
            // Check that re-saving a zip, after modifying properties on
            // each entry, actually does what we want.
            if (encryptionFlavor == 0)
                TestContext.WriteLine("Resave workdir: {0}", TopLevelDir);

            string rootname = String.Format("Resave_Compression{0}_{1}_Encryption_{2}.zip",
                                            variance, compFlavor, encryptionFlavor);

            string zipFileToCreate = Path.Combine(TopLevelDir, rootname);
            int[] values = VariancePairs[(int)variance][compFlavor];

            TestContext.WriteLine("Resave {0} {1} {2} file({3})", variance, compFlavor, encryptionFlavor, Path.GetFileName(zipFileToCreate));

            _Internal_Resave(zipFileToCreate, variance, values, CryptoPairs[encryptionFlavor], compFlavor, encryptionFlavor);
        }


        [TestMethod]
        public void Resave_CompressionMethod_0()
        {
            for (int i=0; i<8;  i++)
            {
                _Internal_Resave(Variance.Method, 0, i);
            }
        }


        [TestMethod]
        public void Resave_CompressionMethod_1()
        {
            for (int i=0; i<8;  i++)
            {
                if (i!=3)
                    _Internal_Resave(Variance.Method, 1, i);
            }
        }

        [TestMethod]
        public void Resave_CompressionMethod_2()
        {
            for (int i=0; i<8;  i++)
            {
                _Internal_Resave(Variance.Method, 2, i);
            }
        }

        [TestMethod]
        public void Resave_CompressionMethod_3()
        {
            for (int i=0; i<8;  i++)
            {
                _Internal_Resave(Variance.Method, 3, i);
            }
        }


        [TestMethod]
        public void Resave_CompressionLevel_0()
        {
            for (int i=0; i<8;  i++)
            {
                _Internal_Resave(Variance.Level, 0, i);
            }
        }


        [TestMethod]
        public void Resave_CompressionLevel_1()
        {
            for (int i=0; i<8;  i++)
            {
                if (i!=3)
                    _Internal_Resave(Variance.Level, 1, i);
            }
        }

        [TestMethod]
        public void Resave_CompressionLevel_2()
        {
            for (int i=0; i<8;  i++)
            {
                _Internal_Resave(Variance.Level, 2, i);
            }
        }

        [TestMethod]
        public void Resave_CompressionLevel_3()
        {
            for (int i=0; i<8;  i++)
            {
                _Internal_Resave(Variance.Level, 3, i);
            }
        }

    }
}