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 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));
 }
 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 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_DifferentType_False()
 {
     ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("application/xml"));
     ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
     Assert.False(parsedMediaType1.TypesEqual(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 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);
 }