Merge Dtf

4 files changed, 924 insertions, 0 deletions

diff --git a/src/dtf/WixToolsetTests.Dtf.Compression/CompressionTestUtil.cs b/src/dtf/WixToolsetTests.Dtf.Compression/CompressionTestUtil.cs
new file mode 100644
index 00000000..e7a5373d
--- /dev/null
+++ b/src/dtf/WixToolsetTests.Dtf.Compression/CompressionTestUtil.cs
@@ -0,0 +1,649 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+using System;
+using System.IO;
+using System.Text;
+using System.Collections.Generic;
+using System.Security.Cryptography;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using WixToolset.Dtf.Compression;
+
+namespace WixToolset.Dtf.Test
+{
+    public class CompressionTestUtil
+    {
+        private static MD5 md5 = new MD5CryptoServiceProvider();
+
+        private string progressTextFile;
+
+        public CompressionTestUtil(string progressTextFile)
+        {
+            this.progressTextFile = progressTextFile;
+        }
+
+        public static IList<int[]> ExpectedProgress
+        {
+            get { return CompressionTestUtil.expectedProgress; }
+            set { CompressionTestUtil.expectedProgress = value; }
+        }
+        private static IList<int[]> expectedProgress;
+
+        public void PrintArchiveProgress(object source, ArchiveProgressEventArgs e)
+        {
+            switch (e.ProgressType)
+            {
+                case ArchiveProgressType.StartFile:
+                    {
+                        Console.WriteLine("StartFile: {0}", e.CurrentFileName);
+                    } break;
+                case ArchiveProgressType.FinishFile:
+                    {
+                        Console.WriteLine("FinishFile: {0}", e.CurrentFileName);
+                    } break;
+                case ArchiveProgressType.StartArchive:
+                    {
+                        Console.WriteLine("StartArchive: {0} : {1}", e.CurrentArchiveNumber, e.CurrentArchiveName);
+                    } break;
+                case ArchiveProgressType.FinishArchive:
+                    {
+                        Console.WriteLine("FinishArchive: {0} : {1}", e.CurrentArchiveNumber, e.CurrentArchiveName);
+                    } break;
+            }
+
+            File.AppendAllText(this.progressTextFile, e.ToString().Replace("\n", Environment.NewLine));
+
+            if (CompressionTestUtil.expectedProgress != null &&
+                e.ProgressType != ArchiveProgressType.PartialFile &&
+                e.ProgressType != ArchiveProgressType.PartialArchive)
+            {
+                Assert.AreNotEqual<int>(0, CompressionTestUtil.expectedProgress.Count);
+                int[] expected = CompressionTestUtil.expectedProgress[0];
+                CompressionTestUtil.expectedProgress.RemoveAt(0);
+                Assert.AreEqual<ArchiveProgressType>((ArchiveProgressType) expected[0], e.ProgressType, "Checking ProgressType.");
+                Assert.AreEqual<int>(expected[1], e.CurrentFileNumber, "Checking CurrentFileNumber.");
+                Assert.AreEqual<int>(expected[2], e.TotalFiles, "Checking TotalFiles.");
+                Assert.AreEqual<int>(expected[4], e.CurrentArchiveNumber, "Checking CurrentArchiveNumber.");
+                Assert.AreEqual<int>(expected[5], e.TotalArchives, "Checking TotalArchives.");
+            }
+        }
+
+        public static bool CompareDirectories(string dirA, string dirB)
+        {
+            bool difference = false;
+            Console.WriteLine("Comparing directories {0}, {1}", dirA, dirB);
+
+            string[] filesA = Directory.GetFiles(dirA);
+            string[] filesB = Directory.GetFiles(dirB);
+            for (int iA = 0; iA < filesA.Length; iA++)
+            {
+                filesA[iA] = Path.GetFileName(filesA[iA]);
+            }
+            for (int iB = 0; iB < filesB.Length; iB++)
+            {
+                filesB[iB] = Path.GetFileName(filesB[iB]);
+            }
+            Array.Sort(filesA);
+            Array.Sort(filesB);
+
+            for (int iA = 0, iB = 0; iA < filesA.Length || iB < filesB.Length; )
+            {
+                int comp;
+                if (iA == filesA.Length)
+                {
+                    comp = 1;
+                }
+                else if (iB == filesB.Length)
+                {
+                    comp = -1;
+                }
+                else
+                {
+                    comp = String.Compare(filesA[iA], filesB[iB]);
+                }
+                if (comp < 0)
+                {
+                    Console.WriteLine("< " + filesA[iA]);
+                    difference = true;
+                    iA++;
+                }
+                else if (comp > 0)
+                {
+                    Console.WriteLine("> " + filesB[iB]);
+                    difference = true;
+                    iB++;
+                }
+                else
+                {
+                    string fileA = Path.Combine(dirA, filesA[iA]);
+                    string fileB = Path.Combine(dirB, filesB[iB]);
+
+                    byte[] hashA;
+                    byte[] hashB;
+
+                    lock (CompressionTestUtil.md5)
+                    {
+                        using (Stream fileAStream = File.OpenRead(fileA))
+                        {
+                            hashA = CompressionTestUtil.md5.ComputeHash(fileAStream);
+                        }
+                        using (Stream fileBStream = File.OpenRead(fileB))
+                        {
+                            hashB = CompressionTestUtil.md5.ComputeHash(fileBStream);
+                        }
+                    }
+
+                    for (int i = 0; i < hashA.Length; i++)
+                    {
+                        if (hashA[i] != hashB[i])
+                        {
+                            Console.WriteLine("~  " + filesA[iA]);
+                            difference = true;
+                            break;
+                        }
+                    }
+
+                    iA++;
+                    iB++;
+                }
+            }
+
+            string[] dirsA = Directory.GetDirectories(dirA);
+            string[] dirsB = Directory.GetDirectories(dirB);
+            for (int iA = 0; iA < dirsA.Length; iA++)
+            {
+                dirsA[iA] = Path.GetFileName(dirsA[iA]);
+            }
+            for (int iB = 0; iB < dirsB.Length; iB++)
+            {
+                dirsB[iB] = Path.GetFileName(dirsB[iB]);
+            }
+            Array.Sort(dirsA);
+            Array.Sort(dirsB);
+
+            for (int iA = 0, iB = 0; iA < dirsA.Length || iB < dirsB.Length; )
+            {
+                int comp;
+                if (iA == dirsA.Length)
+                {
+                    comp = 1;
+                }
+                else if (iB == dirsB.Length)
+                {
+                    comp = -1;
+                }
+                else
+                {
+                    comp = String.Compare(dirsA[iA], dirsB[iB]);
+                }
+                if (comp < 0)
+                {
+                    Console.WriteLine("< {0}\\", dirsA[iA]);
+                    difference = true;
+                    iA++;
+                }
+                else if (comp > 0)
+                {
+                    Console.WriteLine("> {1}\\", dirsB[iB]);
+                    difference = true;
+                    iB++;
+                }
+                else
+                {
+                    string subDirA = Path.Combine(dirA, dirsA[iA]);
+                    string subDirB = Path.Combine(dirB, dirsB[iB]);
+                    if (!CompressionTestUtil.CompareDirectories(subDirA, subDirB))
+                    {
+                        difference = true;
+                    }
+                    iA++;
+                    iB++;
+                }
+            }
+
+            return !difference;
+        }
+
+
+        public static void GenerateRandomFile(string path, int seed, long size)
+        {
+            Console.WriteLine("Generating random file {0} (seed={1}, size={2})",
+                path, seed, size);
+            Random random = new Random(seed);
+            bool easy = random.Next(2) == 1;
+            int chunk = 1024 * random.Next(1, 100);
+            using (TextWriter tw = new StreamWriter(
+                File.Create(path, 4096), Encoding.ASCII))
+            {
+                for (long count = 0; count < size; count++)
+                {
+                    char c = (char) (easy ? random.Next('a', 'b' + 1)
+                        : random.Next(32, 127));
+                    tw.Write(c);
+                    if (--chunk == 0)
+                    {
+                        chunk = 1024 * random.Next(1, 101);
+                        easy = random.Next(2) == 1;
+                    }
+                }
+            }
+        }
+
+        public static void TestArchiveInfoNullParams(
+            ArchiveInfo archiveInfo,
+            string dirA,
+            string dirB,
+            string[] files)
+        {
+            Exception caughtEx = null;
+            try
+            {
+                archiveInfo.PackFiles(null, null, files);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                archiveInfo.PackFiles(null, files, new string[] { });
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentOutOfRangeException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                archiveInfo.PackFileSet(dirA, null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                archiveInfo.PackFiles(null, files, files);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(FileNotFoundException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                archiveInfo.PackFiles(dirA, null, files);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                archiveInfo.PackFiles(dirA, files, null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsNull(caughtEx, "Caught exception: " + caughtEx);
+
+            caughtEx = null;
+            try
+            {
+                archiveInfo.CopyTo(null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                archiveInfo.CopyTo(null, true);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                archiveInfo.MoveTo(null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                archiveInfo.GetFiles(null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                archiveInfo.UnpackFile(null, "test.txt");
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                archiveInfo.UnpackFile("test.txt", null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                archiveInfo.UnpackFiles(null, dirB, files);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                archiveInfo.UnpackFiles(files, null, null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                archiveInfo.UnpackFiles(files, null, files);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsNull(caughtEx, "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                archiveInfo.UnpackFiles(files, dirB, null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsNull(caughtEx, "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                archiveInfo.UnpackFiles(files, dirB, new string[] { });
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentOutOfRangeException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                archiveInfo.UnpackFileSet(null, dirB);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+        }
+
+        public static void TestCompressionEngineNullParams(
+            CompressionEngine engine,
+            ArchiveFileStreamContext streamContext,
+            string[] testFiles)
+        {
+            Exception caughtEx;
+
+            Console.WriteLine("Testing null streamContext.");
+            caughtEx = null;
+            try
+            {
+                engine.Pack(null, testFiles);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                engine.Pack(null, testFiles, 0);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+
+            Console.WriteLine("Testing null files.");
+            caughtEx = null;
+            try
+            {
+                engine.Pack(streamContext, null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+
+            Console.WriteLine("Testing null files.");
+            caughtEx = null;
+            try
+            {
+                engine.Pack(streamContext, null, 0);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+
+
+            Console.WriteLine("Testing null stream.");
+            caughtEx = null;
+            try
+            {
+                engine.IsArchive(null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                engine.FindArchiveOffset(null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                engine.GetFiles(null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                engine.GetFileInfo(null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                engine.Unpack(null, "testUnpack.txt");
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            Console.WriteLine("Testing null streamContext.");
+            caughtEx = null;
+            try
+            {
+                engine.GetFiles(null, null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                engine.GetFileInfo(null, null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+            caughtEx = null;
+            try
+            {
+                engine.Unpack((IUnpackStreamContext) null, null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(ArgumentNullException), "Caught exception: " + caughtEx);
+        }
+
+        public static void TestBadPackStreamContexts(
+            CompressionEngine engine, string archiveName, string[] testFiles)
+        {
+            Exception caughtEx;
+
+            Console.WriteLine("Testing streamContext that returns null from GetName.");
+            caughtEx = null;
+            try
+            {
+                engine.Pack(
+                    new MisbehavingStreamContext(archiveName, null, null, false, false, true, true, true, true),
+                    testFiles);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsTrue(caughtEx is FileNotFoundException, "Caught exception: " + caughtEx);
+            Console.WriteLine("Testing streamContext that returns null from OpenArchive.");
+            caughtEx = null;
+            try
+            {
+                engine.Pack(
+                    new MisbehavingStreamContext(archiveName, null, null, false, true, false, true, true, true),
+                    testFiles);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsTrue(caughtEx is FileNotFoundException, "Caught exception: " + caughtEx);
+            Console.WriteLine("Testing streamContext that returns null from OpenFile.");
+            caughtEx = null;
+            try
+            {
+                engine.Pack(
+                    new MisbehavingStreamContext(archiveName, null, null, false, true, true, true, false, true),
+                    testFiles);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsNull(caughtEx, "Caught exception: " + caughtEx);
+            Console.WriteLine("Testing streamContext that throws on GetName.");
+            caughtEx = null;
+            try
+            {
+                engine.Pack(
+                    new MisbehavingStreamContext(archiveName, null, null, true, false, true, true, true, true),
+                    testFiles);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsTrue(caughtEx != null && caughtEx.Message == MisbehavingStreamContext.EXCEPTION, "Caught exception: " + caughtEx);
+            Console.WriteLine("Testing streamContext that throws on OpenArchive.");
+            caughtEx = null;
+            try
+            {
+                engine.Pack(
+                    new MisbehavingStreamContext(archiveName, null, null, true, true, false, true, true, true),
+                    testFiles);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsTrue(caughtEx != null && caughtEx.Message == MisbehavingStreamContext.EXCEPTION, "Caught exception: " + caughtEx);
+            Console.WriteLine("Testing streamContext that throws on CloseArchive.");
+            caughtEx = null;
+            try
+            {
+                engine.Pack(
+                    new MisbehavingStreamContext(archiveName, null, null, true, true, true, false, true, true),
+                    testFiles);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsTrue(caughtEx != null && caughtEx.Message == MisbehavingStreamContext.EXCEPTION, "Caught exception: " + caughtEx);
+            Console.WriteLine("Testing streamContext that throws on OpenFile.");
+            caughtEx = null;
+            try
+            {
+                engine.Pack(
+                    new MisbehavingStreamContext(archiveName, null, null, true, true, true, true, false, true),
+                    testFiles);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsTrue(caughtEx != null && caughtEx.Message == MisbehavingStreamContext.EXCEPTION, "Caught exception: " + caughtEx);
+            Console.WriteLine("Testing streamContext that throws on CloseFile.");
+            caughtEx = null;
+            try
+            {
+                engine.Pack(
+                    new MisbehavingStreamContext(archiveName, null, null, true, true, true, true, true, false),
+                    testFiles);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsTrue(caughtEx != null && caughtEx.Message == MisbehavingStreamContext.EXCEPTION, "Caught exception: " + caughtEx);
+        }
+
+        public static void TestBadUnpackStreamContexts(
+            CompressionEngine engine, string archiveName)
+        {
+            Exception caughtEx;
+
+            Console.WriteLine("Testing streamContext that returns null from OpenArchive.");
+            caughtEx = null;
+            try
+            {
+                engine.Unpack(new MisbehavingStreamContext(archiveName, null, null, false, true, false, true, true, true), null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsInstanceOfType(caughtEx, typeof(FileNotFoundException), "Caught exception: " + caughtEx);
+            Console.WriteLine("Testing streamContext that returns null from OpenFile.");
+            caughtEx = null;
+            try
+            {
+                engine.Unpack(new MisbehavingStreamContext(archiveName, null, null, false, true, true, true, false, true), null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsNull(caughtEx, "Caught exception: " + caughtEx);
+            Console.WriteLine("Testing streamContext that throws on OpenArchive.");
+            caughtEx = null;
+            try
+            {
+                engine.Unpack(new MisbehavingStreamContext(archiveName, null, null, true, true, false, true, true, true), null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsTrue(caughtEx != null && caughtEx.Message == MisbehavingStreamContext.EXCEPTION, "Caught exception: " + caughtEx);
+            Console.WriteLine("Testing streamContext that throws on CloseArchive.");
+            caughtEx = null;
+            try
+            {
+                engine.Unpack(new MisbehavingStreamContext(archiveName, null, null, true, true, true, false, true, true), null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsTrue(caughtEx != null && caughtEx.Message == MisbehavingStreamContext.EXCEPTION, "Caught exception: " + caughtEx);
+            Console.WriteLine("Testing streamContext that throws on OpenFile.");
+            caughtEx = null;
+            try
+            {
+                engine.Unpack(new MisbehavingStreamContext(archiveName, null, null, true, true, true, true, false, true), null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsTrue(caughtEx != null && caughtEx.Message == MisbehavingStreamContext.EXCEPTION, "Caught exception: " + caughtEx);
+            Console.WriteLine("Testing streamContext that throws on CloseFile.");
+            caughtEx = null;
+            try
+            {
+                engine.Unpack(new MisbehavingStreamContext(archiveName, null, null, true, true, true, true, true, false), null);
+            }
+            catch (Exception ex) { caughtEx = ex; }
+            Assert.IsTrue(caughtEx != null && caughtEx.Message == MisbehavingStreamContext.EXCEPTION, "Caught exception: " + caughtEx);
+        }
+
+        public static void TestTruncatedArchive(
+            ArchiveInfo archiveInfo, Type expectedExceptionType)
+        {
+            for (long len = archiveInfo.Length - 1; len >= 0; len--)
+            {
+                string testArchive = String.Format("{0}.{1:d06}",
+                    archiveInfo.FullName, len);
+                if (File.Exists(testArchive))
+                {
+                    File.Delete(testArchive);
+                }
+
+                archiveInfo.CopyTo(testArchive);
+                using (FileStream truncateStream =
+                    File.Open(testArchive, FileMode.Open, FileAccess.ReadWrite))
+                {
+                    truncateStream.SetLength(len);
+                }
+
+                ArchiveInfo testArchiveInfo = (ArchiveInfo) archiveInfo.GetType()
+                    .GetConstructor(new Type[] { typeof(string) }).Invoke(new object[] { testArchive });
+
+                Exception caughtEx = null;
+                try
+                {
+                    testArchiveInfo.GetFiles();
+                }
+                catch (Exception ex) { caughtEx = ex; }
+                File.Delete(testArchive);
+
+                if (caughtEx != null)
+                {
+                    Assert.IsInstanceOfType(caughtEx, expectedExceptionType,
+                        String.Format("Caught exception listing archive truncated to {0}/{1} bytes",
+                        len, archiveInfo.Length));
+                }
+            }
+        }
+    }
+}
diff --git a/src/dtf/WixToolsetTests.Dtf.Compression/MisbehavingStreamContext.cs b/src/dtf/WixToolsetTests.Dtf.Compression/MisbehavingStreamContext.cs
new file mode 100644
index 00000000..2531f3bc
--- /dev/null
+++ b/src/dtf/WixToolsetTests.Dtf.Compression/MisbehavingStreamContext.cs
@@ -0,0 +1,202 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+using WixToolset.Dtf.Compression;
+
+namespace WixToolset.Dtf.Test
+{
+    public class MisbehavingStreamContext : ArchiveFileStreamContext
+    {
+        public const string EXCEPTION = "Test exception.";
+
+        private bool throwEx;
+        private bool getName;
+        private bool openArchive;
+        private bool closeArchive;
+        private bool openFile;
+        private bool closeFile;
+        private int closeFileCount;
+
+        public MisbehavingStreamContext(
+            string cabinetFile,
+            string directory,
+            IDictionary<string, string> files,
+            bool throwEx,
+            bool getName,
+            bool openArchive,
+            bool closeArchive,
+            bool openFile,
+            bool closeFile)
+            : base(cabinetFile, directory, files)
+        {
+            this.throwEx = throwEx;
+            this.getName = getName;
+            this.openArchive = openArchive;
+            this.closeArchive = closeArchive;
+            this.openFile = openFile;
+            this.closeFile = closeFile;
+        }
+
+        public override string GetArchiveName(int archiveNumber)
+        {
+            if (!this.getName)
+            {
+                if (throwEx)
+                {
+                    throw new Exception(EXCEPTION);
+                }
+                else
+                {
+                    return null;
+                }
+            }
+            return base.GetArchiveName(archiveNumber);
+        }
+
+        public override Stream OpenArchiveWriteStream(
+            int archiveNumber,
+            string archiveName,
+            bool truncate,
+            CompressionEngine compressionEngine)
+        {
+            if (!this.openArchive)
+            {
+                if (throwEx)
+                {
+                    throw new Exception(EXCEPTION);
+                }
+                else
+                {
+                    return null;
+                }
+            }
+            return base.OpenArchiveWriteStream(
+                archiveNumber, archiveName, truncate, compressionEngine);
+        }
+
+        public override void CloseArchiveWriteStream(
+            int archiveNumber,
+            string archiveName,
+            Stream stream)
+        {
+            if (!this.closeArchive)
+            {
+                if (throwEx)
+                {
+                    this.closeArchive = true;
+                    throw new Exception(EXCEPTION);
+                }
+                return;
+            }
+            base.CloseArchiveWriteStream(archiveNumber, archiveName, stream);
+        }
+
+        public override Stream OpenFileReadStream(
+            string path,
+            out FileAttributes attributes,
+            out DateTime lastWriteTime)
+        {
+            if (!this.openFile)
+            {
+                if (throwEx)
+                {
+                    throw new Exception(EXCEPTION);
+                }
+                else
+                {
+                    attributes = FileAttributes.Normal;
+                    lastWriteTime = DateTime.MinValue;
+                    return null;
+                }
+            }
+            return base.OpenFileReadStream(path, out attributes, out lastWriteTime);
+        }
+
+        public override void CloseFileReadStream(string path, Stream stream)
+        {
+            if (!this.closeFile && ++closeFileCount == 2)
+            {
+                if (throwEx)
+                {
+                    throw new Exception(EXCEPTION);
+                }
+                return;
+            }
+            base.CloseFileReadStream(path, stream);
+        }
+
+        public override Stream OpenArchiveReadStream(
+            int archiveNumber,
+            string archiveName,
+            CompressionEngine compressionEngine)
+        {
+            if (!this.openArchive)
+            {
+                if (throwEx)
+                {
+                    throw new Exception(EXCEPTION);
+                }
+                else
+                {
+                    return null;
+                }
+            }
+            return base.OpenArchiveReadStream(archiveNumber, archiveName, compressionEngine);
+        }
+
+        public override void CloseArchiveReadStream(
+            int archiveNumber,
+            string archiveName,
+            Stream stream)
+        {
+            if (!this.closeArchive)
+            {
+                if (throwEx)
+                {
+                    this.closeArchive = true;
+                    throw new Exception(EXCEPTION);
+                }
+                return;
+            }
+            base.CloseArchiveReadStream(archiveNumber, archiveName, stream);
+        }
+
+        public override Stream OpenFileWriteStream(
+            string path,
+            long fileSize,
+            DateTime lastWriteTime)
+        {
+            if (!this.openFile)
+            {
+                if (throwEx)
+                {
+                    throw new Exception(EXCEPTION);
+                }
+                else
+                {
+                    return null;
+                }
+            }
+            return base.OpenFileWriteStream(path, fileSize, lastWriteTime);
+        }
+
+        public override void CloseFileWriteStream(
+            string path,
+            Stream stream,
+            FileAttributes attributes,
+            DateTime lastWriteTime)
+        {
+            if (!this.closeFile && ++closeFileCount == 2)
+            {
+                if (throwEx)
+                {
+                    throw new Exception(EXCEPTION);
+                }
+                return;
+            }
+            base.CloseFileWriteStream(path, stream, attributes, lastWriteTime);
+        }
+    }
+}
diff --git a/src/dtf/WixToolsetTests.Dtf.Compression/OptionStreamContext.cs b/src/dtf/WixToolsetTests.Dtf.Compression/OptionStreamContext.cs
new file mode 100644
index 00000000..98354d97
--- /dev/null
+++ b/src/dtf/WixToolsetTests.Dtf.Compression/OptionStreamContext.cs
@@ -0,0 +1,42 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using WixToolset.Dtf.Compression;
+
+namespace WixToolset.Dtf.Test
+{
+    public class OptionStreamContext : ArchiveFileStreamContext
+    {
+        private PackOptionHandler packOptionHandler;
+
+        public OptionStreamContext(IList<string> archiveFiles, string directory, IDictionary<string, string> files)
+            : base(archiveFiles, directory, files)
+        {
+        }
+
+        public delegate object PackOptionHandler(string optionName, object[] parameters);
+
+        public PackOptionHandler OptionHandler
+        {
+            get
+            {
+                return this.packOptionHandler;
+            }
+            set
+            {
+                this.packOptionHandler = value;
+            }
+        }
+
+        public override object GetOption(string optionName, object[] parameters)
+        {
+            if (this.OptionHandler == null)
+            {
+                return null;
+            }
+
+            return this.OptionHandler(optionName, parameters);
+        }
+    }
+}
diff --git a/src/dtf/WixToolsetTests.Dtf.Compression/WixToolsetTests.Dtf.Compression.csproj b/src/dtf/WixToolsetTests.Dtf.Compression/WixToolsetTests.Dtf.Compression.csproj
new file mode 100644
index 00000000..120779ee
--- /dev/null
+++ b/src/dtf/WixToolsetTests.Dtf.Compression/WixToolsetTests.Dtf.Compression.csproj
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!-- Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. -->
+
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ProjectGuid>{F045FFC1-05F9-4EA2-9F03-E1CBDB7BC4F9}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <RootNamespace>WixToolsetTests.Dtf</RootNamespace>
+    <AssemblyName>WixToolsetTests.Dtf.Compression</AssemblyName>
+    <CreateDocumentation>false</CreateDocumentation>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="CompressionTestUtil.cs" />
+    <Compile Include="MisbehavingStreamContext.cs" />
+    <Compile Include="OptionStreamContext.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\WixToolset.Dtf.Compression\WixToolset.Dtf.Compression.csproj" />
+  </ItemGroup>
+
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+</Project>