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 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());
}
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());
}
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)
{
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 CheckValidTryParse(string input, RangeHeaderValue expectedResult)
{
RangeHeaderValue result = null;
Assert.True(RangeHeaderValue.TryParse(input, out result));
Assert.Equal(expectedResult, result);
}
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 CheckValidParse(string input, RangeHeaderValue expectedResult)
{
var result = RangeHeaderValue.Parse(input);
Assert.Equal(expectedResult, result);
}
private void CheckInvalidParse(string input)
{
Assert.Throws <FormatException>(() => RangeHeaderValue.Parse(input));
}
