public async Task ParseLogoutRequest_post_binding()
{
//ARRANGE
var form = await SamlPostRequestProviderMock.BuildLogoutRequestPostForm();
Func <Type, IMetadataHandler> metadataHandlerFactory = t => new MetadataEntitityDescriptorHandler();
var xmlSerialiser = new XMLSerialiser();
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var logger = new LogProviderMock();
var serialiser = new RequestSerialiser(xmlSerialiser, encoder, logger) as IRequestSerialiser;
var certManager = new CertificateManager(logger);
var signatureManager = new XmlSignatureManager();
Func <IEnumerable <RequestValidationRule> > rulesResolver = () => new[] { new SignatureValidRule(logger, certManager, signatureManager) };
var requestValidator = new Federation.Protocols.Request.Validation.RequestValidator(logger, new RuleFactory(rulesResolver));
var configurationRetrieverMock = new ConfigurationRetrieverMock();
var federationPartyContextBuilderMock = new FederationPartyContextBuilderMock();
var configurationManger = new ConfigurationManager <MetadataBase>(federationPartyContextBuilderMock, configurationRetrieverMock);
var requestParser = new RequestParser(metadataHandlerFactory, t => new LogoutRequestParser(serialiser, logger),
configurationManger, logger, requestValidator);
var postBindingDecoder = new PostBindingDecoder(logger);
var message = await postBindingDecoder.Decode(form.HiddenControls.ToDictionary(k => k.Key, v => v.Value));
var context = new SamlInboundContext
{
Message = message,
DescriptorResolver = m => metadataHandlerFactory(typeof(object)).GetIdentityProviderSingleSignOnDescriptor(m).Single().Roles.Single()
};
//ACT
var result = await requestParser.Parse(context);
//ASSERT
Assert.IsTrue(result.IsValidated);
Assert.IsInstanceOf <LogoutRequest>(result.SamlRequest);
}
public void LogoutRequestType_test_test()
{
//ARRANGE
var requestUri = new Uri("http://localhost:59611/");
var federationPartyContextBuilder = new FederationPartyContextBuilderMock();
var federationContex = federationPartyContextBuilder.BuildContext("local");
var logoutContext = new SamlLogoutContext(new Uri(Reasons.User), new System.IdentityModel.Tokens.Saml2NameIdentifier("testUser", new Uri(NameIdentifierFormats.Persistent)), "local");
var authnRequestContext = new LogoutRequestContext(requestUri, new Uri("http://localhost"), federationContex, logoutContext);
var types = ReflectionHelper.GetAllTypes(t => !t.IsAbstract && !t.IsInterface && typeof(RequestAbstract).IsAssignableFrom(t));
var xmlSerialiser = new XMLSerialiser();
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var logger = new LogProviderMock();
var serialiser = new RequestSerialiser(xmlSerialiser, encoder, logger) as IRequestSerialiser;
RequestHelper.GetAuthnRequestBuilders = AuthnRequestBuildersFactoryMock.GetLogoutRequestBuildersFactory();
var logoutRequest = RequestHelper.BuildRequest(authnRequestContext);
var typeResolver = new MessageTypeResolver();
//ACT
var serialised = serialiser.Serialize(logoutRequest);
var type = typeResolver.ResolveMessageType(serialised, types);
//ASSERT
Assert.AreEqual(typeof(LogoutRequest), type);
}
public void DeflateStream_Decompressor_2()
{
byte[] input = new byte[] { 0x73, 0x74, 0x72, 0x76, 0x71, 0x75, 0x03, 0x00 };
byte[] plaintext = Encoding.UTF8.GetBytes("ABCDEF");
byte[] decompBytes = DeflateCompressor.Decompress(input);
Assert.IsTrue(decompBytes.SequenceEqual(plaintext));
}
public void AuthnRequestSerialiser_test()
{
//ARRANGE
var requestUri = new Uri("http://localhost:59611/");
var federationPartyContextBuilder = new FederationPartyContextBuilderMock();
var federationContex = federationPartyContextBuilder.BuildContext("local");
var supportedNameIdentifierFormats = new List <Uri> {
new Uri(NameIdentifierFormats.Transient)
};
var authnRequestContext = new AuthnRequestContext(requestUri, new Uri("http://localhost"), federationContex, supportedNameIdentifierFormats);
var xmlSerialiser = new XMLSerialiser();
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var logger = new LogProviderMock();
var serialiser = new RequestSerialiser(xmlSerialiser, encoder, logger) as ISerializer;
RequestHelper.GetAuthnRequestBuilders = AuthnRequestBuildersFactoryMock.GetAuthnRequestBuildersFactory();
var authnRequest = RequestHelper.BuildRequest(authnRequestContext);
//ACT
var serialised = serialiser.Serialize(authnRequest);
var deserialised = serialiser.Deserialize <AuthnRequest>(serialised);
//ASSERT
Assert.NotNull(serialised);
Assert.AreEqual(authnRequest.Issuer.Value, deserialised.Issuer.Value);
}
public void Compress()
{
var TestObject = new DeflateCompressor();
string Data = "This is a bit of data that I want to compress";
Assert.Equal("CsnILFYAokSFpMwShfw0hZTEkkSFkozEEgVPhfLEvBKFknyF5PzcgqLU4mIAAAAA//8=", Convert.ToBase64String(TestObject.Compress(Data.ToByteArray())));
}
public async Task AuthnRequestSerialiser_test()
{
//ARRANGE
var requestUri = new Uri("http://localhost:59611/");
var federationPartyContextBuilder = new FederationPartyContextBuilderMock();
var federationContex = federationPartyContextBuilder.BuildContext("local");
var supportedNameIdentifierFormats = new List <Uri> {
new Uri(NameIdentifierFormats.Transient)
};
var authnRequestContext = new AuthnRequestContext(requestUri, federationContex, supportedNameIdentifierFormats);
var xmlSerialiser = new XMLSerialiser();
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var logger = new LogProviderMock();
var serialiser = new AuthnRequestSerialiser(xmlSerialiser, encoder, logger);
AuthnRequestHelper.GetBuilders = AuthnRequestBuildersFactoryMock.GetBuildersFactory();
var authnRequest = AuthnRequestHelper.BuildAuthnRequest(authnRequestContext);
//ACT
var request = await serialiser.Serialize(authnRequest);
//ASSERT
Assert.NotNull(request);
}
public override ScenarioInstance <ICompressor> CreateInstance()
{
var compressor = new DeflateCompressor();
var instance = new ScenarioInstance <ICompressor>(compressor);
return(instance);
}
public void Decompress()
{
var TestObject = new DeflateCompressor();
string Data = "This is a bit of data that I want to compress";
Assert.Equal("This is a bit of data that I want to compress", TestObject.Decompress(TestObject.Compress(Data.ToByteArray())).ToString(null));
}
/// <summary>
/// Gets the compression mechanism using the service context and the depending on the request and response.
/// </summary>
/// <param name="serviceContext">The service context object.</param>
/// <param name="isRequest">Specifies whether to return compression mechanism for reqeust or response.</param>
/// <returns>The Compression mechanism.</returns>
public static ICompressor GetCompressor(ServiceContext serviceContext, bool isRequest)
{
ICompressor compressor = null;
if (isRequest)
{
switch (serviceContext.IppConfiguration.Message.Request.CompressionFormat)
{
case Configuration.CompressionFormat.GZip:
compressor = new GZipCompressor();
break;
case Configuration.CompressionFormat.Deflate:
compressor = new DeflateCompressor();
break;
}
}
else
{
switch (serviceContext.IppConfiguration.Message.Response.CompressionFormat)
{
case Configuration.CompressionFormat.GZip:
compressor = new GZipCompressor();
break;
case Configuration.CompressionFormat.Deflate:
compressor = new DeflateCompressor();
break;
}
}
return(compressor);
}
public void AuthnRequestType_test()
{
//ARRANGE
var requestUri = new Uri("http://localhost:59611/");
var federationPartyContextBuilder = new FederationPartyContextBuilderMock();
var federationContex = federationPartyContextBuilder.BuildContext("local");
var supportedNameIdentifierFormats = new List <Uri> {
new Uri(NameIdentifierFormats.Transient)
};
var authnRequestContext = new AuthnRequestContext(requestUri, new Uri("http://localhost"), federationContex, supportedNameIdentifierFormats);
var types = ReflectionHelper.GetAllTypes(t => !t.IsAbstract && !t.IsInterface && typeof(RequestAbstract).IsAssignableFrom(t));
var xmlSerialiser = new XMLSerialiser();
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var logger = new LogProviderMock();
var serialiser = new RequestSerialiser(xmlSerialiser, encoder, logger) as IRequestSerialiser;
RequestHelper.GetAuthnRequestBuilders = AuthnRequestBuildersFactoryMock.GetAuthnRequestBuildersFactory();
var authnRequest = RequestHelper.BuildRequest(authnRequestContext);
var typeResolver = new MessageTypeResolver();
//ACT
var serialised = serialiser.Serialize(authnRequest);
var type = typeResolver.ResolveMessageType(serialised, types);
//ASSERT
Assert.AreEqual(typeof(AuthnRequest), type);
}
public async Task CompressDecompressString()
{
//ARRANGE
var str = "String to compress";
var compressor = new DeflateCompressor();
//ACT
var strArr = Encoding.UTF8.GetBytes(str);
var source = new MemoryStream(strArr);
source.Position = 0;
var compressed = new MemoryStream();
await compressor.Compress(source, compressed);
compressed.Position = 0;
var decompressed = new MemoryStream();
await compressor.Decompress(compressed, decompressed);
decompressed.Position = 0;
var result = new StreamReader(decompressed).ReadToEnd();
//ASSERT
Assert.AreEqual(str, result);
}
public async Task ParseTokenResponse_post_binding_sp_initiated()
{
//ARRANGE
var inResponseTo = Guid.NewGuid().ToString();
var response = ResponseFactoryMock.GetTokenResponseSuccess(inResponseTo, StatusCodes.Success);
var logger = new LogProviderMock();
var serialised = ResponseFactoryMock.Serialize(response);
var xmlSignatureManager = new XmlSignatureManager();
var document = new XmlDocument();
document.LoadXml(serialised);
var cert = AssertionFactroryMock.GetMockCertificate();
xmlSignatureManager.SignXml(document, response.ID, cert.PrivateKey, null);
var base64Encoded = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(document.DocumentElement.OuterXml));
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var jsonSerialiser = new NSJsonSerializer(new DefaultSettingsProvider());
var relayStateSerialiser = new RelaystateSerialiser(jsonSerialiser, encoder, logger) as IRelayStateSerialiser;
var relayState = await relayStateSerialiser.Serialize(new Dictionary <string, object> {
{ "Key", "Value" }
});
var form = new SAMLForm();
form.SetResponse(base64Encoded);
form.SetRelatState(relayState);
Func <Type, IMetadataHandler> metadataHandlerFactory = t => new MetadataEntitityDescriptorHandler();
var certManager = new CertificateManager(logger);
var signatureManager = new XmlSignatureManager();
Func <IEnumerable <ResponseValidationRule> > rulesResolver = () => new[] { new ResponseSignatureRule(logger, certManager, signatureManager) };
var validator = new Federation.Protocols.Response.Validation.ResponseValidator(logger, new RuleFactory(rulesResolver));
var configurationRetrieverMock = new ConfigurationRetrieverMock();
var federationPartyContextBuilderMock = new FederationPartyContextBuilderMock();
var configurationManger = new ConfigurationManager <MetadataBase>(federationPartyContextBuilderMock, configurationRetrieverMock);
var relayStateHandler = new RelayStateHandler(relayStateSerialiser, logger);
var responseParser = new ResponseParser(metadataHandlerFactory, t => new SamlTokenResponseParser(logger),
configurationManger, relayStateHandler, logger, validator);
var postBindingDecoder = new PostBindingDecoder(logger);
var message = await postBindingDecoder.Decode(form.HiddenControls.ToDictionary(k => k.Key, v => v.Value));
var context = new SamlInboundContext
{
Message = message,
DescriptorResolver = m => metadataHandlerFactory(typeof(object)).GetIdentityProviderSingleSignOnDescriptor(m).Single().Roles.Single()
};
//ACT
var result = await responseParser.Parse(context);
//ASSERT
Assert.IsTrue(result.IsValidated);
}
public void IsSameOrSubclassOrImplementOf_Test()
{
var deflate = new DeflateCompressor();
Assert.IsTrue(TypeTool.IsSameOrSubclassOrImplementedOf(deflate, typeof(ICompressor)));
Assert.IsTrue(TypeTool.IsSameOrSubclassOrImplementedOf(typeof(GZipCompressor), typeof(ICompressor)));
Assert.IsFalse(TypeTool.IsSameOrSubclassOrImplementedOf(typeof(Compressor), typeof(ICompressor)));
}
public void DecompressTest()
{
DeflateCompressor target = new DeflateCompressor();
using (Stream responseStream = new MemoryStream())
{
Stream actual = target.Decompress(responseStream);
Assert.IsNotNull(actual);
}
}
public void CompressTest()
{
DeflateCompressor target = new DeflateCompressor(); // TODO: Initialize to an appropriate value
byte[] content = Encoding.ASCII.GetBytes("Hello World");
using (Stream requestStream = new MemoryStream())
{
target.Compress(content, requestStream);
}
Assert.Inconclusive("A method that does not return a value cannot be verified.");
}
public void DeflateCompressorStringExtesionWorks()
{
var compressor = new DeflateCompressor();
var compressed = compressor.Compress("test");
Assert.IsNotNull(compressed);
var decompressor = new DeflateDecompressor();
var decompressed = decompressor.Decompress(compressed);
Assert.IsNotNull(decompressed);
Assert.AreEqual("test", Encoding.UTF8.GetString(decompressed));
}
public void DeflateCompressorStringExtesionWorks()
{
var compressor = new DeflateCompressor();
var compressed = compressor.Compress("test");
compressed.Should().NotBeNull();
var decompressor = new DeflateDecompressor();
var decompressed = decompressor.Decompress(compressed);
decompressed.Should().NotBeNull();
Encoding.UTF8.GetString(decompressed).Should().Be("test");
}
public async Task MessageEncoding_test()
{
//ARRANGE
var source = "Text to encode";
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var expected = await Helper.DeflateEncode(source.ToString(), compressor);
//ACT
var encoded = await encoder.EncodeMessage(source);
//ASSERT
Assert.AreEqual(expected, encoded);
}
public async Task CompressDecompressString()
{
//ARRANGE
var str = "String to compress.";
var compression = new DeflateCompressor();
//ACT
var compressed = await Helper.DeflateEncode(str, compression);
var decompressed = await Helper.DeflateDecompress(compressed, compression);
//ASSERT
Assert.AreEqual(str, decompressed);
}
public async Task MessageEncodingDecodingTest_test()
{
//ARRANGE
var source = "Text to encode";
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
//ACT
var encoded = await encoder.EncodeMessage(source);
var decoded = await encoder.DecodeMessage(encoded);
//ASSERT
Assert.AreEqual(decoded, source);
}
public async Task CompressDecompressString()
{
//ARRANGE
var str = "String to compress.";
var compression = new DeflateCompressor();
//ACT
var buffer = System.Text.Encoding.UTF8.GetBytes(str);
var compressed = await Helper.DeflateCompress(buffer, compression);
var decompressed = await Helper.DeflateDecompress(compressed, compression);
//ASSERT
Assert.AreEqual(str, decompressed);
}
public async Task MessageDecoding_test()
{
//ARRANGE
var source = "Text to encode";
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var encoded = await Helper.DeflateCompress(System.Text.Encoding.UTF8.GetBytes(source), compressor);
var toString64 = Convert.ToBase64String(encoded);
//ACT
var decoded = await encoder.DecodeMessage(toString64);
//ASSERT
Assert.AreEqual(decoded, source);
}
public static async Task <SAMLForm> BuildRequestBindingContext(RequestContext requestContext)
{
string url = String.Empty;
var builders = new List <IPostClauseBuilder>();
requestContext.RelyingState.Add("relayState", "Test state");
var xmlSerialiser = new XMLSerialiser();
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var logger = new LogProviderMock();
var serialiser = new RequestSerialiser(xmlSerialiser, encoder, logger);
var xmlSinatureManager = new XmlSignatureManager();
RequestHelper.GetAuthnRequestBuilders = AuthnRequestBuildersFactoryMock.GetAuthnRequestBuildersFactory();
var authnBuilder = new SamlRequestBuilder(serialiser);
builders.Add(authnBuilder);
//relay state builder
var jsonSerialiser = new NSJsonSerializer(new DefaultSettingsProvider());
var relayStateSerialiser = new RelaystateSerialiser(jsonSerialiser, encoder, logger) as IRelayStateSerialiser;
var relayStateBuilder = new RelayStateBuilder(relayStateSerialiser);
builders.Add(relayStateBuilder);
//signature builder
var certificateManager = new CertificateManager(logger);
var signatureBuilder = new SignatureBuilder(certificateManager, logger, xmlSinatureManager);
builders.Add(signatureBuilder);
var bindingContext = new RequestPostBindingContext(requestContext);
foreach (var b in builders)
{
await b.Build(bindingContext);
}
var form = new SAMLForm();
var request = bindingContext.RequestParts[HttpRedirectBindingConstants.SamlRequest];
var base64Encoded = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(request));
var relyingStateSerialised = bindingContext.RequestParts[HttpRedirectBindingConstants.RelayState];
form.ActionURL = bindingContext.DestinationUri.AbsoluteUri;
form.SetRequest(base64Encoded);
form.SetRelatState(relyingStateSerialised);
return(form);
}
public void DeflateStream_Compressor_2()
{
byte[] input = Encoding.UTF8.GetBytes("ABCDEF");
// Compress first,
// 73-74-72-76-71-75-03-00
byte[] compBytes = DeflateCompressor.Compress(input);
// then Decompress.
byte[] decompBytes = DeflateCompressor.Decompress(compBytes);
// Comprare SHA256 Digest
byte[] inputDigest = TestSetup.SHA256Digest(input);
byte[] decompDigest = TestSetup.SHA256Digest(decompBytes);
Assert.IsTrue(decompDigest.SequenceEqual(inputDigest));
}
public void CompressDecompressTest()
{
DeflateCompressor target = new DeflateCompressor();
string strContent = "Hello World";
byte[] content = Encoding.ASCII.GetBytes(strContent);
using (Stream requestStream = new MemoryStream())
{
var compressedStream = new DeflateStream(requestStream, CompressionMode.Compress);
compressedStream.Write(content, 0, content.Length);
Stream actual = target.Decompress(requestStream);
Assert.IsNotNull(actual);
actual.Read(content, 0, content.Length);
string dString = Encoding.ASCII.GetString(content);
Assert.IsTrue(string.Compare(strContent, dString, false) == 0);
}
}
public static async Task <RequestBindingContext> BuildRequestBindingContext(RequestContext requestContext)
{
string url = String.Empty;
var builders = new List <IRedirectClauseBuilder>();
requestContext.RelyingState.Add("relayState", "Test state");
var xmlSerialiser = new XMLSerialiser();
var compressor = new DeflateCompressor();
var encoder = new MessageEncoding(compressor);
var logger = new LogProviderMock();
var serialiser = new RequestSerialiser(xmlSerialiser, encoder, logger);
RequestHelper.GetAuthnRequestBuilders = AuthnRequestBuildersFactoryMock.GetAuthnRequestBuildersFactory();
var authnBuilder = new SamlRequestBuilder(serialiser);
builders.Add(authnBuilder);
//request compression builder
var encodingBuilder = new RequestEncoderBuilder(encoder);
builders.Add(encodingBuilder);
//relay state builder
var jsonSerialiser = new NSJsonSerializer(new DefaultSettingsProvider());
var relayStateSerialiser = new RelaystateSerialiser(jsonSerialiser, encoder, logger) as IRelayStateSerialiser;
var relayStateBuilder = new RelayStateBuilder(relayStateSerialiser);
builders.Add(relayStateBuilder);
//signature builder
var certificateManager = new CertificateManager(logger);
var signatureBuilder = new SignatureBuilder(certificateManager, logger);
builders.Add(signatureBuilder);
var bindingContext = new RequestBindingContext(requestContext);
foreach (var b in builders)
{
await b.Build(bindingContext);
}
return(bindingContext);
}
static async Task Main(string[] args)
{
var messageDispatched = 0;
//var resolver = new UnityDependencyResolver();
//using (new InformationLogEventWriter())
//{
// ApplicationConfiguration.RegisterDependencyResolver(() => resolver);
// ApplicationConfiguration.RegisterServerInitialiserFactory(() => new ServerInitialiser());
// Program.InitializeServer();
//}
var compressor = new DeflateCompressor();
var serialaser = new InMemorySerializer(compressor);
var logger = new MockLogProvider();
var transport = new InMemoryQueueTransport(logger, () => new TransportConfiguration());
await transport.Start();
var transportManager = new TransportManager(transport, null);
var dispatcher = new TransportDispatcher(transportManager ,serialaser);//resolver.Resolve<ITranspontDispatcher>();
var internalListener = new MessageListener();
await dispatcher.TransportManager.RegisterListener(internalListener);
var tasks = new List<Task>();
for (var i = 0; i < 1; i++)
{
var batch = i;
var task = Task.Factory.StartNew(async () =>
{
for (var j = 0; j < 1; j++)
{
var command = new LogErrorCommand(Guid.NewGuid(), Guid.NewGuid());
Interlocked.Increment(ref messageDispatched);
Console.WriteLine(String.Format("Dispatched message No: {0}, batch: {1}. Total number messages: {2}", j, batch, messageDispatched));
//Thread.Sleep(10);
await dispatcher.SendMessage(command);
}
});
tasks.Add(task);
}
Console.ReadLine();
}
public void Compress(CompressionType compressionType)
{
if (IsSet)
{
throw new InvalidOperationException("Explicitly setting compression type must be performed before headers get sent");
}
Compression = compressionType;
switch (compressionType)
{
case CompressionType.None: ContentTransform = new RawUnifiedDuplex(); IsCompressionSet = false; break;
case CompressionType.Gzip: ContentTransform = new GzipCompressor(CompressionLevel); IsCompressionSet = true; break;
case CompressionType.Deflate: ContentTransform = new DeflateCompressor(CompressionLevel); IsCompressionSet = true; break;
case CompressionType.Compress: throw new NotImplementedException("Got Compress, an unimplemented compression, as compression type");
default: throw new ArgumentException("Got Unknown as compression type");
}
}
public async Task SerialiseDeserialiseTest()
{
//ARRANGE
var relayState = new Dictionary <string, object> {
{ "relayState", "Test state" }
};
var compressor = new DeflateCompressor();
var messageEncoder = new MessageEncoding(compressor);
var jsonSerialiser = new NSJsonSerializer(new DefaultSettingsProvider());
var logger = new LogProviderMock();
var serialiser = new RelaystateSerialiser(jsonSerialiser, messageEncoder, logger) as IRelayStateSerialiser;
//ACT
var serialised = await serialiser.Serialize(relayState);
var deserialised = await serialiser.Deserialize(serialised) as Dictionary <string, object>;
//ASSERT
Assert.AreEqual(relayState.Count, deserialised.Count);
Assert.AreEqual(relayState["relayState"], deserialised["relayState"]);
}
public bool TrySetFor(MessageHead head)
{
ThrowIfEnded();
BodyType?bodyType = BodyType.TryDetectFor(head);
if (bodyType == null)
{
return(false);
}
CompressionType compression = bodyType.Value.CompressionType;
TransferEncoding transfer = bodyType.Value.TransferEncoding;
int contentLength = bodyType.Value.ContentLength;
if (IsSet)
{
Finish();
}
IsSet = true;
TransferEncoding = transfer;
ContentLength = contentLength;
if (Compression != CompressionType.Unknown)
{
return(true);
}
Compression = compression;
switch (compression)
{
case CompressionType.None: ContentTransform = new RawUnifiedDuplex(); IsCompressionSet = false; break;
case CompressionType.Gzip: ContentTransform = new GzipCompressor(CompressionLevel); IsCompressionSet = true; break;
case CompressionType.Deflate: ContentTransform = new DeflateCompressor(CompressionLevel); IsCompressionSet = true; break;
case CompressionType.Compress: return(false);
default: return(false);
}
return(true);
}
