public void GetNameValueLength_DifferentScenariosWithParameters_AllReturnNonZero()
{
NameValueWithParametersHeaderValue result = null;
CallGetNameValueWithParametersLength(" name = value ; param1 = value1 ,", 1, 31, out result);
Assert.Equal("name", result.Name);
Assert.Equal("value", result.Value);
Assert.Equal(1, result.Parameters.Count);
Assert.Equal("param1", result.Parameters.First().Name);
Assert.Equal("value1", result.Parameters.First().Value);
CallGetNameValueWithParametersLength(" name=value;param1=value1;param2=value2,next", 1, 38, out result);
Assert.Equal("name", result.Name);
Assert.Equal("value", result.Value);
Assert.Equal(2, result.Parameters.Count);
Assert.Equal("param1", result.Parameters.ElementAt(0).Name);
Assert.Equal("value1", result.Parameters.ElementAt(0).Value);
Assert.Equal("param2", result.Parameters.ElementAt(1).Name);
Assert.Equal("value2", result.Parameters.ElementAt(1).Value);
CallGetNameValueWithParametersLength(" name= value ; param1 , next", 1, 23, out result);
Assert.Equal("name", result.Name);
Assert.Equal("value", result.Value);
Assert.Equal(1, result.Parameters.Count);
Assert.Equal("param1", result.Parameters.First().Name);
Assert.Null(result.Parameters.First().Value);
CallGetNameValueWithParametersLength(" name ; param1 , next", 1, 16, out result);
Assert.Equal("name", result.Name);
Assert.Null(result.Value);
Assert.Equal(1, result.Parameters.Count);
Assert.Equal("param1", result.Parameters.First().Name);
Assert.Null(result.Parameters.First().Value);
}
public void GetNameValueLength_DifferentScenariosWithNoParameters_AllReturnNonZero()
{
NameValueWithParametersHeaderValue result = null;
CallGetNameValueWithParametersLength("name=value", 0, 10, out result);
Assert.Equal("name", result.Name);
Assert.Equal("value", result.Value);
CallGetNameValueWithParametersLength(" name=value", 1, 10, out result);
Assert.Equal("name", result.Name);
Assert.Equal("value", result.Value);
CallGetNameValueWithParametersLength(" name", 1, 4, out result);
Assert.Equal("name", result.Name);
Assert.Null(result.Value);
CallGetNameValueWithParametersLength("name=\"quoted str\"", 0, 17, out result);
Assert.Equal("name", result.Name);
Assert.Equal("\"quoted str\"", result.Value);
CallGetNameValueWithParametersLength(" name=\"quoted str\"", 1, 17, out result);
Assert.Equal("name", result.Name);
Assert.Equal("\"quoted str\"", result.Value);
CallGetNameValueWithParametersLength("name\t =va1ue\"", 0, 12, out result);
Assert.Equal("name", result.Name);
Assert.Equal("va1ue", result.Value);
CallGetNameValueWithParametersLength(" name ", 1, 6, out result);
Assert.Equal("name", result.Name);
Assert.Null(result.Value);
}
public void TryParse_Invalid()
{
NameValueWithParametersHeaderValue res;
Assert.IsFalse(NameValueWithParametersHeaderValue.TryParse("", out res), "#1");
Assert.IsNull(res, "#2");
}
private void CheckValidTryParse(string input, NameValueWithParametersHeaderValue expectedResult)
{
NameValueWithParametersHeaderValue result = null;
Assert.True(NameValueWithParametersHeaderValue.TryParse(input, out result));
Assert.Equal(expectedResult, result);
}
private void CheckInvalidParse(string input)
{
Assert.Throws <FormatException>(() => { NameValueWithParametersHeaderValue.Parse(input); });
Assert.False(NameValueWithParametersHeaderValue.TryParse(input, out NameValueWithParametersHeaderValue result));
Assert.Null(result);
}
private void CheckInvalidTryParse(string input)
{
NameValueWithParametersHeaderValue result = null;
Assert.False(NameValueWithParametersHeaderValue.TryParse(input, out result));
Assert.Null(result);
}
public void TryParse_SetOfValidValueStrings_ParsedCorrectly()
{
NameValueWithParametersHeaderValue expected = new NameValueWithParametersHeaderValue("custom");
CheckValidParsedValue("\r\n custom ", 0, expected, 11);
CheckValidParsedValue("custom", 0, expected, 6);
CheckValidParsedValue(",, ,\r\n custom , chunked", 0, expected, 17);
// Note that even if the whole string is invalid, the first "Expect" value is valid. When the parser
// gets called again using the result-index (9), then it fails: I.e. we have 1 valid "Expect" value
// and an invalid one.
CheckValidParsedValue("custom , 会", 0, expected, 9);
// We don't have to test all possible input strings, since most of the pieces are handled by other parsers.
// The purpose of this test is to verify that these other parsers are combined correctly to build a
// transfer-coding parser.
expected.Parameters.Add(new NameValueHeaderValue("name", "value"));
CheckValidParsedValue("\r\n custom ; name = value ", 0, expected, 28);
CheckValidParsedValue(" custom;name=value", 2, expected, 19);
CheckValidParsedValue(" custom ; name=value", 2, expected, 21);
CheckValidParsedValue(null, 0, null, 0);
CheckValidParsedValue(string.Empty, 0, null, 0);
CheckValidParsedValue(" ", 0, null, 2);
CheckValidParsedValue(" ,,", 0, null, 4);
}
public void WhenExpectIsCalledThenRequestExpectIsSet()
{
var expect = new NameValueWithParametersHeaderValue("Foo", "bar");
_builder.Expect(expect);
Assert.AreEqual(expect, _request.Headers.Expect.First());
}
public void TryParse()
{
NameValueWithParametersHeaderValue res;
Assert.IsTrue(NameValueWithParametersHeaderValue.TryParse("a", out res), "#1");
Assert.AreEqual("a", res.Name, "#2");
Assert.IsNull(res.Value, "#3");
}
private static void CheckInvalidGetNameValueWithParametersLength(string input, int startIndex)
{
object result = null;
Assert.Equal(0, NameValueWithParametersHeaderValue.GetNameValueWithParametersLength(input, startIndex,
out result));
Assert.Null(result);
}
private static void CallGetNameValueWithParametersLength(string input, int startIndex, int expectedLength,
out NameValueWithParametersHeaderValue result)
{
object temp = null;
Assert.Equal(expectedLength, NameValueWithParametersHeaderValue.GetNameValueWithParametersLength(input,
startIndex, out temp));
result = temp as NameValueWithParametersHeaderValue;
}
public void Properties_Invalid()
{
var value = new NameValueWithParametersHeaderValue("s");
try {
value.Value = " ";
Assert.Fail("#1");
} catch (FormatException) {
}
}
public void ToString_WithAndWithoutParameters_SerializedCorrectly()
{
NameValueWithParametersHeaderValue nameValue = new NameValueWithParametersHeaderValue("text", "token");
Assert.Equal("text=token", nameValue.ToString());
nameValue.Parameters.Add(new NameValueHeaderValue("param1", "value1"));
nameValue.Parameters.Add(new NameValueHeaderValue("param2", "value2"));
Assert.Equal("text=token; param1=value1; param2=value2", nameValue.ToString());
}
private void CheckValidParsedValue(string input, int startIndex,
NameValueWithParametersHeaderValue expectedResult, int expectedIndex)
{
HttpHeaderParser parser = GenericHeaderParser.MultipleValueNameValueWithParametersParser;
object result = null;
Assert.True(parser.TryParseValue(input, null, ref startIndex, out result),
string.Format("TryParse returned false. Input: '{0}', Index: {1}", input, startIndex));
Assert.Equal(expectedIndex, startIndex);
Assert.Equal(result, expectedResult);
}
public void Parse_ValidValue_ReturnsNameValueWithParametersHeaderValue()
{
// This test verifies that Parse() correctly calls TryParse().
HttpHeaderParser parser = GenericHeaderParser.MultipleValueNameValueWithParametersParser;
int index = 2;
NameValueWithParametersHeaderValue expected = new NameValueWithParametersHeaderValue("custom");
expected.Parameters.Add(new NameValueHeaderValue("name", "value"));
Assert.True(expected.Equals(parser.ParseValue(" custom ; name = value ", null, ref index)));
Assert.Equal(25, index);
}
public void Clone_Call_CloneFieldsMatchSourceFields()
{
NameValueWithParametersHeaderValue source = new NameValueWithParametersHeaderValue("name", "value");
source.Parameters.Add(new NameValueHeaderValue("param1", "value1"));
NameValueWithParametersHeaderValue clone = (NameValueWithParametersHeaderValue)((ICloneable)source).Clone();
Assert.Equal(source.Name, clone.Name);
Assert.Equal(source.Value, clone.Value);
Assert.Equal(1, clone.Parameters.Count);
Assert.Equal("param1", clone.Parameters.First().Name);
Assert.Equal("value1", clone.Parameters.First().Value);
}
public void Ctor_CallBaseCtor_Success()
{
// Just make sure the base ctor gets called correctly. Validation of input parameters is done in the base
// class.
NameValueWithParametersHeaderValue nameValue = new NameValueWithParametersHeaderValue("name");
Assert.Equal("name", nameValue.Name);
Assert.Null(nameValue.Value);
nameValue = new NameValueWithParametersHeaderValue("name", "value");
Assert.Equal("name", nameValue.Name);
Assert.Equal("value", nameValue.Value);
}
public void Properties()
{
var value = new NameValueWithParametersHeaderValue("s", "p");
Assert.AreEqual("s", value.Name, "#1");
Assert.AreEqual("p", value.Value, "#2");
value = new NameValueWithParametersHeaderValue("s");
Assert.AreEqual("s", value.Name, "#3");
Assert.IsNull(value.Value, "#4");
value.Value = "bb";
Assert.AreEqual("bb", value.Value, "#5");
}
public void GetHashCode_ValuesUseDifferentValues_HashDiffersAccordingToRfc()
{
NameValueWithParametersHeaderValue nameValue1 = new NameValueWithParametersHeaderValue("text");
NameValueWithParametersHeaderValue nameValue2 = new NameValueWithParametersHeaderValue("text");
// NameValueWithParametersHeaderValue just calls methods of the base class. Just verify Parameters is used.
Assert.Equal(nameValue1.GetHashCode(), nameValue2.GetHashCode());
nameValue1.Parameters.Add(new NameValueHeaderValue("param1", "value1"));
nameValue2.Value = null;
Assert.NotEqual(nameValue1.GetHashCode(), nameValue2.GetHashCode());
nameValue2.Parameters.Add(new NameValueHeaderValue("param1", "value1"));
Assert.Equal(nameValue1.GetHashCode(), nameValue2.GetHashCode());
}
public void TryParse_SetOfValidValueStrings_ParsedCorrectly()
{
NameValueWithParametersHeaderValue expected = new NameValueWithParametersHeaderValue("custom");
CheckValidTryParse("\r\n custom ", expected);
CheckValidTryParse("custom", expected);
// We don't have to test all possible input strings, since most of the pieces are handled by other parsers.
// The purpose of this test is to verify that these other parsers are combined correctly to build a
// transfer-coding parser.
expected.Parameters.Add(new NameValueHeaderValue("name", "value"));
CheckValidTryParse("\r\n custom ; name = value ", expected);
CheckValidTryParse(" custom;name=value", expected);
CheckValidTryParse(" custom ; name=value", expected);
}
public void Parse()
{
var res = NameValueWithParametersHeaderValue.Parse("c");
Assert.AreEqual("c", res.Name, "#1");
Assert.AreEqual("c", res.ToString(), "#1b");
Assert.IsNull(res.Value, "#2");
res = NameValueWithParametersHeaderValue.Parse("a=2 ; b = 555");
Assert.AreEqual("a", res.Name, "#3");
Assert.AreEqual("a=2; b=555", res.ToString(), "#3b");
Assert.AreEqual("2", res.Value, "#4");
Assert.AreEqual("b", res.Parameters.First().Name, "#5");
Assert.AreEqual(1, res.Parameters.Count, "#6");
}
private static void SetDeflateNegotiationResponse(HttpContext context, WebSocketDeflateCompressionProvider deflateCompressionProvider)
{
NameValueWithParametersHeaderValue secWebSocketExtensionsHeaderValue = new NameValueWithParametersHeaderValue(WEBSOCKET_PERMESSAGE_DEFLATE_EXTENSION);
if (deflateCompressionProvider.ClientNoContextTakeover)
{
secWebSocketExtensionsHeaderValue.Parameters.Add(new NameValueHeaderValue(WebSocketDeflateCompressionOptions.CLIENT_NO_CONTEXT_TAKEOVER_OPTION));
}
if (deflateCompressionProvider.ServerNoContextTakeover)
{
secWebSocketExtensionsHeaderValue.Parameters.Add(new NameValueHeaderValue(WebSocketDeflateCompressionOptions.SERVER_NO_CONTEXT_TAKEOVER_OPTION));
}
context.Response.Headers[HeaderNames.SecWebSocketExtensions] = secWebSocketExtensionsHeaderValue.ToString();
}
public void Equals_ValuesUseDifferentValues_ValuesAreEqualOrDifferentAccordingToRfc()
{
NameValueWithParametersHeaderValue nameValue1 = new NameValueWithParametersHeaderValue("text", "value");
NameValueWithParametersHeaderValue nameValue2 = new NameValueWithParametersHeaderValue("text", "value");
NameValueHeaderValue nameValue3 = new NameValueHeaderValue("text", "value");
// NameValueWithParametersHeaderValue just calls methods of the base class. Just verify Parameters is used.
Assert.True(nameValue1.Equals(nameValue2), "No parameters.");
Assert.False(nameValue1.Equals(null), "Compare to null.");
Assert.False(nameValue1.Equals(nameValue3), "Compare to base class instance.");
nameValue1.Parameters.Add(new NameValueHeaderValue("param1", "value1"));
Assert.False(nameValue1.Equals(nameValue2), "none vs. 1 parameter.");
nameValue2.Parameters.Add(new NameValueHeaderValue("param1", "value1"));
Assert.True(nameValue1.Equals(nameValue2), "1 parameter vs. 1 parameter.");
}
private static WebSocketDeflateCompressionOptions GetDeflateNegotiationOffer(HttpContext context)
{
WebSocketDeflateCompressionOptions compressionOptions = null;
foreach (string headerValue in context.Request.Headers.GetCommaSeparatedValues(HeaderNames.SecWebSocketExtensions))
{
NameValueWithParametersHeaderValue parsedHeaderValue;
if (NameValueWithParametersHeaderValue.TryParse(headerValue, out parsedHeaderValue) && parsedHeaderValue.Name == WEBSOCKET_PERMESSAGE_DEFLATE_EXTENSION)
{
compressionOptions = WebSocketDeflateCompressionOptions.FromHeaderValue(parsedHeaderValue);
break;
}
}
return(compressionOptions);
}
public void Equals()
{
var value = new NameValueWithParametersHeaderValue("ab");
Assert.AreEqual(value, new NameValueWithParametersHeaderValue("ab"), "#1");
Assert.AreEqual(value, new NameValueWithParametersHeaderValue("AB"), "#2");
Assert.AreNotEqual(value, new NameValueWithParametersHeaderValue("AA"), "#3");
var second = new NameValueWithParametersHeaderValue("AB");
second.Parameters.Add(new NameValueHeaderValue("pv"));
Assert.AreNotEqual(value, second, "#4");
value.Parameters.Add(new NameValueHeaderValue("pv"));
Assert.AreEqual(value, second, "#5");
}
private void CheckValidParse(string input, NameValueWithParametersHeaderValue expectedResult)
{
NameValueWithParametersHeaderValue result = NameValueWithParametersHeaderValue.Parse(input);
Assert.Equal(expectedResult, result);
Assert.True(NameValueWithParametersHeaderValue.TryParse(input, out result));
Assert.Equal(expectedResult, result);
// New lines are never allowed
for (int i = 0; i < input.Length; i++)
{
CheckInvalidParse(input.Insert(i, "\r"));
CheckInvalidParse(input.Insert(i, "\n"));
CheckInvalidParse(input.Insert(i, "\r\n"));
CheckInvalidParse(input.Insert(i, "\r\n "));
}
}
public void Parse_Invalid()
{
try {
NameValueWithParametersHeaderValue.Parse(null);
Assert.Fail("#1");
} catch (FormatException) {
}
try {
NameValueWithParametersHeaderValue.Parse(" ");
Assert.Fail("#2");
} catch (FormatException) {
}
try {
NameValueWithParametersHeaderValue.Parse("a=1;");
Assert.Fail("#3");
} catch (FormatException) {
}
}
/// <summary>
/// Creates new instance of <see cref="WebSocketDeflateCompressionOptions"/> from header value.
/// </summary>
/// <param name="headerValue">The header value.</param>
/// <returns>New instance of <see cref="WebSocketDeflateCompressionOptions"/>.</returns>
public static WebSocketDeflateCompressionOptions FromHeaderValue(NameValueWithParametersHeaderValue headerValue)
{
WebSocketDeflateCompressionOptions compressionOptions = new WebSocketDeflateCompressionOptions();
foreach (NameValueHeaderValue parameterValue in headerValue.Parameters)
{
switch (parameterValue.Name.ToLowerInvariant())
{
case SERVER_NO_CONTEXT_TAKEOVER_OPTION:
compressionOptions = SetAndEnsureServerNoContextTakeover(compressionOptions);
break;
case CLIENT_NO_CONTEXT_TAKEOVER_OPTION:
compressionOptions = SetAndEnsureClientNoContextTakeover(compressionOptions);
break;
case SERVER_MAX_WINDOW_BITS_OPTION:
compressionOptions = SetAndEnsureServerMaxWindowBits(compressionOptions, parameterValue.Value);
break;
case CLIENT_MAX_WINDOW_BITS_OPTION:
compressionOptions = SetAndEnsureClientMaxWindowBits(compressionOptions, parameterValue.Value);
break;
default:
compressionOptions = null;
break;
}
if (compressionOptions == null)
{
break;
}
}
return(compressionOptions);
}
public void Parameters_AddNull_Throw()
{
NameValueWithParametersHeaderValue nameValue = new NameValueWithParametersHeaderValue("name");
Assert.Throws <ArgumentNullException>(() => { nameValue.Parameters.Add(null); });
}
private void CheckInvalidParse(string input)
{
Assert.Throws <FormatException>(() => { NameValueWithParametersHeaderValue.Parse(input); });
}
