private void ExecuteFileTests(ICompressor compressor, string extension, List<string> exclusions)
        {
            // Bung the folder name and extension onto each element - makes it easier in testing membership
            // Since we don't have linq in .net 2 land :}
            for (var i = 0; i < exclusions.Count; i++)
            {
                exclusions[i] = "Compatability Test Files\\" + exclusions[i] + extension;
            }

            var sourceFiles = Directory.GetFiles("Compatability Test Files", "*" + extension);
            Assume.That(sourceFiles.Length, Is.GreaterThan(0), "No matching source files found, nothing to test");

            foreach (var file in Directory.GetFiles("Compatability Test Files", "*" + extension))
            {
                if (exclusions.Contains(file))
                {
                    continue;
                }
                var source = File.ReadAllText(file);
                var expected = File.ReadAllText(file + ".min");

                // Some of the test files have a load of carriage returns at the end, so we should strip those out
                while (expected.EndsWith("\n"))
                {
                    expected = expected.Substring(0, expected.Length - 1);
                }

                // Act
                var actual = compressor.Compress(source);

                // Assert
                Assert.That(actual, Is.EqualTo(expected), file);
            }
        }

        public void Performance(ICompressor compressor)
        {
            results.Add("---------" + compressor.GetType() + "---------");
            byte[] indata = Encoding.UTF8.GetBytes(testData);

            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            byte[] result = null;
            foreach (var i in Enumerable.Range(0,100))
            {
                result = compressor.Compress(indata);
            }
            stopwatch.Stop();
            long ticks = stopwatch.ElapsedTicks;
            results.Add("Compress: " +  ticks);

            stopwatch.Reset();
            stopwatch.Start();

            byte[] resurrected;
            foreach (var i in Enumerable.Range(0, 100))
            {
                resurrected = compressor.Decompress(result);
            }
            stopwatch.Stop();
            ticks = stopwatch.ElapsedTicks;
            results.Add("Decompress: " + ticks);
            results.Add("Compression: " + result.Length / (1.0 * indata.Length));
        }

        public static string GetCompressedContents(IEnumerable<string> bundle, string basePath, ICompressor compressor)
        {
            var fileList = bundle.ToList();
            var tempLookup = new ConcurrentDictionary<int, string>();
            Parallel.For(0, fileList.Count(), index =>
            {
                var file = fileList[index];
                var filePathName = Path.Combine(basePath, file);
                var fileContents = File.ReadAllText(filePathName, Encoding.UTF8);
                try
                {
                    fileContents = compressor.Compress(fileContents);
                }
                catch (Exception)
                {
                    Log.Warn("Error during compression (using uncompressed file) - " + file);
                }

                tempLookup[index] = fileContents;
            });

            var contents = new StringBuilder();
            for (var index = 0; index < fileList.Count; index++)
            {
                contents.Append(tempLookup[index]);
            }

            return contents.ToString();
        }

 public CompressorTaskEngine(ILog log, ICompressor compressor)
 {
     Log = log;
     this.compressor = compressor;
     this.Encoding = Encoding.Default;
     DeleteSourceFiles = false;
     LineBreakPosition = -1;
 }

 protected CompressorTask(ICompressor compressor)
 {
     this.logger = new NantLogAdapter();
     this.TaskEngine = new CompressorTaskEngine(logger, compressor) { SetBuildParameters = this.SetBuildParameters };
     this.SourceFiles = new FileSet();
     this.DeleteSourceFiles = false;
     this.LineBreakPosition = -1;
 }

 public CompressorTaskEngine(ILog log, ICompressor compressor)
 {
     Log = log;
     this.compressor = compressor;
     this.Encoding = Encoding.Default;
     DeleteSourceFiles = false;
     LineBreakPosition = -1;
     EcmaExceptions = new List<EcmaScriptException>();
 }

        public static MongoGridFSFileInfo UploadFileWithCompress(this IMongoRepository repository, ICompressor compressor, byte[] data,
                                                                 string remoteFilename) {
            compressor.ShouldNotBeNull("compressor");

            var entry = new CompressedFileItem(compressor.GetType(), compressor.Compress(data));

            using(var stream = new MemoryStream(FileSerializer.Serialize(entry))) {
                return repository.UploadFile(remoteFilename, stream);
            }
        }

 private static async Task CompressResponseNormal(IOwinContext context, ICompressor tmpCompressor, 
     Stream responseStream, CancellationToken cancellationToken)
 {
     using (var tmpBufferStream = new MemoryStream())
     {
         await tmpCompressor.Compress(context.Response.Body, tmpBufferStream, cancellationToken);
         context.Response.ContentLength = tmpBufferStream.Length;
         await BaseCompressor.Pump(tmpBufferStream, responseStream, cancellationToken);
     }
 }

        public CompressedContent(HttpContent content, ICompressor compressor)
        {
            //Ensure.Argument.NotNull(content, "content");
            //Ensure.Argument.NotNull(compressor, "compressor");

            this.content = content;
            this.compressor = compressor;

            AddHeaders();
        }

 public void Compress_decompression_yields_original_data(ICompressor compressor)
 {
     var randomBytes = new byte[2000];
     new Randomizer().NextBytes(randomBytes);
     var textBytes = Encoding.UTF8.GetBytes(testData);
     foreach (var array in new[]{randomBytes,textBytes})
     {
         var resurrected = compressor.Decompress(compressor.Compress(array));
         CollectionAssert.AreEqual(array, resurrected);
     }
 }

        private static async Task<HttpContent> DecompressContent(HttpContent compressedContent, ICompressor compressor)
        {
            using (compressedContent)
            {
                MemoryStream decompressed = new MemoryStream();
                await compressor.Decompress(await compressedContent.ReadAsStreamAsync(), decompressed);
                var newContent = new StreamContent(decompressed);
                // copy content type so we know how to load correct formatter
                newContent.Headers.ContentType = compressedContent.Headers.ContentType;

                return newContent;
            }
        }

        private static async Task<HttpContent> DecompressContentAsync(HttpContent compressedContent, ICompressor compressor)
        {
            using (compressedContent)
            {
                var decompressed = new MemoryStream();
                await compressor.Decompress(await compressedContent.ReadAsStreamAsync(), decompressed).ConfigureAwait(true);

                decompressed.Position = 0;
                var newContent = new StreamContent(decompressed);

                newContent.Headers.ContentType = compressedContent.Headers.ContentType;
                return newContent;
            }
        }

        private static async Task CompressToHttpOutputStream(OwinContext context, ICompressor compressor, Stream httpOutputStream, MemoryStream uncompressedStream)
        {
            using (var compressedStream = new MemoryStream())
            {
                using (var compressionStream = compressor.CreateStream(compressedStream))
                {
                    await uncompressedStream.CopyToAsync(compressionStream, BufferSize);
                }

                compressedStream.Position = 0;

                SetResponseHeaders(context, compressor, compressedStream);
                await compressedStream.CopyToAsync(httpOutputStream, BufferSize);
            }
        }

		public virtual void Compression(string sourcePath, string destinationPath, CompressionMode mode, ICompressor compressor = null)
		{
			compressor = compressor ?? new GzipCompressor();

			switch (mode)
			{
				case CompressionMode.Compress:
					Compress(sourcePath, destinationPath, compressor);
					return;
				case CompressionMode.Decompress:
					Decompress(sourcePath, destinationPath, compressor);
					return;
				default:
					throw new ArgumentException("The compression mode is not valid.", "mode");
			}
		}

        private static async Task<HttpContent> DecompressContentAsync(HttpContent compressedContent, ICompressor compressor)
        {
            using (compressedContent)
            {
                MemoryStream decompressed = new MemoryStream();
                await compressor.Decompress(await compressedContent.ReadAsStreamAsync(), decompressed).ConfigureAwait(false);
                
                // set position back to 0 so it can be read again
                decompressed.Position = 0;

                var newContent = new StreamContent(decompressed);
                // copy content type so we know how to load correct formatter
                newContent.Headers.ContentType = compressedContent.Headers.ContentType;
                return newContent;
            }
        }

		private void Decompress(string sourcePath, string destinationPath, ICompressor compressor)
		{
			using (var originalStream = OpenRead(sourcePath))
			{
				using (var destinationStream = OpenWrite(destinationPath))
				{
					using (compressor)
					{
						using (var compression = compressor.Decompress(originalStream))
						{
							compression.CopyTo(destinationStream);
						}
					}
				}
			}
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="CompressedContent"/> class.
        /// </summary>
        /// <param name="content">The content.</param>
        /// <param name="compressor">The compressor.</param>
        public CompressedContent(HttpContent content, ICompressor compressor)
        {
            if (content == null)
            {
                throw new ArgumentNullException("content");
            }

            if (compressor == null)
            {
                throw new ArgumentNullException("compressor");
            }

            this.originalContent = content;
            this.compressor = compressor;

            this.CopyHeaders();
        }

        internal override async Task Compress(Func<IDictionary<string, object>, Task> next, OwinContext context, ICompressor compressor, Stream httpOutputStream)
        {
            using (var memoryStream = new MemoryStream())
            {
                using (var compressedStream = compressor.CreateStream(memoryStream))
                {
                    context.Response.Body = compressedStream;
                    await next.Invoke(context.Environment);
                }

                if (memoryStream.Length > 0)
                {
                    SetResponseHeaders(context, compressor, memoryStream);
                    memoryStream.Position = 0;
                    await memoryStream.CopyToAsync(httpOutputStream, BufferSize);
                }
            }
        }

 public BrokeredMessageFactory(MaxLargeMessageSizeSetting maxLargeMessageSize,
                               MaxSmallMessageSizeSetting maxSmallMessageSize,
                               IClock clock,
                               ICompressor compressor,
                               IDispatchContextManager dispatchContextManager,
                               ILargeMessageBodyStore largeMessageBodyStore,
                               ISerializer serializer,
                               ITypeProvider typeProvider)
 {
     _serializer = serializer;
     _maxLargeMessageSize = maxLargeMessageSize;
     _maxSmallMessageSize = maxSmallMessageSize;
     _compressor = compressor;
     _dispatchContextManager = dispatchContextManager;
     _largeMessageBodyStore = largeMessageBodyStore;
     _typeProvider = typeProvider;
     _clock = clock;
 }

        /// <summary>
        /// <paramref name="pageState"/> 정보를 직렬화해서, <see cref="IPageStateEntity"/> 객체로 빌드합니다.
        /// </summary>
        /// <param name="id"></param>
        /// <param name="pageState"></param>
        /// <param name="compressor"></param>
        /// <param name="compressThreshold"></param>
        /// <returns></returns>
        public static IPageStateEntity CreateStateEntity(string id, object pageState, ICompressor compressor,
                                                         int compressThreshold = 40960) {
            compressor.ShouldNotBeNull("compressor");
            compressThreshold.ShouldBePositive("compressThreshold");

            if(IsDebugEnabled)
                log.Debug("상태 정보를 가지는 인스턴스를 생성합니다. pageState=[{0}], compressor=[{1}], compressThreshold=[{2}]",
                          pageState, compressor, compressThreshold);

            if(pageState == null)
                return new PageStateEntity(id, null, false);

            var serializedValue = Serializer.Serialize(pageState);

            if(serializedValue.Length > compressThreshold)
                return new PageStateEntity(id, compressor.Compress(serializedValue), true);

            return new PageStateEntity(id, serializedValue, false);
        }