private RangeItemHeaderValue(RangeItemHeaderValue source)
{
Debug.Assert(source != null);
_from = source._from;
_to = source._to;
}
private RangeItemHeaderValue(RangeItemHeaderValue source)
{
Contract.Requires(source != null);
this.from = source.from;
this.to = source.to;
}
public void Equals ()
{
var value = new RangeItemHeaderValue (5, null);
Assert.AreEqual (value, new RangeItemHeaderValue (5, null), "#1");
Assert.AreNotEqual (value, new RangeItemHeaderValue (6, null), "#2");
Assert.AreNotEqual (value, new RangeItemHeaderValue (5, 10), "#3");
}
private RangeItemHeaderValue(RangeItemHeaderValue source)
{
Contract.Requires(source != null);
_from = source._from;
_to = source._to;
}
public ByteRangeStream(Stream innerStream, RangeItemHeaderValue range)
: base(innerStream)
{
if (range == null)
{
throw new ArgumentNullException("range");
}
if (!innerStream.CanSeek)
{
throw new ArgumentException(RS.Format(Resources.ByteRangeStreamNotSeekable, typeof(ByteRangeStream).Name), "innerStream");
}
if (innerStream.Length < 1)
{
throw new ArgumentOutOfRangeException("innerStream", innerStream.Length,
RS.Format(Resources.ByteRangeStreamEmpty, typeof(ByteRangeStream).Name));
}
if (range.From.HasValue && range.From.Value > innerStream.Length)
{
throw new ArgumentOutOfRangeException("range", range.From,
RS.Format(Resources.ByteRangeStreamInvalidFrom, innerStream.Length));
}
// Ranges are inclusive so 0-9 means the first 10 bytes
long maxLength = innerStream.Length - 1;
long upperbounds;
if (range.To.HasValue)
{
if (range.From.HasValue)
{
// e.g bytes=0-499 (the first 500 bytes offsets 0-499)
upperbounds = Math.Min(range.To.Value, maxLength);
_lowerbounds = range.From.Value;
}
else
{
// e.g bytes=-500 (the final 500 bytes)
upperbounds = maxLength;
_lowerbounds = Math.Max(innerStream.Length - range.To.Value, 0);
}
}
else
{
if (range.From.HasValue)
{
// e.g bytes=500- (from byte offset 500 and up)
upperbounds = maxLength;
_lowerbounds = range.From.Value;
}
else
{
// e.g. bytes=- (invalid so will never get here)
upperbounds = maxLength;
_lowerbounds = 0;
}
}
_totalCount = upperbounds - _lowerbounds + 1;
ContentRange = new ContentRangeHeaderValue(_lowerbounds, upperbounds, innerStream.Length);
}
public void Ctor ()
{
var v = new RangeItemHeaderValue (1, null);
Assert.AreEqual ("1-", v.ToString (), "#1");
v = new RangeItemHeaderValue (null, 1);
Assert.AreEqual ("-1", v.ToString (), "#2");
}
public void Properties ()
{
var value = new RangeItemHeaderValue (3, 23);
Assert.AreEqual (3, value.From, "#1");
Assert.AreEqual (23, value.To, "#2");
value = new RangeItemHeaderValue (5, null);
Assert.AreEqual (5, value.From, "#3");
Assert.IsNull (value.To, "#4");
}
public void Ctor_ThrowsIfCantSeekInnerStream()
{
// Arrange
Mock<Stream> mockInnerStream = new Mock<Stream>();
mockInnerStream.Setup(s => s.CanSeek).Returns(false);
RangeItemHeaderValue range = new RangeItemHeaderValue(0, 10);
// Act/Assert
Assert.ThrowsArgument(() => new ByteRangeStream(mockInnerStream.Object, range), "innerStream");
}
public void Ctor_ThrowsIfLowerRangeExceedsInnerStream()
{
// Arrange
Mock<Stream> mockInnerStream = new Mock<Stream>();
mockInnerStream.Setup(s => s.CanSeek).Returns(true);
mockInnerStream.Setup(s => s.Length).Returns(5);
RangeItemHeaderValue range = new RangeItemHeaderValue(10, 20);
// Act/Assert
Assert.ThrowsArgumentOutOfRange(() => new ByteRangeStream(mockInnerStream.Object, range), "range",
"The 'From' value of the range must be less than or equal to 5.", false, 10);
}
public void ToString_UseDifferentRangeItems_AllSerializedCorrectly()
{
// Make sure ToString() doesn't add any separators.
RangeItemHeaderValue rangeItem = new RangeItemHeaderValue(1000000000, 2000000000);
Assert.Equal("1000000000-2000000000", rangeItem.ToString());
rangeItem = new RangeItemHeaderValue(5, null);
Assert.Equal("5-", rangeItem.ToString());
rangeItem = new RangeItemHeaderValue(null, 10);
Assert.Equal("-10", rangeItem.ToString());
}
public void Ctor_ThrowsIfInnerStreamLengthIsLessThanOne(int innerLength)
{
// Arrange
Mock<Stream> mockInnerStream = new Mock<Stream>();
mockInnerStream.Setup(s => s.CanSeek).Returns(true);
mockInnerStream.Setup(s => s.Length).Returns(innerLength);
RangeItemHeaderValue range = new RangeItemHeaderValue(null, 0);
// Act/Assert
Assert.ThrowsArgumentOutOfRange(() => new ByteRangeStream(mockInnerStream.Object, range), "innerStream",
"The stream over which 'ByteRangeStream' provides a range view must have a length greater than or equal to 1.",
false, innerLength);
}
public void GetHashCode_UseSameAndDifferentRangeItems_SameOrDifferentHashCodes()
{
RangeItemHeaderValue rangeItem1 = new RangeItemHeaderValue(1, 2);
RangeItemHeaderValue rangeItem2 = new RangeItemHeaderValue(1, null);
RangeItemHeaderValue rangeItem3 = new RangeItemHeaderValue(null, 2);
RangeItemHeaderValue rangeItem4 = new RangeItemHeaderValue(2, 2);
RangeItemHeaderValue rangeItem5 = new RangeItemHeaderValue(1, 2);
Assert.NotEqual(rangeItem1.GetHashCode(), rangeItem2.GetHashCode());
Assert.NotEqual(rangeItem1.GetHashCode(), rangeItem3.GetHashCode());
Assert.NotEqual(rangeItem1.GetHashCode(), rangeItem4.GetHashCode());
Assert.Equal(rangeItem1.GetHashCode(), rangeItem5.GetHashCode());
}
public void Ctor_SetsContentRange()
{
// Arrange
ContentRangeHeaderValue expectedContentRange = new ContentRangeHeaderValue(5, 9, 20);
Mock<Stream> mockInnerStream = new Mock<Stream>();
mockInnerStream.Setup(s => s.CanSeek).Returns(true);
mockInnerStream.Setup(s => s.Length).Returns(20);
RangeItemHeaderValue range = new RangeItemHeaderValue(5, 9);
// Act
ByteRangeStream rangeStream = new ByteRangeStream(mockInnerStream.Object, range);
// Assert
Assert.Equal(expectedContentRange, rangeStream.ContentRange);
}
public void Equals_UseSameAndDifferentRanges_EqualOrNotEqualNoExceptions()
{
RangeItemHeaderValue rangeItem1 = new RangeItemHeaderValue(1, 2);
RangeItemHeaderValue rangeItem2 = new RangeItemHeaderValue(1, null);
RangeItemHeaderValue rangeItem3 = new RangeItemHeaderValue(null, 2);
RangeItemHeaderValue rangeItem4 = new RangeItemHeaderValue(2, 2);
RangeItemHeaderValue rangeItem5 = new RangeItemHeaderValue(1, 2);
Assert.False(rangeItem1.Equals(rangeItem2), "1-2 vs. 1-.");
Assert.False(rangeItem2.Equals(rangeItem1), "1- vs. 1-2.");
Assert.False(rangeItem1.Equals(null), "1-2 vs. null.");
Assert.False(rangeItem1.Equals(rangeItem3), "1-2 vs. -2.");
Assert.False(rangeItem3.Equals(rangeItem1), "-2 vs. 1-2.");
Assert.False(rangeItem1.Equals(rangeItem4), "1-2 vs. 2-2.");
Assert.True(rangeItem1.Equals(rangeItem5), "1-2 vs. 1-2.");
}
public static bool TryReadRangeItem(RangeItemHeaderValue range, long contentLength,
out long start, out long end)
{
if (range.From != null)
{
start = range.From.Value;
if (range.To != null)
end = range.To.Value;
else
end = contentLength - 1;
}
else
{
end = contentLength - 1;
if (range.To != null)
start = contentLength - range.To.Value;
else
start = 0;
}
return (start < contentLength && end < contentLength);
}
internal static int GetRangeItemLength(string input, int startIndex, out RangeItemHeaderValue parsedValue)
{
Contract.Requires(startIndex >= 0);
// This parser parses number ranges: e.g. '1-2', '1-', '-2'.
parsedValue = null;
if (string.IsNullOrEmpty(input) || (startIndex >= input.Length))
{
return 0;
}
// Caller must remove leading whitespaces. If not, we'll return 0.
int current = startIndex;
// Try parse the first value of a value pair.
int fromStartIndex = current;
int fromLength = HttpRuleParser.GetNumberLength(input, current, false);
if (fromLength > HttpRuleParser.MaxInt64Digits)
{
return 0;
}
current = current + fromLength;
current = current + HttpRuleParser.GetWhitespaceLength(input, current);
// Afer the first value, the '-' character must follow.
if ((current == input.Length) || (input[current] != '-'))
{
// We need a '-' character otherwise this can't be a valid range.
return 0;
}
current++; // skip the '-' character
current = current + HttpRuleParser.GetWhitespaceLength(input, current);
int toStartIndex = current;
int toLength = 0;
// If we didn't reach the end of the string, try parse the second value of the range.
if (current < input.Length)
{
toLength = HttpRuleParser.GetNumberLength(input, current, false);
if (toLength > HttpRuleParser.MaxInt64Digits)
{
return 0;
}
current = current + toLength;
current = current + HttpRuleParser.GetWhitespaceLength(input, current);
}
if ((fromLength == 0) && (toLength == 0))
{
return 0; // At least one value must be provided in order to be a valid range.
}
// Try convert first value to int64
long from = 0;
if ((fromLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(fromStartIndex, fromLength), out from))
{
return 0;
}
// Try convert second value to int64
long to = 0;
if ((toLength > 0) && !HeaderUtilities.TryParseInt64(input.Substring(toStartIndex, toLength), out to))
{
return 0;
}
// 'from' must not be greater than 'to'
if ((fromLength > 0) && (toLength > 0) && (from > to))
{
return 0;
}
parsedValue = new RangeItemHeaderValue((fromLength == 0 ? (long?)null : (long?)from),
(toLength == 0 ? (long?)null : (long?)to));
return current - startIndex;
}
public void Ctor_ThrowsOnNullInnerStream()
{
RangeItemHeaderValue range = new RangeItemHeaderValue(0, 10);
Assert.ThrowsArgumentNull(() => new ByteRangeStream(innerStream: null, range: range), "innerStream");
}
public void ReadByte_ReadsEffectiveLengthTimes(int from, int to, int innerLength, int effectiveLength)
{
// Arrange
Mock<Stream> mockInnerStream = new Mock<Stream>();
mockInnerStream.Setup(s => s.CanSeek).Returns(true);
mockInnerStream.Setup(s => s.Length).Returns(innerLength);
RangeItemHeaderValue range = new RangeItemHeaderValue(from, to);
// Act
ByteRangeStream rangeStream = new ByteRangeStream(mockInnerStream.Object, range);
int counter = 0;
while (rangeStream.ReadByte() != -1)
{
counter++;
}
// Assert
Assert.Equal(effectiveLength, counter);
mockInnerStream.Verify(s => s.ReadByte(), Times.Exactly(effectiveLength));
}
public void Ctor_SetsLength(int from, int to, int innerLength, int expectedLength)
{
// Arrange
Mock<Stream> mockInnerStream = new Mock<Stream>();
mockInnerStream.Setup(s => s.CanSeek).Returns(true);
mockInnerStream.Setup(s => s.Length).Returns(innerLength);
RangeItemHeaderValue range = new RangeItemHeaderValue(from, to);
// Act
ByteRangeStream rangeStream = new ByteRangeStream(mockInnerStream.Object, range);
// Assert
Assert.Equal(expectedLength, rangeStream.Length);
}
internal static int GetRangeItemLength(string input, int startIndex, out RangeItemHeaderValue parsedValue)
{
Debug.Assert(startIndex >= 0);
// This parser parses number ranges: e.g. '1-2', '1-', '-2'.
parsedValue = null;
if (string.IsNullOrEmpty(input) || (startIndex >= input.Length))
{
return(0);
}
// Caller must remove leading whitespace. If not, we'll return 0.
int current = startIndex;
// Try parse the first value of a value pair.
int fromStartIndex = current;
int fromLength = HttpRuleParser.GetNumberLength(input, current, false);
if (fromLength > HttpRuleParser.MaxInt64Digits)
{
return(0);
}
current = current + fromLength;
current = current + HttpRuleParser.GetWhitespaceLength(input, current);
// After the first value, the '-' character must follow.
if ((current == input.Length) || (input[current] != '-'))
{
// We need a '-' character otherwise this can't be a valid range.
return(0);
}
current++; // skip the '-' character
current = current + HttpRuleParser.GetWhitespaceLength(input, current);
int toStartIndex = current;
int toLength = 0;
// If we didn't reach the end of the string, try parse the second value of the range.
if (current < input.Length)
{
toLength = HttpRuleParser.GetNumberLength(input, current, false);
if (toLength > HttpRuleParser.MaxInt64Digits)
{
return(0);
}
current = current + toLength;
current = current + HttpRuleParser.GetWhitespaceLength(input, current);
}
if ((fromLength == 0) && (toLength == 0))
{
return(0); // At least one value must be provided in order to be a valid range.
}
// Try convert first value to int64
long from = 0;
if ((fromLength > 0) && !HeaderUtilities.TryParseInt64(input, fromStartIndex, fromLength, out from))
{
return(0);
}
// Try convert second value to int64
long to = 0;
if ((toLength > 0) && !HeaderUtilities.TryParseInt64(input, toStartIndex, toLength, out to))
{
return(0);
}
// 'from' must not be greater than 'to'
if ((fromLength > 0) && (toLength > 0) && (from > to))
{
return(0);
}
parsedValue = new RangeItemHeaderValue((fromLength == 0 ? (long?)null : (long?)from),
(toLength == 0 ? (long?)null : (long?)to));
return(current - startIndex);
}
public void Ctor_ValidFormat_SuccessfullyCreated()
{
RangeItemHeaderValue rangeItem = new RangeItemHeaderValue(1, 2);
Assert.Equal(1, rangeItem.From);
Assert.Equal(2, rangeItem.To);
}
public void Clone_Call_CloneFieldsMatchSourceFields()
{
RangeItemHeaderValue source = new RangeItemHeaderValue(1, 2);
RangeItemHeaderValue clone = (RangeItemHeaderValue)((ICloneable)source).Clone();
Assert.Equal(source.From, clone.From);
Assert.Equal(source.To, clone.To);
source = new RangeItemHeaderValue(1, null);
clone = (RangeItemHeaderValue)((ICloneable)source).Clone();
Assert.Equal(source.From, clone.From);
Assert.Equal(source.To, clone.To);
source = new RangeItemHeaderValue(null, 2);
clone = (RangeItemHeaderValue)((ICloneable)source).Clone();
Assert.Equal(source.From, clone.From);
Assert.Equal(source.To, clone.To);
}
public void Read_ReadsEffectiveLengthBytes(int from, int to, int innerLength, int effectiveLength)
{
// Arrange
Mock<Stream> mockInnerStream = new Mock<Stream>();
mockInnerStream.Setup(s => s.CanSeek).Returns(true);
mockInnerStream.Setup(s => s.Length).Returns(innerLength);
RangeItemHeaderValue range = new RangeItemHeaderValue(from, to);
byte[] data = new byte[25];
int offset = 5;
// Act
ByteRangeStream rangeStream = new ByteRangeStream(mockInnerStream.Object, range);
rangeStream.Read(data, offset, data.Length);
// Assert
mockInnerStream.Verify(s => s.Read(data, offset, effectiveLength), Times.Once());
}
public ByteRangeStream(Stream innerStream, RangeItemHeaderValue range)
: base(innerStream)
{
// Ranges are inclusive so 0-9 means the first 10 bytes
long maxLength = innerStream.Length - 1;
long upperbounds;
if (range.To.HasValue)
{
if (range.From.HasValue)
{
// e.g bytes=0-499 (the first 500 bytes offsets 0-499)
upperbounds = Math.Min(range.To.Value, maxLength);
_lowerbounds = range.From.Value;
}
else
{
// e.g bytes=-500 (the final 500 bytes)
upperbounds = maxLength;
_lowerbounds = Math.Max(innerStream.Length - range.To.Value, 0);
}
}
else
{
if (range.From.HasValue)
{
// e.g bytes=500- (from byte offset 500 and up)
upperbounds = maxLength;
_lowerbounds = range.From.Value;
}
else
{
// e.g. bytes=- (invalid so will never get here)
upperbounds = maxLength;
_lowerbounds = 0;
}
}
_totalCount = upperbounds - _lowerbounds + 1;
ContentRange = new ContentRangeHeaderValue(_lowerbounds, upperbounds, innerStream.Length);
}
internal static int GetRangeItemLength(string input, int startIndex, out RangeItemHeaderValue parsedValue)
{
}