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()); }