private void CheckValidTryParse(string input, RangeHeaderValue expectedResult) { RangeHeaderValue result = null; Assert.True(RangeHeaderValue.TryParse(input, out result)); Assert.Equal(expectedResult, result); }
public void Equals_UseSameAndDifferentRanges_EqualOrNotEqualNoExceptions() { var range1 = new RangeHeaderValue(1, 2); var range2 = new RangeHeaderValue(1, 2); range2.Unit = "BYTES"; var range3 = new RangeHeaderValue(1, null); var range4 = new RangeHeaderValue(null, 2); var range5 = new RangeHeaderValue(); range5.Ranges.Add(new RangeItemHeaderValue(1, 2)); range5.Ranges.Add(new RangeItemHeaderValue(3, 4)); var range6 = new RangeHeaderValue(); range6.Ranges.Add(new RangeItemHeaderValue(3, 4)); // reverse order of range5 range6.Ranges.Add(new RangeItemHeaderValue(1, 2)); var range7 = new RangeHeaderValue(1, 2); range7.Unit = "other"; Assert.False(range1.Equals(null), "bytes=1-2 vs. <null>"); Assert.True(range1.Equals(range2), "bytes=1-2 vs. BYTES=1-2"); Assert.False(range1.Equals(range3), "bytes=1-2 vs. bytes=1-"); Assert.False(range1.Equals(range4), "bytes=1-2 vs. bytes=-2"); Assert.False(range1.Equals(range5), "bytes=1-2 vs. bytes=1-2,3-4"); Assert.True(range5.Equals(range6), "bytes=1-2,3-4 vs. bytes=3-4,1-2"); Assert.False(range1.Equals(range7), "bytes=1-2 vs. other=1-2"); }
private void CheckInvalidTryParse(string input) { RangeHeaderValue result = null; Assert.False(RangeHeaderValue.TryParse(input, out result)); Assert.Null(result); }
public static RangeHeaderValue GetRanges(this HttpContext context, long contentSize) { RangeHeaderValue rangesResult = null; string rangeHeader = context.Request.Headers["Range"]; if (!string.IsNullOrEmpty(rangeHeader)) { // rangeHeader contains the value of the Range HTTP Header and can have values like: // Range: bytes=0-1 * Get bytes 0 and 1, inclusive // Range: bytes=0-500 * Get bytes 0 to 500 (the first 501 bytes), inclusive // Range: bytes=400-1000 * Get bytes 500 to 1000 (501 bytes in total), inclusive // Range: bytes=-200 * Get the last 200 bytes // Range: bytes=500- * Get all bytes from byte 500 to the end // // Can also have multiple ranges delimited by commas, as in: // Range: bytes=0-500,600-1000 * Get bytes 0-500 (the first 501 bytes), inclusive plus bytes 600-1000 (401 bytes) inclusive // Remove "Ranges" and break up the ranges string[] ranges = rangeHeader.Replace("bytes=", string.Empty).Split(",".ToCharArray()); rangesResult = new RangeHeaderValue(); for (int i = 0; i < ranges.Length; i++) { const int START = 0, END = 1; long endByte, startByte; long parsedValue; string[] currentRange = ranges[i].Split("-".ToCharArray()); if (long.TryParse(currentRange[END], out parsedValue)) endByte = parsedValue; else endByte = contentSize - 1; if (long.TryParse(currentRange[START], out parsedValue)) startByte = parsedValue; else { // No beginning specified, get last n bytes of file // We already parsed end, so subtract from total and // make end the actual size of the file startByte = contentSize - endByte; endByte = contentSize - 1; } rangesResult.Ranges.Add(new RangeItemHeaderValue(startByte, endByte)); } } return rangesResult; }
public void TryParse_SetOfValidValueStrings_ParsedCorrectly() { CheckValidTryParse(" bytes=1-2 ", new RangeHeaderValue(1, 2)); var expected = new RangeHeaderValue(); expected.Unit = "custom"; expected.Ranges.Add(new RangeItemHeaderValue(null, 5)); expected.Ranges.Add(new RangeItemHeaderValue(1, 4)); CheckValidTryParse("custom = - 5 , 1 - 4 ,,", expected); }
public void ToString_UseDifferentRanges_AllSerializedCorrectly() { var range = new RangeHeaderValue(); range.Unit = "myunit"; range.Ranges.Add(new RangeItemHeaderValue(1, 3)); Assert.Equal("myunit=1-3", range.ToString()); range.Ranges.Add(new RangeItemHeaderValue(5, null)); range.Ranges.Add(new RangeItemHeaderValue(null, 17)); Assert.Equal("myunit=1-3, 5-, -17", range.ToString()); }
public void Unit_GetAndSetValidAndInvalidValues_MatchExpectation() { var range = new RangeHeaderValue(); range.Unit = "myunit"; Assert.Equal("myunit", range.Unit); Assert.Throws<ArgumentException>(() => range.Unit = null); Assert.Throws<ArgumentException>(() => range.Unit = ""); Assert.Throws<FormatException>(() => range.Unit = " x"); Assert.Throws<FormatException>(() => range.Unit = "x "); Assert.Throws<FormatException>(() => range.Unit = "x y"); }
public void Unit_GetAndSetValidAndInvalidValues_MatchExpectation() { var range = new RangeHeaderValue(); range.Unit = "myunit"; Assert.Equal("myunit", range.Unit); Assert.Throws <ArgumentException>(() => range.Unit = null); Assert.Throws <ArgumentException>(() => range.Unit = ""); Assert.Throws <FormatException>(() => range.Unit = " x"); Assert.Throws <FormatException>(() => range.Unit = "x "); Assert.Throws <FormatException>(() => range.Unit = "x y"); }
private static void CheckValidTryParse(string input, long?expectedFrom, long?expectedTo) { RangeHeaderValue result; Assert.True(RangeHeaderValue.TryParse("byte=" + input, out result), input); var ranges = result.Ranges.ToArray(); Assert.Equal(1, ranges.Length); var range = ranges.First(); Assert.Equal(expectedFrom, range.From); Assert.Equal(expectedTo, range.To); }
private static void CheckValidTryParse(string input, params Tuple <long?, long?>[] expectedRanges) { RangeHeaderValue result; Assert.True(RangeHeaderValue.TryParse("byte=" + input, out result), input); var ranges = result.Ranges.ToArray(); Assert.Equal(expectedRanges.Length, ranges.Length); for (int i = 0; i < expectedRanges.Length; i++) { Assert.Equal(expectedRanges[i].Item1, ranges[i].From); Assert.Equal(expectedRanges[i].Item2, ranges[i].To); } }
private static int GetRangeLength(StringSegment input, int startIndex, out RangeHeaderValue parsedValue) { Contract.Requires(startIndex >= 0); parsedValue = null; if (StringSegment.IsNullOrEmpty(input) || (startIndex >= input.Length)) { return(0); } // Parse the unit string: <unit> in '<unit>=<from1>-<to1>, <from2>-<to2>' var unitLength = HttpRuleParser.GetTokenLength(input, startIndex); if (unitLength == 0) { return(0); } RangeHeaderValue result = new RangeHeaderValue(); result._unit = input.Subsegment(startIndex, unitLength); var current = startIndex + unitLength; current = current + HttpRuleParser.GetWhitespaceLength(input, current); if ((current == input.Length) || (input[current] != '=')) { return(0); } current++; // skip '=' separator current = current + HttpRuleParser.GetWhitespaceLength(input, current); var rangesLength = RangeItemHeaderValue.GetRangeItemListLength(input, current, result.Ranges); if (rangesLength == 0) { return(0); } current = current + rangesLength; Contract.Assert(current == input.Length, "GetRangeItemListLength() should consume the whole string or fail."); parsedValue = result; return(current - startIndex); }
public void GetHashCode_UseSameAndDifferentRanges_SameOrDifferentHashCodes() { var range1 = new RangeHeaderValue(1, 2); var range2 = new RangeHeaderValue(1, 2); range2.Unit = "BYTES"; var range3 = new RangeHeaderValue(1, null); var range4 = new RangeHeaderValue(null, 2); var range5 = new RangeHeaderValue(); range5.Ranges.Add(new RangeItemHeaderValue(1, 2)); range5.Ranges.Add(new RangeItemHeaderValue(3, 4)); var range6 = new RangeHeaderValue(); range6.Ranges.Add(new RangeItemHeaderValue(3, 4)); // reverse order of range5 range6.Ranges.Add(new RangeItemHeaderValue(1, 2)); Assert.Equal(range1.GetHashCode(), range2.GetHashCode()); Assert.NotEqual(range1.GetHashCode(), range3.GetHashCode()); Assert.NotEqual(range1.GetHashCode(), range4.GetHashCode()); Assert.NotEqual(range1.GetHashCode(), range5.GetHashCode()); Assert.Equal(range5.GetHashCode(), range6.GetHashCode()); }
private void CheckInvalidTryParse(string?input) { Assert.False(RangeHeaderValue.TryParse(input, out var result)); Assert.Null(result); }
private bool IsRangeRequest(RangeHeaderValue range) { return range != null && range.Ranges != null && range.Ranges.Count > 0; }
[InlineData("-9999999999999999999")] // 19-digit numbers outside the Int64 range. public void TryParse_DifferentInvalidScenarios_AllReturnFalse(string input) { RangeHeaderValue result; Assert.False(RangeHeaderValue.TryParse("byte=" + input, out result)); }
public void Parse_SetOfValidValueStrings_ParsedCorrectly() { CheckValidParse(" bytes=1-2 ", new RangeHeaderValue(1, 2)); var expected = new RangeHeaderValue(); expected.Unit = "custom"; expected.Ranges.Add(new RangeItemHeaderValue(null, 5)); expected.Ranges.Add(new RangeItemHeaderValue(1, 4)); CheckValidParse("custom = - 5 , 1 - 4 ,,", expected); expected = new RangeHeaderValue(); expected.Unit = "custom"; expected.Ranges.Add(new RangeItemHeaderValue(1, 2)); CheckValidParse(" custom = 1 - 2", expected); expected = new RangeHeaderValue(); expected.Ranges.Add(new RangeItemHeaderValue(1, 2)); expected.Ranges.Add(new RangeItemHeaderValue(3, null)); expected.Ranges.Add(new RangeItemHeaderValue(null, 4)); CheckValidParse("bytes =1-2,,3-, , ,-4,,", expected); }
public static bool TryParse(StringSegment input, out RangeHeaderValue parsedValue) { var index = 0; return(Parser.TryParseValue(input, ref index, out parsedValue)); }
private void CheckValidParse(string input, RangeHeaderValue expectedResult) { var result = RangeHeaderValue.Parse(input); Assert.Equal(expectedResult, result); }
public static bool TryParse(string input, out RangeHeaderValue parsedValue) { var index = 0; return Parser.TryParseValue(input, ref index, out parsedValue); }
private static int GetRangeLength(string input, int startIndex, out RangeHeaderValue parsedValue) { Contract.Requires(startIndex >= 0); parsedValue = null; if (string.IsNullOrEmpty(input) || (startIndex >= input.Length)) { return 0; } // Parse the unit string: <unit> in '<unit>=<from1>-<to1>, <from2>-<to2>' var unitLength = HttpRuleParser.GetTokenLength(input, startIndex); if (unitLength == 0) { return 0; } RangeHeaderValue result = new RangeHeaderValue(); result._unit = input.Substring(startIndex, unitLength); var current = startIndex + unitLength; current = current + HttpRuleParser.GetWhitespaceLength(input, current); if ((current == input.Length) || (input[current] != '=')) { return 0; } current++; // skip '=' separator current = current + HttpRuleParser.GetWhitespaceLength(input, current); var rangesLength = RangeItemHeaderValue.GetRangeItemListLength(input, current, result.Ranges); if (rangesLength == 0) { return 0; } current = current + rangesLength; Contract.Assert(current == input.Length, "GetRangeItemListLength() should consume the whole string or fail."); parsedValue = result; return current - startIndex; }
private bool IsMultipartRequest(RangeHeaderValue range) { return range != null && range.Ranges != null && range.Ranges.Count > 1; }
private void CheckInvalidParse(string input) { Assert.Throws <FormatException>(() => RangeHeaderValue.Parse(input)); }