public void ClearReferenceSet()
{
var bytes = new byte[] { 0x30 }; // this value depends on pattern
var clientHeaders = new HeadersList
{
new KeyValuePair <string, string>(":method", "get")
};
var clientCompressionProc = new CompressionProcessor();
var serverCompressionProc = new CompressionProcessor();
serverCompressionProc.Decompress(clientCompressionProc.Compress(clientHeaders));
stateBefore = new CompProcState(serverCompressionProc);
Assert.True(stateBefore.LocalRefSet.Count > 0);
serverCompressionProc.Decompress(bytes);
stateAfter = new CompProcState(serverCompressionProc);
serverCompressionProc.Dispose();
clientCompressionProc.Dispose();
Assert.True(stateAfter.LocalRefSet == null ||
stateAfter.LocalRefSet.Count == 0);
}
private static void Processor_ProcessingFinished(object sender, CompressionResult result)
{
CompressionProcessor processor = (CompressionProcessor)sender;
try
{
switch (result.Type)
{
case CompressionResultType.Success:
PrintProgress($"Finished!");
break;
case CompressionResultType.Cancelled:
DeleteDestinationFile(processor);
PrintProgress($"Canceled!");
break;
case CompressionResultType.Fail:
DeleteDestinationFile(processor);
throw result.Exception;
default: throw new NotSupportedException();
}
if (result.Type == CompressionResultType.Fail)
{
throw result.Exception;
}
}
catch (Exception ex)
{
PrintError(ex.Message, true);
}
}
public void SendValidMaxHeaderTableSize()
{
var bytes = validHeaderTableSize.ToUVarInt(prefix);
bytes[0] |= (byte)IndexationType.EncodingContextUpdate;
var serverCompressionProc = new CompressionProcessor();
serverCompressionProc.NotifySettingsChanges(newSettingsMaxHeaderTableSize);
stateBefore = new CompProcState(serverCompressionProc);
serverCompressionProc.Decompress(bytes);
stateAfter = new CompProcState(serverCompressionProc);
serverCompressionProc.Dispose();
Assert.Equal(newSettingsMaxHeaderTableSize, stateAfter.SettingsHeaderTableSize);
Assert.Equal(stateBefore.SettingsHeaderTableSize,
stateAfter.SettingsHeaderTableSize);
Assert.Equal(stateBefore.MaxHeaderByteSize,
stateBefore.SettingsHeaderTableSize);
Assert.True(stateAfter.IsSettingHeaderTableSizeReceived ==
stateBefore.IsSettingHeaderTableSizeReceived);
Assert.True(stateAfter.IsSettingHeaderTableSizeReceived);
Assert.Equal(validHeaderTableSize, stateAfter.MaxHeaderByteSize);
Assert.True(stateAfter.MaxHeaderByteSize <= stateAfter.SettingsHeaderTableSize);
}
public void NeverIndexedEmission()
{
var serverCompressionProc = new CompressionProcessor();
var header = new KeyValuePair <string, string>("custom-key", "custom-value");
byte[] index = { 0x10 };
byte[] name = Encoding.UTF8.GetBytes(header.Key);
byte[] nameLength = name.Length.ToUVarInt(7);
byte[] value = Encoding.UTF8.GetBytes(header.Value);
byte[] valueLength = value.Length.ToUVarInt(7);
byte[] encodedHeader = new byte[index.Length + name.Length +
value.Length + nameLength.Length + valueLength.Length];
// creates encoded header
int offset = 0;
Buffer.BlockCopy(index, 0, encodedHeader, 0, index.Length);
offset += index.Length;
Buffer.BlockCopy(nameLength, 0, encodedHeader, offset, nameLength.Length);
offset += nameLength.Length;
Buffer.BlockCopy(name, 0, encodedHeader, offset, name.Length);
offset += name.Length;
Buffer.BlockCopy(valueLength, 0, encodedHeader, offset, valueLength.Length);
offset += valueLength.Length;
Buffer.BlockCopy(value, 0, encodedHeader, offset, value.Length);
HeadersList deserializedHeaders = serverCompressionProc.Decompress(encodedHeader);
Assert.Equal(deserializedHeaders[0].Key, header.Key);
Assert.Equal(deserializedHeaders[0].Value, header.Value);
}
private static void DeleteDestinationFile(CompressionProcessor processor)
{
FileInfo file = IOHelper.GetFileFromStream(processor.GetDestinationStream);
if (file != null && file.Exists)
{
file.Delete();
}
}
public void CompressAndDecompressEmptyData()
{
CompressionProcessor compressor = new CompressionProcessor();
byte[] data = new byte[10];
byte[] compressedData = compressor.Compress(data);
byte[] decompressedData = compressor.Decompress(compressedData);
Assert.Equal(data, decompressedData);
}
public void CompressAndDecompressSimpleData()
{
CompressionProcessor compressor = new CompressionProcessor();
byte[] data = new byte[] { 0x65, 0x66, 0x67, 0x68 };
byte[] compressedData = compressor.Compress(data);
byte[] decompressedData = compressor.Decompress(compressedData);
Assert.Equal(data, decompressedData);
}
public CompProcState(CompressionProcessor proc)
{
IsSettingHeaderTableSizeReceived = (bool)GetFieldValue(typeof(CompressionProcessor),
"_isSettingHeaderTableSizeReceived", proc);
SettingsHeaderTableSize = (int)GetFieldValue(typeof(CompressionProcessor),
"_settingsHeaderTableSize", proc);
MaxHeaderByteSize = (int)GetFieldValue(typeof(CompressionProcessor),
"_maxHeaderByteSize", proc);
LocalRefSet = (HeadersList)GetFieldValue(typeof(CompressionProcessor),
"_localRefSet", proc);
}
public void SendInvalidMaxHeaderTableSize()
{
bool isErrorThrown = false;
var bytes = invalidHeaderTableSize.ToUVarInt(prefix);
bytes[0] |= (byte)IndexationType.EncodingContextUpdate;
var serverCompressionProc = new CompressionProcessor();
serverCompressionProc.NotifySettingsChanges(newSettingsMaxHeaderTableSize);
stateBefore = new CompProcState(serverCompressionProc);
try
{
serverCompressionProc.Decompress(bytes);
}
catch (CompressionError)
{
isErrorThrown = true;
}
stateAfter = new CompProcState(serverCompressionProc);
serverCompressionProc.Dispose();
Assert.True(isErrorThrown);
Assert.Equal(newSettingsMaxHeaderTableSize, stateAfter.SettingsHeaderTableSize);
Assert.Equal(stateBefore.SettingsHeaderTableSize,
stateAfter.SettingsHeaderTableSize);
Assert.Equal(stateBefore.MaxHeaderByteSize, stateBefore.SettingsHeaderTableSize);
Assert.True(stateAfter.IsSettingHeaderTableSizeReceived);
Assert.NotEqual(invalidHeaderTableSize, stateAfter.MaxHeaderByteSize);
Assert.True(stateAfter.MaxHeaderByteSize <= stateAfter.SettingsHeaderTableSize);
Assert.Equal(stateBefore.MaxHeaderByteSize, stateAfter.MaxHeaderByteSize);
}
public void CompressionSuccessful()
{
var clientHeaders = new HeadersList
{
new KeyValuePair <string, string>(":method", "get"),
new KeyValuePair <string, string>(":path", "/test.txt"),
new KeyValuePair <string, string>(":version", Protocols.Http2),
new KeyValuePair <string, string>(":host", "localhost"),
new KeyValuePair <string, string>(":scheme", "http"),
};
var clientCompressor = new CompressionProcessor(ConnectionEnd.Client);
var serverDecompressor = new CompressionProcessor(ConnectionEnd.Server);
var serializedHeaders = clientCompressor.Compress(clientHeaders);
var decompressedHeaders = new HeadersList(serverDecompressor.Decompress(serializedHeaders));
foreach (var t in clientHeaders)
{
Assert.Equal(decompressedHeaders.GetValue(t.Key), t.Value);
}
var serverHeaders = new HeadersList
{
new KeyValuePair <string, string>(":status", StatusCode.Code200Ok.ToString()),
};
var serverCompressor = new CompressionProcessor(ConnectionEnd.Server);
var clientDecompressor = new CompressionProcessor(ConnectionEnd.Client);
serializedHeaders = serverCompressor.Compress(serverHeaders);
decompressedHeaders = new HeadersList(clientCompressor.Decompress(serializedHeaders));
foreach (var t in serverHeaders)
{
Assert.Equal(decompressedHeaders.GetValue(t.Key), t.Value);
}
}
public void HeadersCompression()
{
var clientHeaders = new HeadersList
{
new KeyValuePair <string, string>(":method", "get"),
new KeyValuePair <string, string>(":path", "/Y3A9NTcuNjE2NjY1fjM5Ljg2NjY2NSZsdmw9NyZzdHk9ciZxPVlhcm9zbGF2bA=="),
new KeyValuePair <string, string>(":version", Protocols.Http2),
new KeyValuePair <string, string>(":host", "localhost"),
new KeyValuePair <string, string>(":scheme", "https"),
};
var clientCompressionProc = new CompressionProcessor();
var serverCompressionProc = new CompressionProcessor();
var serializedHeaders = clientCompressionProc.Compress(clientHeaders);
var decompressedHeaders = new HeadersList(serverCompressionProc.Decompress(serializedHeaders));
foreach (var t in clientHeaders)
{
Assert.Equal(decompressedHeaders.GetValue(t.Key), t.Value);
}
var serverHeaders = new HeadersList
{
new KeyValuePair <string, string>(":method", "get"),
new KeyValuePair <string, string>(":path", "/simpleTest.txt"),
new KeyValuePair <string, string>(":version", Protocols.Http2),
new KeyValuePair <string, string>(":host", "localhost"),
new KeyValuePair <string, string>(":scheme", "https"),
};
serializedHeaders = serverCompressionProc.Compress(serverHeaders);
decompressedHeaders = new HeadersList(clientCompressionProc.Decompress(serializedHeaders));
foreach (var t in serverHeaders)
{
Assert.Equal(decompressedHeaders.GetValue(t.Key), t.Value);
}
serverHeaders = new HeadersList
{
new KeyValuePair <string, string>(":status", StatusCode.Code404NotFound.ToString(CultureInfo.InvariantCulture)),
};
serializedHeaders = serverCompressionProc.Compress(serverHeaders);
decompressedHeaders = new HeadersList(clientCompressionProc.Decompress(serializedHeaders));
foreach (var t in serverHeaders)
{
Assert.Equal(decompressedHeaders.GetValue(t.Key), t.Value);
}
serverHeaders = new HeadersList
{
new KeyValuePair <string, string>("content-type", "text/plain"),
new KeyValuePair <string, string>("last-modified", "Wed, 23 Oct 2013 21:32:06 GMT"),
new KeyValuePair <string, string>("etag", "1cedo15cb041fc1"),
new KeyValuePair <string, string>("content-length", "749761"),
new KeyValuePair <string, string>(":status", StatusCode.Code200Ok.ToString(CultureInfo.InvariantCulture)),
};
serializedHeaders = serverCompressionProc.Compress(serverHeaders);
decompressedHeaders = new HeadersList(clientCompressionProc.Decompress(serializedHeaders));
foreach (var t in serverHeaders)
{
Assert.Equal(decompressedHeaders.GetValue(t.Key), t.Value);
}
clientHeaders = new HeadersList
{
new KeyValuePair <string, string>(":method", "get"),
new KeyValuePair <string, string>(":path", "/index.html"),
new KeyValuePair <string, string>(":version", Protocols.Http2),
new KeyValuePair <string, string>(":host", "localhost"),
new KeyValuePair <string, string>(":scheme", "https"),
};
serializedHeaders = clientCompressionProc.Compress(clientHeaders);
decompressedHeaders = new HeadersList(serverCompressionProc.Decompress(serializedHeaders));
foreach (var t in clientHeaders)
{
Assert.Equal(decompressedHeaders.GetValue(t.Key), t.Value);
}
}
