コード例 #1
0
        public void QualityFactor_Returns_Q_Value_For_MediaTypeWithQualityHeaderValue()
        {
            MediaTypeHeaderValue       mediaType       = new MediaTypeWithQualityHeaderValue("text/*", 0.5);
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);

            Assert.AreEqual(0.5, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 0.5.");

            mediaType       = new MediaTypeWithQualityHeaderValue("*/*", 0.0);
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual(0.0, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 0.0.");

            mediaType       = new MediaTypeWithQualityHeaderValue("application/xml", 1.0);
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual(1.0, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 1.0.");

            mediaType       = new MediaTypeWithQualityHeaderValue("application/xml");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual(1.0, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 1.0.");

            mediaType = new MediaTypeWithQualityHeaderValue("application/xml");
            mediaType.Parameters.Add(new NameValueHeaderValue("q", "0.5"));
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual(0.5, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 0.5.");

            MediaTypeWithQualityHeaderValue mediaTypeWithQuality = new MediaTypeWithQualityHeaderValue("application/xml");

            mediaTypeWithQuality.Quality = 0.2;
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaTypeWithQuality);
            Assert.AreEqual(0.2, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 0.2.");
        }
コード例 #2
0
        public void IsSubTypeMediaRange_Returns_True_For_Media_Ranges()
        {
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/*");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.IsTrue(parsedMediaType.IsSubTypeMediaRange, "ParsedMediaTypeHeadeValue.IsSubTypeMediaRange should have returned true.");

            mediaType = new MediaTypeHeaderValue("*/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.IsTrue(parsedMediaType.IsSubTypeMediaRange, "ParsedMediaTypeHeadeValue.IsSubTypeMediaRange should have returned true.");
        }
コード例 #3
0
        public void IsSubTypeMediaRange_Returns_True_For_Media_Ranges()
        {
            MediaTypeHeaderValue       mediaType       = new MediaTypeHeaderValue("text/*");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);

            Assert.IsTrue(parsedMediaType.IsSubTypeMediaRange, "ParsedMediaTypeHeadeValue.IsSubTypeMediaRange should have returned true.");

            mediaType       = new MediaTypeHeaderValue("*/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.IsTrue(parsedMediaType.IsSubTypeMediaRange, "ParsedMediaTypeHeadeValue.IsSubTypeMediaRange should have returned true.");
        }
コード例 #4
0
        public int Compare(MediaTypeHeaderValue mediaType1, MediaTypeHeaderValue mediaType2)
        {
            Fx.Assert(mediaType1 != null, "The 'mediaType1' parameter should not be null.");
            Fx.Assert(mediaType2 != null, "The 'mediaType2' parameter should not be null.");

            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);

            int returnValue = CompareBasedOnQualityFactor(parsedMediaType1, parsedMediaType2);

            if (returnValue == 0)
            {
                if (!string.Equals(parsedMediaType1.Type, parsedMediaType2.Type, StringComparison.OrdinalIgnoreCase))
                {
                    if (parsedMediaType1.IsAllMediaRange)
                    {
                        return(1);
                    }
                    else if (parsedMediaType2.IsAllMediaRange)
                    {
                        return(-1);
                    }
                }
                else if (!string.Equals(parsedMediaType1.SubType, parsedMediaType2.SubType, StringComparison.OrdinalIgnoreCase))
                {
                    if (parsedMediaType1.IsSubTypeMediaRange)
                    {
                        return(1);
                    }
                    else if (parsedMediaType2.IsSubTypeMediaRange)
                    {
                        return(-1);
                    }
                }
                else
                {
                    if (!parsedMediaType1.HasNonQualityFactorParameter)
                    {
                        if (parsedMediaType2.HasNonQualityFactorParameter)
                        {
                            return(1);
                        }
                    }
                    else if (!parsedMediaType2.HasNonQualityFactorParameter)
                    {
                        return(-1);
                    }
                }
            }

            return(returnValue);
        }
コード例 #5
0
        public void IsAllMediaRange_Returns_True_Only_When_Type_And_SubType_Are_Wildcards()
        {
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/*");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.IsFalse(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned false.");

            mediaType = new MediaTypeHeaderValue("*/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.IsTrue(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned true.");

            mediaType = new MediaTypeHeaderValue("*/xml");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.IsFalse(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned false.");
        }
コード例 #6
0
        public void IsAllMediaRange_Returns_True_Only_When_Type_And_SubType_Are_Wildcards()
        {
            MediaTypeHeaderValue       mediaType       = new MediaTypeHeaderValue("text/*");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);

            Assert.IsFalse(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned false.");

            mediaType       = new MediaTypeHeaderValue("*/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.IsTrue(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned true.");

            mediaType       = new MediaTypeHeaderValue("*/xml");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.IsFalse(parsedMediaType.IsAllMediaRange, "ParsedMediaTypeHeadeValue.IsAllMediaRange should have returned false.");
        }
コード例 #7
0
        public void SubType_Returns_Just_The_Sub_Type()
        {
            MediaTypeHeaderValue       mediaType       = new MediaTypeHeaderValue("text/xml");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);

            Assert.AreEqual("xml", parsedMediaType.SubType, "ParsedMediaTypeHeadeValue.SubType should have returned 'xml'.");

            mediaType       = new MediaTypeHeaderValue("text/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual("*", parsedMediaType.SubType, "ParsedMediaTypeHeadeValue.SubType should have returned '*'.");

            mediaType       = new MediaTypeHeaderValue("*/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual("*", parsedMediaType.SubType, "ParsedMediaTypeHeadeValue.SubType should have returned '*'.");
        }
コード例 #8
0
            private static void ValidateMediaType(MediaTypeHeaderValue item)
            {
                if (item == null)
                {
                    throw Fx.Exception.ArgumentNull("item");
                }

                ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(item);

                if (parsedMediaType.IsAllMediaRange || parsedMediaType.IsSubTypeMediaRange)
                {
                    throw Fx.Exception.AsError(
                              new ArgumentException(
                                  SR.CannotUseMediaRangeForSupportedMediaType(mediaTypeHeaderValueType.Name, item.MediaType),
                                  "item"));
                }
            }
コード例 #9
0
        private static int CompareBasedOnQualityFactor(ParsedMediaTypeHeaderValue parsedMediaType1, ParsedMediaTypeHeaderValue parsedMediaType2)
        {
            Fx.Assert(parsedMediaType1 != null, "The 'parsedMediaType1' parameter should not be null.");
            Fx.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);
        }
コード例 #10
0
        public void QualityFactor_Returns_1_For_MediaTypeHeaderValue()
        {
            MediaTypeHeaderValue       mediaType       = new MediaTypeHeaderValue("text/*");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);

            Assert.AreEqual(1.0, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 1.0.");

            mediaType       = new MediaTypeHeaderValue("*/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual(1.0, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 1.0.");

            mediaType       = new MediaTypeHeaderValue("application/xml");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual(1.0, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 1.0.");

            mediaType = new MediaTypeHeaderValue("application/xml");
            mediaType.Parameters.Add(new NameValueHeaderValue("q", "0.5"));
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual(1.0, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 1.0.");
        }
コード例 #11
0
        public void CharSet_Is_CharSet_Of_MediaTypeHeaderValue()
        {
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("application/*");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.IsNull(parsedMediaType.CharSet, "ParsedMediaTypeHeadeValue.CharSet should have returned null.");

            mediaType = new MediaTypeHeaderValue("application/*");
            mediaType.CharSet = "";
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.IsNull(parsedMediaType.CharSet, "ParsedMediaTypeHeadeValue.CharSet should have returned null.");

            mediaType = new MediaTypeHeaderValue("application/xml");
            mediaType.CharSet = "someCharSet";
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual("someCharSet", parsedMediaType.CharSet, "ParsedMediaTypeHeadeValue.CharSet should have returned 'someCharSet'.");

            mediaType = new MediaTypeHeaderValue("text/xml");
            mediaType.CharSet = "someCharSet";
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual("someCharSet", parsedMediaType.CharSet, "ParsedMediaTypeHeadeValue.CharSet should have returned 'someCharSet'.");
        }
コード例 #12
0
        public void CharSet_Is_CharSet_Of_MediaTypeHeaderValue()
        {
            MediaTypeHeaderValue       mediaType       = new MediaTypeHeaderValue("application/*");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);

            Assert.IsNull(parsedMediaType.CharSet, "ParsedMediaTypeHeadeValue.CharSet should have returned null.");

            mediaType         = new MediaTypeHeaderValue("application/*");
            mediaType.CharSet = "";
            parsedMediaType   = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.IsNull(parsedMediaType.CharSet, "ParsedMediaTypeHeadeValue.CharSet should have returned null.");

            mediaType         = new MediaTypeHeaderValue("application/xml");
            mediaType.CharSet = "someCharSet";
            parsedMediaType   = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual("someCharSet", parsedMediaType.CharSet, "ParsedMediaTypeHeadeValue.CharSet should have returned 'someCharSet'.");

            mediaType         = new MediaTypeHeaderValue("text/xml");
            mediaType.CharSet = "someCharSet";
            parsedMediaType   = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual("someCharSet", parsedMediaType.CharSet, "ParsedMediaTypeHeadeValue.CharSet should have returned 'someCharSet'.");
        }
コード例 #13
0
        public static bool IsWithinMediaRange(this MediaTypeHeaderValue mediaType, MediaTypeHeaderValue mediaRange)
        {
            Fx.Assert(mediaType != null, "The 'mediaType' parameter should not be null.");
            Fx.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);
        }
コード例 #14
0
        public static bool IsWithinMediaRange(this MediaTypeHeaderValue mediaType, MediaTypeHeaderValue mediaRange)
        {
            Fx.Assert(mediaType != null, "The 'mediaType' parameter should not be null.");
            Fx.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;
        }
コード例 #15
0
        public void Type_Returns_Just_The_Type()
        {
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/xml");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual("text", parsedMediaType.Type, "ParsedMediaTypeHeadeValue.Type should have returned 'text'.");

            mediaType = new MediaTypeHeaderValue("text/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual("text", parsedMediaType.Type, "ParsedMediaTypeHeadeValue.Type should have returned 'text'.");

            mediaType = new MediaTypeHeaderValue("*/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual("*", parsedMediaType.Type, "ParsedMediaTypeHeadeValue.Type should have returned '*'.");
        }
コード例 #16
0
        public void QualityFactor_Returns_Q_Value_For_MediaTypeWithQualityHeaderValue()
        {
            MediaTypeHeaderValue mediaType = new MediaTypeWithQualityHeaderValue("text/*", 0.5);
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual(0.5, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 0.5.");

            mediaType = new MediaTypeWithQualityHeaderValue("*/*", 0.0);
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual(0.0, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 0.0.");

            mediaType = new MediaTypeWithQualityHeaderValue("application/xml", 1.0);
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual(1.0, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 1.0.");

            mediaType = new MediaTypeWithQualityHeaderValue("application/xml");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual(1.0, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 1.0.");

            mediaType = new MediaTypeWithQualityHeaderValue("application/xml");
            mediaType.Parameters.Add(new NameValueHeaderValue("q", "0.5"));
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual(0.5, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 0.5.");

            MediaTypeWithQualityHeaderValue mediaTypeWithQuality = new MediaTypeWithQualityHeaderValue("application/xml");
            mediaTypeWithQuality.Quality = 0.2;
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaTypeWithQuality);
            Assert.AreEqual(0.2, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 0.2.");
        }
コード例 #17
0
        public void QualityFactor_Returns_1_For_MediaTypeHeaderValue()
        {
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/*");
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual(1.0, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 1.0.");

            mediaType = new MediaTypeHeaderValue("*/*");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual(1.0, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 1.0.");

            mediaType = new MediaTypeHeaderValue("application/xml");
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual(1.0, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 1.0.");

            mediaType = new MediaTypeHeaderValue("application/xml");
            mediaType.Parameters.Add(new NameValueHeaderValue("q", "0.5"));
            parsedMediaType = new ParsedMediaTypeHeaderValue(mediaType);
            Assert.AreEqual(1.0, parsedMediaType.QualityFactor, "ParsedMediaTypeHeadeValue.QualityFactor should have returned 1.0.");
        }