public void TypesEqual_DifferentType_False()
{
ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("application/xml"));
ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
Assert.False(parsedMediaType1.TypesEqual(ref parsedMediaType2));
}
public void SubTypesEqual_SameType_True()
{
ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("application/xml"));
Assert.True(parsedMediaType1.SubTypesEqual(ref parsedMediaType2));
}
public void TypesEqual_SameType_True()
{
ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/json"));
Assert.True(parsedMediaType1.TypesEqual(ref parsedMediaType2));
}
public void SubTypesEqual_DifferentTypeSameLength_False()
{
ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/yml"));
Assert.False(parsedMediaType1.SubTypesEqual(ref parsedMediaType2));
}
public void QualityFactor_Returns_Q_Value_For_MediaTypeWithQualityHeaderValue()
{
MediaTypeHeaderValue mediaType = new MediaTypeWithQualityHeaderValue("text/*", 0.5);
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(0.5, parsedMediaType.QualityFactor);
mediaType = new MediaTypeWithQualityHeaderValue("*/*", 0.0);
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(0.0, parsedMediaType.QualityFactor);
mediaType = new MediaTypeWithQualityHeaderValue("application/xml", 1.0);
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(1.0, parsedMediaType.QualityFactor);
mediaType = new MediaTypeWithQualityHeaderValue("application/xml");
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(1.0, parsedMediaType.QualityFactor);
mediaType = new MediaTypeWithQualityHeaderValue("application/xml");
mediaType.Parameters.Add(new NameValueHeaderValue("q", "0.5"));
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(0.5, parsedMediaType.QualityFactor);
MediaTypeWithQualityHeaderValue mediaTypeWithQuality = new MediaTypeWithQualityHeaderValue("application/xml");
mediaTypeWithQuality.Quality = 0.2;
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaTypeWithQuality);
Assert.Equal(0.2, parsedMediaType.QualityFactor);
}
public void IsSubTypeMediaRange_ReturnsTrueForSubTypeMediaRanges(string mediaType)
{
MediaTypeHeaderValue mediaTypeHeaderValue = MediaTypeHeaderValue.Parse(mediaType);
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaTypeHeaderValue);
Assert.True(parsedMediaType.IsSubtypeMediaRange);
}
public void IsAllMediaRange_ReturnsFalseForNonFullMediaTypeRanges(string mediaType)
{
MediaTypeHeaderValue mediaTypeHeaderValue = MediaTypeHeaderValue.Parse(mediaType);
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaTypeHeaderValue);
Assert.False(parsedMediaType.IsAllMediaRange);
}
public void SubTypesEqual_SameTypeDifferentCase_True()
{
ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/XML"));
Assert.True(parsedMediaType1.SubTypesEqual(ref parsedMediaType2));
}
/// <summary>
/// Determines whether two <see cref="MediaTypeHeaderValue"/> instances match. The instance
/// <paramref name="mediaType1"/> is said to match <paramref name="mediaType2"/> if and only if
/// <paramref name="mediaType1"/> is a strict subset of the values and parameters of <paramref name="mediaType2"/>.
/// That is, if the media type and media type parameters of <paramref name="mediaType1"/> are all present
/// and match those of <paramref name="mediaType2"/> then it is a match even though <paramref name="mediaType2"/> may have additional
/// parameters.
/// </summary>
/// <param name="mediaType1">The first media type.</param>
/// <param name="mediaType2">The second media type.</param>
/// <param name="mediaType2Range">Indicates whether <paramref name="mediaType2"/> is a regular media type, a subtype media range, or a full media range</param>
/// <returns><c>true</c> if this is a subset of <paramref name="mediaType2"/>; false otherwise.</returns>
public static bool IsSubsetOf(this MediaTypeHeaderValue mediaType1, MediaTypeHeaderValue mediaType2, out MediaTypeHeaderValueRange mediaType2Range)
{
// Performance-sensitive
Contract.Assert(mediaType1 != null);
if (mediaType2 == null)
{
mediaType2Range = MediaTypeHeaderValueRange.None;
return false;
}
ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);
mediaType2Range = parsedMediaType2.IsAllMediaRange ? MediaTypeHeaderValueRange.AllMediaRange :
parsedMediaType2.IsSubtypeMediaRange ? MediaTypeHeaderValueRange.SubtypeMediaRange :
MediaTypeHeaderValueRange.None;
if (!parsedMediaType1.TypesEqual(ref parsedMediaType2))
{
if (mediaType2Range != MediaTypeHeaderValueRange.AllMediaRange)
{
return false;
}
}
else if (!parsedMediaType1.SubTypesEqual(ref parsedMediaType2))
{
if (mediaType2Range != MediaTypeHeaderValueRange.SubtypeMediaRange)
{
return false;
}
}
// So far we either have a full match or a subset match. Now check that all of
// mediaType1's parameters are present and equal in mediatype2
// Optimize for the common case where the parameters inherit from Collection<T> and cache the count which is faster for Collection<T>.
Collection<NameValueHeaderValue> parameters1 = mediaType1.Parameters.AsCollection();
int parameterCount1 = parameters1.Count;
Collection<NameValueHeaderValue> parameters2 = mediaType2.Parameters.AsCollection();
int parameterCount2 = parameters2.Count;
for (int i = 0; i < parameterCount1; i++)
{
NameValueHeaderValue parameter1 = parameters1[i];
bool found = false;
for (int j = 0; j < parameterCount2; j++)
{
NameValueHeaderValue parameter2 = parameters2[j];
if (parameter1.Equals(parameter2))
{
found = true;
break;
}
}
if (!found)
{
return false;
}
}
return true;
}
public bool TypesEqual(ref ParsedMediaTypeHeaderValue other)
{
if (_delimiterIndex != other._delimiterIndex)
{
return false;
}
return String.Compare(_mediaType, 0, other._mediaType, 0, _delimiterIndex, StringComparison.OrdinalIgnoreCase) == 0;
}
public void SubType_ReturnsJustTheSubType(string mediaType)
{
MediaTypeHeaderValue mediaTypeHeaderValue = MediaTypeHeaderValue.Parse(mediaType);
string subtype = mediaTypeHeaderValue.MediaType.Split('/')[1];
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaTypeHeaderValue);
Assert.Equal(subtype, parsedMediaType.Subtype);
}
public void Type_ReturnsJustTheType(string mediaType)
{
MediaTypeHeaderValue mediaTypeHeaderValue = MediaTypeHeaderValue.Parse(mediaType);
string type = mediaTypeHeaderValue.MediaType.Split('/')[0];
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaTypeHeaderValue);
Assert.Equal(type, parsedMediaType.Type);
}
public bool TypesEqual(ref ParsedMediaTypeHeaderValue other)
{
if (_delimiterIndex != other._delimiterIndex)
{
return(false);
}
return(String.Compare(_mediaType, 0, other._mediaType, 0, _delimiterIndex, StringComparison.OrdinalIgnoreCase) == 0);
}
public bool SubTypesEqual(ref ParsedMediaTypeHeaderValue other)
{
int _subTypeLength = _mediaType.Length - _delimiterIndex - 1;
if (_subTypeLength != other._mediaType.Length - other._delimiterIndex - 1)
{
return false;
}
return String.Compare(_mediaType, _delimiterIndex + 1, other._mediaType, other._delimiterIndex + 1, _subTypeLength, StringComparison.OrdinalIgnoreCase) == 0;
}
public bool SubTypesEqual(ref ParsedMediaTypeHeaderValue other)
{
int _subTypeLength = _mediaType.Length - _delimiterIndex - 1;
if (_subTypeLength != other._mediaType.Length - other._delimiterIndex - 1)
{
return(false);
}
return(String.Compare(_mediaType, _delimiterIndex + 1, other._mediaType, other._delimiterIndex + 1, _subTypeLength, StringComparison.OrdinalIgnoreCase) == 0);
}
public void IsSubTypeMediaRange_Returns_True_For_Media_Ranges()
{
MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/*");
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.True(parsedMediaType.IsSubTypeMediaRange, "ParsedMediaTypeHeadeValue.IsSubTypeMediaRange should have returned true.");
mediaType = new MediaTypeHeaderValue("*/*");
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.True(parsedMediaType.IsSubTypeMediaRange, "ParsedMediaTypeHeadeValue.IsSubTypeMediaRange should have returned true.");
}
public void IsSubTypeMediaRange_Returns_True_For_Media_Ranges()
{
MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/*");
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.True(parsedMediaType.IsSubTypeMediaRange, "ParsedMediaTypeHeadeValue.IsSubTypeMediaRange should have returned true.");
mediaType = new MediaTypeHeaderValue("*/*");
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.True(parsedMediaType.IsSubTypeMediaRange, "ParsedMediaTypeHeadeValue.IsSubTypeMediaRange should have returned true.");
}
/// <summary>
/// Compares two <see cref="MediaTypeWithQualityHeaderValue"/> based on their quality value (a.k.a their "q-value").
/// Values with identical q-values are considered equal (i.e the result is 0) with the exception that sub-type wild-cards are
/// considered less than specific media types and full wild-cards are considered less than sub-type wild-cards. This allows to
/// sort a sequence of <see cref="StringWithQualityHeaderValue"/> following their q-values in the order of specific media types,
/// sub-type wildcards, and last any full wild-cards.
/// </summary>
/// <param name="mediaType1">The first <see cref="MediaTypeWithQualityHeaderValue"/> to compare.</param>
/// <param name="mediaType2">The second <see cref="MediaTypeWithQualityHeaderValue"/> to compare.</param>
/// <returns></returns>
public int Compare(MediaTypeWithQualityHeaderValue mediaType1, MediaTypeWithQualityHeaderValue mediaType2)
{
Contract.Assert(mediaType1 != null, "The 'mediaType1' parameter should not be null.");
Contract.Assert(mediaType2 != null, "The 'mediaType2' parameter should not be null.");
if (Object.ReferenceEquals(mediaType1, mediaType2))
{
return(0);
}
int returnValue = CompareBasedOnQualityFactor(mediaType1, mediaType2);
if (returnValue == 0)
{
ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);
if (!String.Equals(parsedMediaType1.Type, parsedMediaType2.Type, StringComparison.OrdinalIgnoreCase))
{
if (parsedMediaType1.IsAllMediaRange)
{
return(-1);
}
else if (parsedMediaType2.IsAllMediaRange)
{
return(1);
}
else if (parsedMediaType1.IsSubtypeMediaRange && !parsedMediaType2.IsSubtypeMediaRange)
{
return(-1);
}
else if (!parsedMediaType1.IsSubtypeMediaRange && parsedMediaType2.IsSubtypeMediaRange)
{
return(1);
}
}
else if (!String.Equals(parsedMediaType1.Subtype, parsedMediaType2.Subtype, StringComparison.OrdinalIgnoreCase))
{
if (parsedMediaType1.IsSubtypeMediaRange)
{
return(-1);
}
else if (parsedMediaType2.IsSubtypeMediaRange)
{
return(1);
}
}
}
return(returnValue);
}
/// <summary>
/// Compares two <see cref="MediaTypeWithQualityHeaderValue"/> based on their quality value (a.k.a their
/// "q-value"). Values with identical q-values are considered equal (i.e the result is 0) with the exception
/// that sub-type wild-cards are considered less than specific media types and full wild-cards are considered
/// less than sub-type wild-cards. This allows to sort a sequence of <see cref="StringWithQualityHeaderValue"/>
/// following their q-values in the order of specific media types, subtype wild-cards, and last any full
/// wild-cards.
/// </summary>
/// <param name="mediaType1">The first <see cref="MediaTypeWithQualityHeaderValue"/> to compare.</param>
/// <param name="mediaType2">The second <see cref="MediaTypeWithQualityHeaderValue"/> to compare.</param>
/// <returns>
/// <c>0</c> if <paramref name="mediaType1"/> and <paramref name="mediaType2"/> are considered equal.
/// <c>1</c> if <paramref name="mediaType1"/> is considered greater than <paramref name="mediaType2"/>.
/// <c>-1</c> otherwise (<paramref name="mediaType1"/> is considered less than <paramref name="mediaType2"/>).
/// </returns>
public int Compare(MediaTypeWithQualityHeaderValue mediaType1, MediaTypeWithQualityHeaderValue mediaType2)
{
Debug.Assert(mediaType1 != null, "The 'mediaType1' parameter should not be null.");
Debug.Assert(mediaType2 != null, "The 'mediaType2' parameter should not be null.");
if (ReferenceEquals(mediaType1, mediaType2))
{
return(0);
}
var returnValue = CompareBasedOnQualityFactor(mediaType1, mediaType2);
if (returnValue == 0)
{
var parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
var parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);
if (!parsedMediaType1.TypesEqual(ref parsedMediaType2))
{
if (parsedMediaType1.IsAllMediaRange)
{
return(-1);
}
else if (parsedMediaType2.IsAllMediaRange)
{
return(1);
}
else if (parsedMediaType1.IsSubtypeMediaRange && !parsedMediaType2.IsSubtypeMediaRange)
{
return(-1);
}
else if (!parsedMediaType1.IsSubtypeMediaRange && parsedMediaType2.IsSubtypeMediaRange)
{
return(1);
}
}
else if (!parsedMediaType1.SubTypesEqual(ref parsedMediaType2))
{
if (parsedMediaType1.IsSubtypeMediaRange)
{
return(-1);
}
else if (parsedMediaType2.IsSubtypeMediaRange)
{
return(1);
}
}
}
return(returnValue);
}
private static void ValidateMediaType(MediaTypeHeaderValue item)
{
if (item == null)
{
throw Error.ArgumentNull("item");
}
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(item);
if (parsedMediaType.IsAllMediaRange || parsedMediaType.IsSubtypeMediaRange)
{
throw Error.Argument("item", Properties.Resources.CannotUseMediaRangeForSupportedMediaType, _mediaTypeHeaderValueType.Name, item.MediaType);
}
}
public void SubType_Returns_Just_The_Sub_Type()
{
MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/xml");
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal("xml", parsedMediaType.SubType);
mediaType = new MediaTypeHeaderValue("text/*");
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal("*", parsedMediaType.SubType);
mediaType = new MediaTypeHeaderValue("*/*");
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal("*", parsedMediaType.SubType);
}
public void IsAllMediaRange_Returns_True_Only_When_Type_And_SubType_Are_Wildcards()
{
MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/*");
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.False(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned false.");
mediaType = new MediaTypeHeaderValue("*/*");
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.True(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned true.");
mediaType = new MediaTypeHeaderValue("*/xml");
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.False(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned false.");
}
public bool TypesEqual(ref ParsedMediaTypeHeaderValue other)
{
if (_delimiterIndex != other._delimiterIndex)
{
return(false);
}
return(string.Compare(
strA: _mediaType,
indexA: 0,
strB: other._mediaType,
indexB: 0,
length: _delimiterIndex,
comparisonType: StringComparison.OrdinalIgnoreCase) == 0);
}
public bool TypesEqual(ref ParsedMediaTypeHeaderValue other)
{
if (_delimiterIndex != other._delimiterIndex)
{
return false;
}
return string.Compare(
strA: _mediaType,
indexA: 0,
strB: other._mediaType,
indexB: 0,
length: _delimiterIndex,
comparisonType: StringComparison.OrdinalIgnoreCase) == 0;
}
public void IsAllMediaRange_Returns_True_Only_When_Type_And_SubType_Are_Wildcards()
{
MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/*");
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.False(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned false.");
mediaType = new MediaTypeHeaderValue("*/*");
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.True(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned true.");
mediaType = new MediaTypeHeaderValue("*/xml");
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.False(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned false.");
}
public void SubType_Returns_Just_The_Sub_Type()
{
MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/xml");
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal("xml", parsedMediaType.SubType);
mediaType = new MediaTypeHeaderValue("text/*");
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal("*", parsedMediaType.SubType);
mediaType = new MediaTypeHeaderValue("*/*");
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal("*", parsedMediaType.SubType);
}
public bool SubTypesEqual(ref ParsedMediaTypeHeaderValue other)
{
var _subTypeLength = _mediaType.Length - _delimiterIndex - 1;
if (_subTypeLength != other._mediaType.Length - other._delimiterIndex - 1)
{
return false;
}
return string.Compare(
strA: _mediaType,
indexA: _delimiterIndex + 1,
strB: other._mediaType,
indexB: other._delimiterIndex + 1,
length: _subTypeLength,
comparisonType: StringComparison.OrdinalIgnoreCase) == 0;
}
private static void ValidateMediaType(MediaTypeHeaderValue item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(item);
if (parsedMediaType.IsAllMediaRange || parsedMediaType.IsSubTypeMediaRange)
{
throw new ArgumentException(
RS.Format(Properties.Resources.CannotUseMediaRangeForSupportedMediaType, _mediaTypeHeaderValueType.Name, item.MediaType),
"item");
}
}
public bool SubTypesEqual(ref ParsedMediaTypeHeaderValue other)
{
var _subTypeLength = _mediaType.Length - _delimiterIndex - 1;
if (_subTypeLength != other._mediaType.Length - other._delimiterIndex - 1)
{
return(false);
}
return(string.Compare(
strA: _mediaType,
indexA: _delimiterIndex + 1,
strB: other._mediaType,
indexB: other._delimiterIndex + 1,
length: _subTypeLength,
comparisonType: StringComparison.OrdinalIgnoreCase) == 0);
}
private static int CompareBasedOnQualityFactor(ParsedMediaTypeHeaderValue parsedMediaType1, ParsedMediaTypeHeaderValue parsedMediaType2)
{
Contract.Assert(parsedMediaType1 != null, "The 'parsedMediaType1' parameter should not be null.");
Contract.Assert(parsedMediaType2 != null, "The 'parsedMediaType2' parameter should not be null.");
double qualityDifference = parsedMediaType1.QualityFactor - parsedMediaType2.QualityFactor;
if (qualityDifference < 0)
{
return(-1);
}
else if (qualityDifference > 0)
{
return(1);
}
return(0);
}
/// <summary>
/// Determines whether two <see cref="MediaTypeHeaderValue"/> instances match. The instance
/// <paramref name="mediaType1"/> is said to match <paramref name="mediaType2"/> if and only if
/// <paramref name="mediaType1"/> is a strict subset of the values and parameters of <paramref name="mediaType2"/>.
/// That is, if the media type and media type parameters of <paramref name="mediaType1"/> are all present
/// and match those of <paramref name="mediaType2"/> then it is a match even though <paramref name="mediaType2"/> may have additional
/// parameters.
/// </summary>
/// <param name="mediaType1">The first media type.</param>
/// <param name="mediaType2">The second media type.</param>
/// <param name="mediaType2Range">Indicates whether <paramref name="mediaType2"/> is a regular media type, a subtype media range, or a full media range</param>
/// <returns><c>true</c> if this is a subset of <paramref name="mediaType2"/>; false otherwise.</returns>
public static bool IsSubsetOf(this MediaTypeHeaderValue mediaType1, MediaTypeHeaderValue mediaType2, out MediaTypeHeaderValueRange mediaType2Range)
{
Contract.Assert(mediaType1 != null);
if (mediaType2 == null)
{
mediaType2Range = MediaTypeHeaderValueRange.None;
return(false);
}
ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);
mediaType2Range = parsedMediaType2.IsAllMediaRange ? MediaTypeHeaderValueRange.AllMediaRange :
parsedMediaType2.IsSubtypeMediaRange ? MediaTypeHeaderValueRange.SubtypeMediaRange :
MediaTypeHeaderValueRange.None;
if (!String.Equals(parsedMediaType1.Type, parsedMediaType2.Type, StringComparison.OrdinalIgnoreCase))
{
if (mediaType2Range != MediaTypeHeaderValueRange.AllMediaRange)
{
return(false);
}
}
else if (!String.Equals(parsedMediaType1.Subtype, parsedMediaType2.Subtype, StringComparison.OrdinalIgnoreCase))
{
if (mediaType2Range != MediaTypeHeaderValueRange.SubtypeMediaRange)
{
return(false);
}
}
// So far we either have a full match or a subset match. Now check that all of
// mediaType1's parameters are present and equal in mediatype2
foreach (NameValueHeaderValue parameter1 in mediaType1.Parameters)
{
if (!mediaType2.Parameters.Any(parameter2 => parameter1.Equals(parameter2)))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Determines whether two <see cref="MediaTypeHeaderValue"/> instances match. The instance
/// <paramref name="mediaType1"/> is said to match <paramref name="mediaType2"/> if and only if
/// <paramref name="mediaType1"/> is a strict subset of the values and parameters of <paramref name="mediaType2"/>.
/// That is, if the media type and media type parameters of <paramref name="mediaType1"/> are all present
/// and match those of <paramref name="mediaType2"/> then it is a match even though <paramref name="mediaType2"/> may have additional
/// parameters.
/// </summary>
/// <param name="mediaType1">The first media type.</param>
/// <param name="mediaType2">The second media type.</param>
/// <param name="mediaType2Range">Indicates whether <paramref name="mediaType2"/> is a regular media type, a subtype media range, or a full media range</param>
/// <returns><c>true</c> if this is a subset of <paramref name="mediaType2"/>; false otherwise.</returns>
public static bool IsSubsetOf(this MediaTypeHeaderValue mediaType1, MediaTypeHeaderValue mediaType2, out MediaTypeHeaderValueRange mediaType2Range)
{
Contract.Assert(mediaType1 != null);
if (mediaType2 == null)
{
mediaType2Range = MediaTypeHeaderValueRange.None;
return false;
}
ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);
mediaType2Range = parsedMediaType2.IsAllMediaRange ? MediaTypeHeaderValueRange.AllMediaRange :
parsedMediaType2.IsSubtypeMediaRange ? MediaTypeHeaderValueRange.SubtypeMediaRange :
MediaTypeHeaderValueRange.None;
if (!String.Equals(parsedMediaType1.Type, parsedMediaType2.Type, StringComparison.OrdinalIgnoreCase))
{
if (mediaType2Range != MediaTypeHeaderValueRange.AllMediaRange)
{
return false;
}
}
else if (!String.Equals(parsedMediaType1.Subtype, parsedMediaType2.Subtype, StringComparison.OrdinalIgnoreCase))
{
if (mediaType2Range != MediaTypeHeaderValueRange.SubtypeMediaRange)
{
return false;
}
}
// So far we either have a full match or a subset match. Now check that all of
// mediaType1's parameters are present and equal in mediatype2
foreach (NameValueHeaderValue parameter1 in mediaType1.Parameters)
{
if (!mediaType2.Parameters.Any(parameter2 => parameter1.Equals(parameter2)))
{
return false;
}
}
return true;
}
public void QualityFactor_Returns_1_For_MediaTypeHeaderValue()
{
MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/*");
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(1.0, parsedMediaType.QualityFactor);
mediaType = new MediaTypeHeaderValue("*/*");
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(1.0, parsedMediaType.QualityFactor);
mediaType = new MediaTypeHeaderValue("application/xml");
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(1.0, parsedMediaType.QualityFactor);
mediaType = new MediaTypeHeaderValue("application/xml");
mediaType.Parameters.Add(new NameValueHeaderValue("q", "0.5"));
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(1.0, parsedMediaType.QualityFactor);
}
public void CharSet_Is_CharSet_Of_MediaTypeHeaderValue()
{
MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("application/*");
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Null(parsedMediaType.CharSet);
mediaType = new MediaTypeHeaderValue("application/*");
mediaType.CharSet = "";
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Null(parsedMediaType.CharSet);
mediaType = new MediaTypeHeaderValue("application/xml");
mediaType.CharSet = "someCharSet";
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal("someCharSet", parsedMediaType.CharSet);
mediaType = new MediaTypeHeaderValue("text/xml");
mediaType.CharSet = "someCharSet";
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal("someCharSet", parsedMediaType.CharSet);
}
public static bool IsWithinMediaRange(this MediaTypeHeaderValue mediaType, MediaTypeHeaderValue mediaRange)
{
Contract.Assert(mediaType != null, "The 'mediaType' parameter should not be null.");
Contract.Assert(mediaRange != null, "The 'mediaRange' parameter should not be null.");
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
ParsedMediaTypeHeaderValue parsedMediaRange = new ParsedMediaTypeHeaderValue(mediaRange);
if (!String.Equals(parsedMediaType.Type, parsedMediaRange.Type, StringComparison.OrdinalIgnoreCase))
{
return parsedMediaRange.IsAllMediaRange;
}
else if (!String.Equals(parsedMediaType.SubType, parsedMediaRange.SubType, StringComparison.OrdinalIgnoreCase))
{
return parsedMediaRange.IsSubTypeMediaRange;
}
if (!String.IsNullOrWhiteSpace(parsedMediaRange.CharSet))
{
return String.Equals(parsedMediaRange.CharSet, parsedMediaType.CharSet, StringComparison.OrdinalIgnoreCase);
}
return true;
}
public static bool IsWithinMediaRange(this MediaTypeHeaderValue mediaType, MediaTypeHeaderValue mediaRange)
{
Contract.Assert(mediaType != null, "The 'mediaType' parameter should not be null.");
Contract.Assert(mediaRange != null, "The 'mediaRange' parameter should not be null.");
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
ParsedMediaTypeHeaderValue parsedMediaRange = new ParsedMediaTypeHeaderValue(mediaRange);
if (!String.Equals(parsedMediaType.Type, parsedMediaRange.Type, StringComparison.OrdinalIgnoreCase))
{
return(parsedMediaRange.IsAllMediaRange);
}
else if (!String.Equals(parsedMediaType.SubType, parsedMediaRange.SubType, StringComparison.OrdinalIgnoreCase))
{
return(parsedMediaRange.IsSubTypeMediaRange);
}
if (!String.IsNullOrWhiteSpace(parsedMediaRange.CharSet))
{
return(String.Equals(parsedMediaRange.CharSet, parsedMediaType.CharSet, StringComparison.OrdinalIgnoreCase));
}
return(true);
}
/// <summary>
/// Determines whether two <see cref="MediaTypeHeaderValue"/> instances match. The instance
/// <paramref name="mediaType1"/> is said to match <paramref name="mediaType2"/> if and only if
/// <paramref name="mediaType1"/> is a strict subset of the values and parameters of
/// <paramref name="mediaType2"/>.
/// That is, if the media type and media type parameters of <paramref name="mediaType1"/> are all present
/// and match those of <paramref name="mediaType2"/> then it is a match even though
/// <paramref name="mediaType2"/> may have additional parameters.
/// </summary>
/// <param name="mediaType1">The first media type.</param>
/// <param name="mediaType2">The second media type.</param>
/// <param name="mediaType2Range">
/// Indicates whether <paramref name="mediaType2"/> is a regular media type, a subtype media range, or a full
/// media range.
/// </param>
/// <returns><c>true</c> if this is a subset of <paramref name="mediaType2"/>; false otherwise.</returns>
public static bool IsSubsetOf(
this MediaTypeHeaderValue mediaType1,
MediaTypeHeaderValue mediaType2,
out MediaTypeFormatterMatchRanking mediaType2Range)
{
// Performance-sensitive
Debug.Assert(mediaType1 != null);
if (mediaType2 == null)
{
mediaType2Range = MediaTypeFormatterMatchRanking.None;
return false;
}
var parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
var parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);
mediaType2Range = parsedMediaType2.IsAllMediaRange ? MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderAllMediaRange :
parsedMediaType2.IsSubtypeMediaRange ? MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange :
MediaTypeFormatterMatchRanking.None;
if (!parsedMediaType1.TypesEqual(ref parsedMediaType2))
{
if (mediaType2Range != MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderAllMediaRange)
{
return false;
}
}
else if (!parsedMediaType1.SubTypesEqual(ref parsedMediaType2))
{
if (mediaType2Range != MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange)
{
return false;
}
}
else
{
mediaType2Range = MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral;
}
// So far we either have a full match or a subset match. Now check that all of
// mediaType1's parameters are present and equal in mediatype2
// Optimize for the common case where the parameters inherit from Collection<T> and cache the count which
// is faster for Collection<T>.
var parameters1 = mediaType1.Parameters.AsCollection();
var parameterCount1 = parameters1.Count;
var parameters2 = mediaType2.Parameters.AsCollection();
var parameterCount2 = parameters2.Count;
for (var i = 0; i < parameterCount1; i++)
{
var parameter1 = parameters1[i];
var found = false;
for (var j = 0; j < parameterCount2; j++)
{
var parameter2 = parameters2[j];
if (parameter1.Equals(parameter2))
{
found = true;
break;
}
}
if (!found)
{
return false;
}
}
return true;
}
/// <summary>
/// Determines whether two <see cref="MediaTypeHeaderValue"/> instances match. The instance
/// <paramref name="mediaType1"/> is said to match <paramref name="mediaType2"/> if and only if
/// <paramref name="mediaType1"/> is a strict subset of the values and parameters of <paramref name="mediaType2"/>.
/// That is, if the media type and media type parameters of <paramref name="mediaType1"/> are all present
/// and match those of <paramref name="mediaType2"/> then it is a match even though <paramref name="mediaType2"/> may have additional
/// parameters.
/// </summary>
/// <param name="mediaType1">The first media type.</param>
/// <param name="mediaType2">The second media type.</param>
/// <param name="mediaType2Range">Indicates whether <paramref name="mediaType2"/> is a regular media type, a subtype media range, or a full media range</param>
/// <returns><c>true</c> if this is a subset of <paramref name="mediaType2"/>; false otherwise.</returns>
public static bool IsSubsetOf(this MediaTypeHeaderValue mediaType1, MediaTypeHeaderValue mediaType2, out MediaTypeHeaderValueRange mediaType2Range)
{
// Performance-sensitive
Contract.Assert(mediaType1 != null);
if (mediaType2 == null)
{
mediaType2Range = MediaTypeHeaderValueRange.None;
return(false);
}
ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);
mediaType2Range = parsedMediaType2.IsAllMediaRange ? MediaTypeHeaderValueRange.AllMediaRange :
parsedMediaType2.IsSubtypeMediaRange ? MediaTypeHeaderValueRange.SubtypeMediaRange :
MediaTypeHeaderValueRange.None;
if (!String.Equals(parsedMediaType1.Type, parsedMediaType2.Type, StringComparison.OrdinalIgnoreCase))
{
if (mediaType2Range != MediaTypeHeaderValueRange.AllMediaRange)
{
return(false);
}
}
else if (!String.Equals(parsedMediaType1.Subtype, parsedMediaType2.Subtype, StringComparison.OrdinalIgnoreCase))
{
if (mediaType2Range != MediaTypeHeaderValueRange.SubtypeMediaRange)
{
return(false);
}
}
// So far we either have a full match or a subset match. Now check that all of
// mediaType1's parameters are present and equal in mediatype2
// Optimize for the common case where the parameters inherit from Collection<T> and cache the count which is faster for Collection<T>.
Collection <NameValueHeaderValue> parameters1 = mediaType1.Parameters.AsCollection();
int parameterCount1 = parameters1.Count;
Collection <NameValueHeaderValue> parameters2 = mediaType2.Parameters.AsCollection();
int parameterCount2 = parameters2.Count;
for (int i = 0; i < parameterCount1; i++)
{
NameValueHeaderValue parameter1 = parameters1[i];
bool found = false;
for (int j = 0; j < parameterCount2; j++)
{
NameValueHeaderValue parameter2 = parameters2[j];
if (parameter1.Equals(parameter2))
{
found = true;
break;
}
}
if (!found)
{
return(false);
}
}
return(true);
}
public void QualityFactor_Returns_Q_Value_For_MediaTypeWithQualityHeaderValue()
{
MediaTypeHeaderValue mediaType = new MediaTypeWithQualityHeaderValue("text/*", 0.5);
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(0.5, parsedMediaType.QualityFactor);
mediaType = new MediaTypeWithQualityHeaderValue("*/*", 0.0);
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(0.0, parsedMediaType.QualityFactor);
mediaType = new MediaTypeWithQualityHeaderValue("application/xml", 1.0);
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(1.0, parsedMediaType.QualityFactor);
mediaType = new MediaTypeWithQualityHeaderValue("application/xml");
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(1.0, parsedMediaType.QualityFactor);
mediaType = new MediaTypeWithQualityHeaderValue("application/xml");
mediaType.Parameters.Add(new NameValueHeaderValue("q", "0.5"));
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(0.5, parsedMediaType.QualityFactor);
MediaTypeWithQualityHeaderValue mediaTypeWithQuality = new MediaTypeWithQualityHeaderValue("application/xml");
mediaTypeWithQuality.Quality = 0.2;
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaTypeWithQuality);
Assert.Equal(0.2, parsedMediaType.QualityFactor);
}
public void CharSet_Is_CharSet_Of_MediaTypeHeaderValue()
{
MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("application/*");
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Null(parsedMediaType.CharSet);
mediaType = new MediaTypeHeaderValue("application/*");
mediaType.CharSet = "";
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Null(parsedMediaType.CharSet);
mediaType = new MediaTypeHeaderValue("application/xml");
mediaType.CharSet = "someCharSet";
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal("someCharSet", parsedMediaType.CharSet);
mediaType = new MediaTypeHeaderValue("text/xml");
mediaType.CharSet = "someCharSet";
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal("someCharSet", parsedMediaType.CharSet);
}
public void QualityFactor_Returns_1_For_MediaTypeHeaderValue()
{
MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/*");
ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(1.0, parsedMediaType.QualityFactor);
mediaType = new MediaTypeHeaderValue("*/*");
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(1.0, parsedMediaType.QualityFactor);
mediaType = new MediaTypeHeaderValue("application/xml");
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(1.0, parsedMediaType.QualityFactor);
mediaType = new MediaTypeHeaderValue("application/xml");
mediaType.Parameters.Add(new NameValueHeaderValue("q", "0.5"));
parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
Assert.Equal(1.0, parsedMediaType.QualityFactor);
}
/// <summary>
/// Determines whether two <see cref="MediaTypeHeaderValue"/> instances match. The instance
/// <paramref name="mediaType1"/> is said to match <paramref name="mediaType2"/> if and only if
/// <paramref name="mediaType1"/> is a strict subset of the values and parameters of
/// <paramref name="mediaType2"/>.
/// That is, if the media type and media type parameters of <paramref name="mediaType1"/> are all present
/// and match those of <paramref name="mediaType2"/> then it is a match even though
/// <paramref name="mediaType2"/> may have additional parameters.
/// </summary>
/// <param name="mediaType1">The first media type.</param>
/// <param name="mediaType2">The second media type.</param>
/// <param name="mediaType2Range">
/// Indicates whether <paramref name="mediaType2"/> is a regular media type, a subtype media range, or a full
/// media range.
/// </param>
/// <returns><c>true</c> if this is a subset of <paramref name="mediaType2"/>; false otherwise.</returns>
public static bool IsSubsetOf(
this MediaTypeHeaderValue mediaType1,
MediaTypeHeaderValue mediaType2,
out MediaTypeFormatterMatchRanking mediaType2Range)
{
// Performance-sensitive
Debug.Assert(mediaType1 != null);
if (mediaType2 == null)
{
mediaType2Range = MediaTypeFormatterMatchRanking.None;
return(false);
}
var parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
var parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);
mediaType2Range = parsedMediaType2.IsAllMediaRange ? MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderAllMediaRange :
parsedMediaType2.IsSubtypeMediaRange ? MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange :
MediaTypeFormatterMatchRanking.None;
if (!parsedMediaType1.TypesEqual(ref parsedMediaType2))
{
if (mediaType2Range != MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderAllMediaRange)
{
return(false);
}
}
else if (!parsedMediaType1.SubTypesEqual(ref parsedMediaType2))
{
if (mediaType2Range != MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange)
{
return(false);
}
}
else
{
mediaType2Range = MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral;
}
// So far we either have a full match or a subset match. Now check that all of
// mediaType1's parameters are present and equal in mediatype2
// Optimize for the common case where the parameters inherit from Collection<T> and cache the count which
// is faster for Collection<T>.
var parameters1 = mediaType1.Parameters.AsCollection();
var parameterCount1 = parameters1.Count;
var parameters2 = mediaType2.Parameters.AsCollection();
var parameterCount2 = parameters2.Count;
for (var i = 0; i < parameterCount1; i++)
{
var parameter1 = parameters1[i];
var found = false;
for (var j = 0; j < parameterCount2; j++)
{
var parameter2 = parameters2[j];
if (parameter1.Equals(parameter2))
{
found = true;
break;
}
}
if (!found)
{
return(false);
}
}
return(true);
}
