public void CopyTo_ArrayTooSmall_Throw()
{
MockHeaders headers = new MockHeaders();
HttpHeaderValueCollection <string> collection = new HttpHeaderValueCollection <string>(knownStringHeader, headers);
string[] array = new string[1];
array[0] = null;
collection.CopyTo(array, 0); // no exception
Assert.Null(array[0]);
Assert.Throws <ArgumentNullException>(() => { collection.CopyTo(null, 0); });
Assert.Throws <ArgumentOutOfRangeException>(() => { collection.CopyTo(array, -1); });
Assert.Throws <ArgumentOutOfRangeException>(() => { collection.CopyTo(array, 2); });
headers.Add(knownStringHeader, "special");
array = new string[0];
AssertExtensions.Throws <ArgumentException>(null, () => { collection.CopyTo(array, 0); });
headers.Add(knownStringHeader, "special");
headers.Add(knownStringHeader, "special");
array = new string[1];
AssertExtensions.Throws <ArgumentException>(() => { collection.CopyTo(array, 0); });
headers.Add(knownStringHeader, "value1");
array = new string[0];
AssertExtensions.Throws <ArgumentException>(() => { collection.CopyTo(array, 0); });
headers.Add(knownStringHeader, "value2");
array = new string[1];
AssertExtensions.Throws <ArgumentException>(() => { collection.CopyTo(array, 0); });
array = new string[2];
AssertExtensions.Throws <ArgumentException>(() => { collection.CopyTo(array, 1); });
}
public void Count_AddMultipleValuesThenQueryCount_ReturnsValueCountWithSpecialValues()
{
MockHeaders headers = new MockHeaders(knownHeader, new MockHeaderParser(typeof(string)));
HttpHeaderValueCollection<string> collection = new HttpHeaderValueCollection<string>(knownHeader, headers,
"special");
Assert.Equal(0, collection.Count);
collection.Add("value1");
headers.Add(knownHeader, "special");
Assert.Equal(2, collection.Count);
headers.Add(knownHeader, "special");
headers.Add(knownHeader, "value2");
headers.Add(knownHeader, "special");
Assert.Equal(5, collection.Count);
}
public void Count_AddMultipleValuesThenQueryCount_ReturnsValueCountWithSpecialValues()
{
MockHeaders headers = new MockHeaders();
HttpHeaderValueCollection <string> collection = new HttpHeaderValueCollection <string>(knownStringHeader, headers,
"special");
Assert.Equal(0, collection.Count);
collection.Add("value1");
headers.Add(knownStringHeader, "special");
Assert.Equal(2, collection.Count);
headers.Add(knownStringHeader, "special");
headers.Add(knownStringHeader, "value2");
headers.Add(knownStringHeader, "special");
Assert.Equal(5, collection.Count);
}
public void Count_AddSingleValueThenQueryCount_ReturnsValueCountWithSpecialValues()
{
MockHeaders headers = new MockHeaders();
HttpHeaderValueCollection <string> collection = new HttpHeaderValueCollection <string>(knownStringHeader, headers,
"special");
Assert.Equal(0, collection.Count);
headers.Add(knownStringHeader, "value2");
Assert.Equal(1, collection.Count);
headers.Clear();
headers.Add(knownStringHeader, "special");
Assert.Equal(1, collection.Count);
headers.Add(knownStringHeader, "special");
headers.Add(knownStringHeader, "special");
Assert.Equal(3, collection.Count);
}
public void CopyTo_OnlySpecialValue_Copied()
{
MockHeaders headers = new MockHeaders();
HttpHeaderValueCollection <Uri> collection = new HttpHeaderValueCollection <Uri>(knownUriHeader, headers,
specialValue);
collection.SetSpecialValue();
headers.Add(knownUriHeader, specialValue.ToString());
headers.Add(knownUriHeader, specialValue.ToString());
headers.Add(knownUriHeader, specialValue.ToString());
Uri[] array = new Uri[4];
array[0] = null;
collection.CopyTo(array, 0);
Assert.Equal(specialValue, array[0]);
Assert.Equal(specialValue, array[1]);
Assert.Equal(specialValue, array[2]);
Assert.Equal(specialValue, array[3]);
Assert.True(collection.IsSpecialValueSet, "Special value not set.");
}
public void CopyTo_OnlySpecialValueEmptyDestination_Copied()
{
MockHeaders headers = new MockHeaders(knownHeader, new MockHeaderParser(typeof(Uri)));
HttpHeaderValueCollection <Uri> collection = new HttpHeaderValueCollection <Uri>(knownHeader, headers,
specialValue);
collection.SetSpecialValue();
headers.Add(knownHeader, specialValue.ToString());
Uri[] array = new Uri[2];
collection.CopyTo(array, 0);
Assert.Equal(specialValue, array[0]);
Assert.Equal(specialValue, array[1]);
Assert.True(collection.IsSpecialValueSet, "Special value not set.");
}
public void CopyTo_AddSingleValue_ContainsSingleValue()
{
MockHeaders headers = new MockHeaders();
HttpHeaderValueCollection <Uri> collection = new HttpHeaderValueCollection <Uri>(knownUriHeader, headers,
specialValue);
collection.Add(new Uri("http://www.example.org/"));
Uri[] array = new Uri[1];
collection.CopyTo(array, 0);
Assert.Equal(new Uri("http://www.example.org/"), array[0]);
// Now only set the special value: nothing should be added to the array.
headers.Clear();
headers.Add(knownUriHeader, specialValue.ToString());
array[0] = null;
collection.CopyTo(array, 0);
Assert.Equal(specialValue, array[0]);
}
public void Add_SingleAddCustomHeaderWithNullValue_HeaderIsAddedWithEmptyStringValue()
{
MockHeaders headers = new MockHeaders();
headers.Add(customHeader, (string)null);
Assert.Equal(0, headers.Parser.TryParseValueCallCount);
Assert.Equal(1, headers.Count());
Assert.Equal(1, headers.First().Value.Count());
Assert.Equal(string.Empty, headers.First().Value.ElementAt(0));
// We're using a custom header. No parsing should be triggered.
Assert.Equal(0, headers.Parser.TryParseValueCallCount);
}
public void Add_MultipleAddNullValueCollection_Throw()
{
MockHeaders headers = new MockHeaders();
string[] values = null;
Assert.Throws<ArgumentNullException>(() => { headers.Add(knownHeader, values); });
}
public void Add_SingleAddInvalidValueToNonExistingHeader_ThrowAndDontAddHeader()
{
// Since Add() immediately parses the value, it will throw an exception if the value is invalid.
MockHeaders headers = new MockHeaders();
Assert.Throws<FormatException>(() => { headers.Add(knownHeader, invalidHeaderValue); });
// Make sure the header did not get added to the store.
Assert.False(headers.Contains(knownHeader),
"No header expected to be added since header value was invalid.");
}
public void Add_SingleUseNullHeaderName_Throw()
{
MockHeaders headers = new MockHeaders();
Assert.Throws<ArgumentException>(() => { headers.Add(null, "value"); });
}
public void Add_SingleAddValidValue_ValueParsedCorrectly()
{
MockHeaders headers = new MockHeaders();
headers.Add(knownHeader, rawPrefix);
// Add() should trigger parsing.
Assert.Equal(1, headers.Parser.TryParseValueCallCount);
Assert.Equal(1, headers.Count());
Assert.Equal(1, headers.First().Value.Count());
Assert.Equal(parsedPrefix, headers.First().Value.ElementAt(0));
// Value is already parsed. There shouldn't be additional calls to the parser.
Assert.Equal(1, headers.Parser.TryParseValueCallCount);
}
public void RemoveParsedValue_AddTwoValuesAndRemoveSecondOne_FirstValueRemains()
{
MockHeaders headers = new MockHeaders();
headers.Add(knownHeader, rawPrefix + "1");
headers.Add(knownHeader, rawPrefix + "2");
// Remove the parsed value (note the original string 'raw2' was "parsed" to 'parsed2')
Assert.True(headers.RemoveParsedValue(knownHeader, parsedPrefix + "2"));
Assert.Equal(2, headers.Parser.TryParseValueCallCount);
// Note that when the last value of a header gets removed, the whole header gets removed.
Assert.Equal(1, headers.Count());
Assert.Equal(1, headers.First().Value.Count());
Assert.Equal(parsedPrefix + "1", headers.First().Value.ElementAt(0));
Assert.Equal(2, headers.Parser.TryParseValueCallCount);
}
public void RemoveParsedValue_AddValueAndRemoveIt_NoHeader()
{
MockHeaders headers = new MockHeaders();
headers.Add(knownHeader, rawPrefix + "1");
// Remove the parsed value (note the original string 'raw1' was "parsed" to 'parsed1')
Assert.True(headers.RemoveParsedValue(knownHeader, parsedPrefix + "1"));
Assert.Equal(1, headers.Parser.TryParseValueCallCount);
// Note that when the last value of a header gets removed, the whole header gets removed.
Assert.Equal(0, headers.Count());
Assert.Equal(1, headers.Parser.TryParseValueCallCount);
// Remove the value again: It shouldn't be found in the store.
Assert.False(headers.RemoveParsedValue(knownHeader, parsedPrefix + "1"));
}
public void Add_SingleFirstAddThenTryAddWithoutValidation_TwoParsedValuesAdded()
{
MockHeaders headers = new MockHeaders();
headers.Add(knownHeader, rawPrefix + "1");
headers.TryAddWithoutValidation(knownHeader, rawPrefix + "2");
// Add() should trigger parsing. Since TryAddWithoutValidation() is called afterwards the second value is
// not parsed yet.
Assert.Equal(1, headers.Parser.TryParseValueCallCount);
Assert.Equal(1, headers.Count());
Assert.Equal(2, headers.First().Value.Count());
Assert.Equal(parsedPrefix + "1", headers.First().Value.ElementAt(0));
Assert.Equal(parsedPrefix + "2", headers.First().Value.ElementAt(1));
// Value is already parsed. There shouldn't be additional calls to the parser.
Assert.Equal(2, headers.Parser.TryParseValueCallCount);
}
public void Add_SingleFirstTryAddWithoutValidationForEmptyValueThenAdd_OneParsedValueAddedEmptyIgnored()
{
MockHeaders headers = new MockHeaders();
headers.TryAddWithoutValidation(knownHeader, string.Empty);
headers.Add(knownHeader, rawPrefix + "1");
// Add() should trigger parsing. TryAddWithoutValidation() doesn't trigger parsing, but Add() triggers
// parsing of raw header values (TryParseValue() is called)
Assert.Equal(2, headers.Parser.TryParseValueCallCount);
Assert.Equal(1, headers.Count());
Assert.Equal(1, headers.First().Value.Count());
Assert.Equal(parsedPrefix + "1", headers.First().Value.ElementAt(0));
// Value is already parsed. There shouldn't be additional calls to the parser.
Assert.Equal(2, headers.Parser.TryParseValueCallCount);
}
public void Add_SingleAddTwoValidValuesToHeaderWithSingleValue_Throw()
{
MockHeaderParser parser = new MockHeaderParser(false); // doesn't support multiple values.
MockHeaders headers = new MockHeaders(parser);
try
{
headers.Add(knownHeader, rawPrefix + "1");
}
catch (Exception e)
{
Assert.True(false, string.Format("Adding the first header already threw exception: {0}", e));
}
Assert.Throws<FormatException>(() => { headers.Add(knownHeader, rawPrefix + "2"); });
// Verify that the first header value is still there.
Assert.Equal(1, headers.First().Value.Count());
}
public void Add_MultipleAddValidValueThenAddInvalidValuesToNonExistingHeader_ThrowAndDontAddHeader()
{
MockHeaders headers = new MockHeaders();
Assert.Throws<FormatException>(() => { headers.Add(knownHeader, new string[] { rawPrefix + "1", invalidHeaderValue }); });
// Make sure the header got added due to the valid add. Note that the first value in the array
// is valid, so it gets added.
Assert.True(headers.Contains(knownHeader), "Header was not added even though we added 1 valid value.");
Assert.Equal(1, headers.First().Value.Count());
Assert.Equal(parsedPrefix + "1", headers.First().Value.ElementAt(0));
}
public void Add_MultipleAddValidValueThenAddInvalidValuesToExistingHeader_ThrowAndDontAddHeader()
{
MockHeaders headers = new MockHeaders();
headers.Add(knownHeader, rawPrefix + "1");
Assert.Throws<FormatException>(() => { headers.Add(knownHeader, new string[] { rawPrefix + "2", invalidHeaderValue }); });
// Make sure the header did not get removed due to the failed add. Note that the first value in the array
// is valid, so it gets added. I.e. we have 2 values.
Assert.True(headers.Contains(knownHeader), "Header was removed even if there is a valid header value.");
Assert.Equal(2, headers.First().Value.Count());
Assert.Equal(parsedPrefix + "1", headers.First().Value.ElementAt(0));
Assert.Equal(parsedPrefix + "2", headers.First().Value.ElementAt(1));
}
public void Add_MultipleAddInvalidValuesToNonExistingHeader_ThrowAndDontAddHeader()
{
MockHeaders headers = new MockHeaders();
Assert.Throws<FormatException>(() => { headers.Add(knownHeader, new string[] { invalidHeaderValue }); });
// Make sure the header did not get added since we just tried to add an invalid value.
Assert.False(headers.Contains(knownHeader), "Header was added even if we just added an invalid value.");
}
public void Add_SingleAddValidValueThenAddInvalidValue_ThrowAndHeaderContainsValidValue()
{
MockHeaders headers = new MockHeaders();
headers.Add(knownHeader, rawPrefix);
Assert.Throws<FormatException>(() => { headers.Add(knownHeader, invalidHeaderValue); });
// Make sure the header did not get removed due to the failed add.
Assert.True(headers.Contains(knownHeader), "Header was removed even if there is a valid header value.");
Assert.Equal(1, headers.First().Value.Count());
Assert.Equal(parsedPrefix, headers.First().Value.ElementAt(0));
}
public void Add_SingleAddHeadersWithDifferentCasing_ConsideredTheSameHeader()
{
MockHeaders headers = new MockHeaders();
headers.Add("custom-header", "value1");
headers.Add("Custom-Header", "value2");
headers.Add("CUSTOM-HEADER", "value2");
Assert.Equal(3, headers.GetValues("custom-header").Count());
Assert.Equal(3, headers.GetValues("Custom-Header").Count());
Assert.Equal(3, headers.GetValues("CUSTOM-HEADER").Count());
Assert.Equal(3, headers.GetValues("CuStOm-HeAdEr").Count());
}
public void Add_AddValueContainingNewLine_NewLineFollowedByWhitespaceIsOKButNewLineFollowedByNonWhitespaceIsRejected()
{
MockHeaders headers = new MockHeaders();
headers.Clear();
headers.Add("custom", "value\r");
Assert.Equal(1, headers.Count());
Assert.Equal(1, headers.First().Value.Count());
Assert.Equal("value\r", headers.First().Value.First());
headers.Clear();
Assert.Throws<FormatException>(() => { headers.Add("custom", new string[] { "valid\n", "invalid\r\nother" }); });
Assert.Equal(1, headers.Count());
Assert.Equal(1, headers.First().Value.Count());
Assert.Equal("valid\n", headers.First().Value.First());
}
public void Add_SingleAddThenTryAddWithoutValidationThenAdd_ThreeParsedValuesAdded()
{
MockHeaders headers = new MockHeaders();
headers.Add(knownHeader, rawPrefix + "1");
headers.TryAddWithoutValidation(knownHeader, rawPrefix + "2");
headers.Add(knownHeader, rawPrefix + "3");
// The second Add() triggers also parsing of the value added by TryAddWithoutValidation()
Assert.Equal(3, headers.Parser.TryParseValueCallCount);
Assert.Equal(1, headers.Count());
Assert.Equal(3, headers.First().Value.Count());
Assert.Equal(parsedPrefix + "1", headers.First().Value.ElementAt(0));
Assert.Equal(parsedPrefix + "2", headers.First().Value.ElementAt(1));
Assert.Equal(parsedPrefix + "3", headers.First().Value.ElementAt(2));
// Value is already parsed. There shouldn't be additional calls to the parser.
Assert.Equal(3, headers.Parser.TryParseValueCallCount);
}
public void RemoveParsedValue_AddTwoValuesAndRemoveThem_NoHeader()
{
MockHeaders headers = new MockHeaders();
headers.Add(knownHeader, rawPrefix + "1");
headers.Add(knownHeader, rawPrefix + "2");
// Remove the parsed value (note the original string 'raw1' was "parsed" to 'parsed1')
Assert.True(headers.RemoveParsedValue(knownHeader, parsedPrefix + "1"));
Assert.True(headers.RemoveParsedValue(knownHeader, parsedPrefix + "2"));
Assert.Equal(2, headers.Parser.TryParseValueCallCount);
// Note that when the last value of a header gets removed, the whole header gets removed.
Assert.Equal(0, headers.Count());
Assert.Equal(2, headers.Parser.TryParseValueCallCount);
}
public void Add_SingleFirstTryAddWithoutValidationThenAddToSingleValueHeader_AddThrows()
{
MockHeaderParser parser = new MockHeaderParser(false); // doesn't support multiple values.
MockHeaders headers = new MockHeaders(parser);
headers.TryAddWithoutValidation(knownHeader, rawPrefix + "1");
Assert.Throws<FormatException>(() => {headers.Add(knownHeader, rawPrefix + "2"); });
}
public void RemoveParsedValue_RemoveFromNonExistingHeader_ReturnsFalse()
{
MockHeaders headers = new MockHeaders();
headers.Add(knownHeader, rawPrefix);
// Header 'non-existing-header' can't be found, so false is returned.
Assert.False(headers.RemoveParsedValue("non-existing-header", "doesntexist"));
}
public void CopyTo_AddSingleValue_ContainsSingleValue()
{
MockHeaders headers = new MockHeaders(knownHeader, new MockHeaderParser(typeof(Uri)));
HttpHeaderValueCollection<Uri> collection = new HttpHeaderValueCollection<Uri>(knownHeader, headers,
specialValue);
collection.Add(new Uri("http://www.example.org/"));
Uri[] array = new Uri[1];
collection.CopyTo(array, 0);
Assert.Equal(new Uri("http://www.example.org/"), array[0]);
// Now only set the special value: nothing should be added to the array.
headers.Clear();
headers.Add(knownHeader, specialValue.ToString());
array[0] = null;
collection.CopyTo(array, 0);
Assert.Equal(specialValue, array[0]);
}
public void CopyTo_ArrayTooSmall_Throw()
{
MockHeaders headers = new MockHeaders(knownHeader, new MockHeaderParser(typeof(string)));
HttpHeaderValueCollection<string> collection = new HttpHeaderValueCollection<string>(knownHeader, headers,
"special");
string[] array = new string[1];
array[0] = null;
collection.CopyTo(array, 0); // no exception
Assert.Null(array[0]);
Assert.Throws<ArgumentNullException>(() => { collection.CopyTo(null, 0); });
Assert.Throws<ArgumentOutOfRangeException>(() => { collection.CopyTo(array, -1); });
Assert.Throws<ArgumentOutOfRangeException>(() => { collection.CopyTo(array, 2); });
headers.Add(knownHeader, "special");
array = new string[0];
Assert.Throws<ArgumentException>(() => { collection.CopyTo(array, 0); });
headers.Add(knownHeader, "special");
headers.Add(knownHeader, "special");
array = new string[1];
Assert.Throws<ArgumentException>(() => { collection.CopyTo(array, 0); });
headers.Add(knownHeader, "value1");
array = new string[0];
Assert.Throws<ArgumentException>(() => { collection.CopyTo(array, 0); });
headers.Add(knownHeader, "value2");
array = new string[1];
Assert.Throws<ArgumentException>(() => { collection.CopyTo(array, 0); });
array = new string[2];
Assert.Throws<ArgumentException>(() => { collection.CopyTo(array, 1); });
}
public void AddHeaders_DestinationHasEmptyHeaderStore_DestinationHeaderStoreGetsCreatedAndValuesAdded()
{
Dictionary<string, HttpHeaderParser> parserStore = new Dictionary<string, HttpHeaderParser>();
parserStore.Add("known1", new MockHeaderParser());
MockHeaders source = new MockHeaders(parserStore);
source.Add("known1", rawPrefix);
MockHeaders destination = new MockHeaders(parserStore);
destination.AddHeaders(source);
Assert.Equal(1, destination.Count());
}
public void Add_SingleFirstAddThenTryAddWithoutValidationToSingleValueHeader_BothParsedAndInvalidValue()
{
MockHeaderParser parser = new MockHeaderParser(false); // doesn't support multiple values.
MockHeaders headers = new MockHeaders(parser);
headers.Add(knownHeader, rawPrefix + "1");
headers.TryAddWithoutValidation(knownHeader, rawPrefix + "2");
Assert.Equal(1, headers.Parser.TryParseValueCallCount);
// Add() succeeds since we don't have a value added yet. TryAddWithoutValidation() also succeeds, however
// the value is added to the 'invalid values' list when retrieved.
Assert.Equal(1, headers.Count());
Assert.Equal(2, headers.First().Value.Count());
Assert.Equal(parsedPrefix + "1", headers.First().Value.ElementAt(0));
Assert.Equal(rawPrefix + "2", headers.First().Value.ElementAt(1));
// Note that TryParseValue() is not called because HttpHeaders sees that there is already a value
// so it adds the raw value to 'invalid values'.
Assert.Equal(1, headers.Parser.TryParseValueCallCount);
}
public void Add_SingleAddEmptyValueMultipleTimes_EmptyHeaderAdded()
{
MockHeaders headers = new MockHeaders();
headers.Add(knownHeader, (string)null);
headers.Add(knownHeader, string.Empty);
headers.Add(knownHeader, string.Empty);
// Add() should trigger parsing.
Assert.Equal(3, headers.Parser.TryParseValueCallCount);
Assert.Equal(0, headers.Count());
}
public void CopyTo_OnlySpecialValueEmptyDestination_Copied()
{
MockHeaders headers = new MockHeaders(knownHeader, new MockHeaderParser(typeof(Uri)));
HttpHeaderValueCollection<Uri> collection = new HttpHeaderValueCollection<Uri>(knownHeader, headers,
specialValue);
collection.SetSpecialValue();
headers.Add(knownHeader, specialValue.ToString());
Uri[] array = new Uri[2];
collection.CopyTo(array, 0);
Assert.Equal(specialValue, array[0]);
Assert.Equal(specialValue, array[1]);
Assert.True(collection.IsSpecialValueSet, "Special value not set.");
}
public void Add_MultipleAddThreeValidValuesAsOneString_BothValuesParsed()
{
MockHeaders headers = new MockHeaders();
headers.Add(knownHeader, rawPrefix + "1," + rawPrefix + "2," + rawPrefix + "3");
Assert.Equal(3, headers.Parser.TryParseValueCallCount);
Assert.Equal(1, headers.Count());
Assert.Equal(3, headers.First().Value.Count());
Assert.Equal(parsedPrefix + "1", headers.First().Value.ElementAt(0));
Assert.Equal(parsedPrefix + "2", headers.First().Value.ElementAt(1));
Assert.Equal(parsedPrefix + "3", headers.First().Value.ElementAt(2));
}
public void Add_MultipleAddThreeValidValuesWithOneCall_ValuesParsedCorrectly()
{
MockHeaders headers = new MockHeaders();
string[] values = new string[] { rawPrefix + "1", rawPrefix + "2", rawPrefix + "3" };
headers.Add(knownHeader, values);
// Add() should trigger parsing.
Assert.Equal(3, headers.Parser.TryParseValueCallCount);
Assert.Equal(1, headers.Count());
Assert.Equal(3, headers.First().Value.Count());
Assert.Equal(parsedPrefix + "1", headers.First().Value.ElementAt(0));
Assert.Equal(parsedPrefix + "2", headers.First().Value.ElementAt(1));
Assert.Equal(parsedPrefix + "3", headers.First().Value.ElementAt(2));
// Value is already parsed. There shouldn't be additional calls to the parser.
Assert.Equal(3, headers.Parser.TryParseValueCallCount);
}
public void AddHeaders_SourceHasEmptyHeaderStore_DestinationRemainsUnchanged()
{
Dictionary<string, HttpHeaderParser> parserStore = new Dictionary<string, HttpHeaderParser>();
parserStore.Add("known1", new MockHeaderParser());
MockHeaders source = new MockHeaders(parserStore);
MockHeaders destination = new MockHeaders(parserStore);
destination.Add("known1", rawPrefix);
destination.AddHeaders(source);
Assert.Equal(1, destination.Count());
}
