public void Ctor_AddNameAndQuality_QualityParameterAdded()
 {
     var mediaType = new MediaTypeHeaderValue("application/xml", 0.08);
     Assert.Equal(0.08, mediaType.Quality);
     Assert.Equal("application/xml", mediaType.MediaType);
     Assert.Equal(1, mediaType.Parameters.Count);
 }

        public override bool CanWriteResult([NotNull]OutputFormatterContext context, MediaTypeHeaderValue contentType)
        {
            var type = context.Object.GetType();
            var request = context.ActionContext.HttpContext.Request;

            if (request != null)
            {
                IEdmModel model = request.ODataProperties().Model;
                if (model != null)
                {
                    ODataPayloadKind? payloadKind = null;

                    Type elementType;
                    if (typeof(IEdmObject).GetTypeInfo().IsAssignableFrom(type.GetTypeInfo()) ||
                        (type.IsCollection(out elementType) && typeof(IEdmObject).GetTypeInfo().IsAssignableFrom(elementType.GetTypeInfo())))
                    {
                        payloadKind = GetEdmObjectPayloadKind(type, request);
                    }
                    else
                    {
                        payloadKind = GetClrObjectResponsePayloadKind(type, model, request);
                    }

                    return payloadKind == null ? false : _payloadKinds.Contains(payloadKind.Value);
                }
            }

            return false;
        }

        public override async Task ExecuteResultAsync([NotNull] ActionContext context)
        {
            var response = context.HttpContext.Response;

            MediaTypeHeaderValue contentTypeHeader;
            if (string.IsNullOrEmpty(ContentType))
            {
                contentTypeHeader = new MediaTypeHeaderValue("text/plain");
            }
            else
            {
                contentTypeHeader = new MediaTypeHeaderValue(ContentType);
            }

            contentTypeHeader.Encoding = ContentEncoding ?? Encodings.UTF8EncodingWithoutBOM;
            response.ContentType = contentTypeHeader.ToString();

            if (StatusCode != null)
            {
                response.StatusCode = StatusCode.Value;
            }

            if (Content != null)
            {
                await response.WriteAsync(Content, contentTypeHeader.Encoding);
            }
        }

 private static string GetBoundary(MediaTypeHeaderValue contentType) {
     var boundary = HeaderUtilities.RemoveQuotes(contentType.Boundary);
     if(string.IsNullOrWhiteSpace(boundary)) {
         throw new InvalidOperationException("Missing content-type boundary.");
     }
     return boundary;
 }

        /// <summary>
        /// Asynchronously renders the specified <paramref name="view"/> to the response body.
        /// </summary>
        /// <param name="view">The <see cref="IView"/> to render.</param>
        /// <param name="actionContext">The <see cref="ActionContext"/> for the current executing action.</param>
        /// <param name="viewData">The <see cref="ViewDataDictionary"/> for the view being rendered.</param>
        /// <param name="tempData">The <see cref="ITempDataDictionary"/> for the view being rendered.</param>
        /// <returns>A <see cref="Task"/> that represents the asynchronous rendering.</returns>
        public static async Task ExecuteAsync([NotNull] IView view,
                                              [NotNull] ActionContext actionContext,
                                              [NotNull] ViewDataDictionary viewData,
                                              [NotNull] ITempDataDictionary tempData,
                                              [NotNull] HtmlHelperOptions htmlHelperOptions,
                                              MediaTypeHeaderValue contentType)
        {
            var response = actionContext.HttpContext.Response;

            contentType = contentType ?? DefaultContentType;
            if (contentType.Encoding == null)
            {
                // Do not modify the user supplied content type, so copy it instead
                contentType = contentType.Copy();
                contentType.Encoding = Encoding.UTF8;
            }

            response.ContentType = contentType.ToString();

            using (var writer = new HttpResponseStreamWriter(response.Body, contentType.Encoding))
            {
                var viewContext = new ViewContext(
                    actionContext,
                    view,
                    viewData,
                    tempData,
                    writer,
                    htmlHelperOptions);

                await view.RenderAsync(viewContext);
            }
        }

        public async static Task ReturnScript(HttpContext context, string scriptKey, string contentType)
        {
            var dynamicScript = DynamicScriptManager.GetScript(scriptKey);
            if (dynamicScript == null)
            {
                context.Response.StatusCode = (int)HttpStatusCode.NotFound;
                await context.Response.WriteAsync("File not found!");
            }

            var mediaType = new MediaTypeHeaderValue(contentType);
            mediaType.Encoding = System.Text.Encoding.UTF8;
            context.Response.ContentType = mediaType.ToString();

            var responseHeaders = context.Response.GetTypedHeaders();
            var cacheControl = responseHeaders.CacheControl = new CacheControlHeaderValue();
            cacheControl.MaxAge = TimeSpan.FromDays(365);
            cacheControl.Private = true;
            cacheControl.MustRevalidate = false;

            var supportsGzip = dynamicScript.CompressedBytes != null &&
                context.Request.GetTypedHeaders().AcceptEncoding.ToString()
                    .IndexOf("gzip", StringComparison.OrdinalIgnoreCase) >= 0;

            byte[] contentBytes;
            if (supportsGzip)
            {
                context.Response.Headers["Content-Encoding"] = "gzip";
                contentBytes = dynamicScript.CompressedBytes;
            }
            else
                contentBytes = dynamicScript.UncompressedBytes;

            await WriteWithIfModifiedSinceControl(context, contentBytes, dynamicScript.Time);
        }

 public TwilioResponseResult(Action<TwilioResponse> buildResponse)
 {
     var response = new TwilioResponse();
     buildResponse(response);
     Content = response.Element.ToString();
     ContentType = new MediaTypeHeaderValue("text/xml");
 }

        /// <inheritdoc />
        public virtual IReadOnlyList<MediaTypeHeaderValue> GetSupportedContentTypes(
            Type declaredType,
            Type runtimeType,
            MediaTypeHeaderValue contentType)
        {
            if (!CanWriteType(declaredType, runtimeType))
            {
                return null;
            }

            if (contentType == null)
            {
                // If contentType is null, then any type we support is valid.
                return _supportedMediaTypes.Count > 0 ? _supportedMediaTypes : null;
            }
            else
            {
                List<MediaTypeHeaderValue> mediaTypes = null;

                foreach (var mediaType in _supportedMediaTypes)
                {
                    if (mediaType.IsSubsetOf(contentType))
                    {
                        if (mediaTypes == null)
                        {
                            mediaTypes = new List<MediaTypeHeaderValue>();
                        }

                        mediaTypes.Add(mediaType);
                    }
                }

                return mediaTypes;
            }
        }

 private void ValidateContentType(MediaTypeHeaderValue contentType)
 {
     if (contentType.Type == "*" || contentType.SubType == "*")
     {
         throw new ArgumentException(string.Format(Resources.FormatterMappings_NotValidMediaType, contentType));
     }
 }

 public void Ctor_MediaTypeValidFormat_SuccessfullyCreated()
 {
     var mediaType = new MediaTypeHeaderValue("text/plain");
     Assert.Equal("text/plain", mediaType.MediaType);
     Assert.Equal(0, mediaType.Parameters.Count);
     Assert.Null(mediaType.Charset);
 }

        /**
         * TODO: 
         * Refactor ErrorContentResult to ErrorContentResult(string responseType = "json") 
         * and allow JSON & XML responses depending on request type from user.
         */

        public static ContentResult ErrorContentResult(
            object value,
            int status,
            string responseType = "json")
        {
            if (value is string)
            {
                value = new ApiError { Error = value.ToString() };
            }

            string content;
            MediaTypeHeaderValue contentType;
            if (responseType == "xml")
            {
                content = SerializeToJson(value);
                contentType = new MediaTypeHeaderValue("application/xml");
            }
            else
            {
                content = SerializeToJson(value);
                contentType = new MediaTypeHeaderValue("application/json");
            }

            return new ContentResult { StatusCode = status, Content = content, ContentType = contentType };
        }

        public void MediaType_SetAndGetMediaType_MatchExpectations()
        {
            var mediaType = new MediaTypeHeaderValue("text/plain");
            Assert.Equal("text/plain", mediaType.MediaType);

            mediaType.MediaType = "application/xml";
            Assert.Equal("application/xml", mediaType.MediaType);
        }

 public void Copy_SimpleMediaType_Copied()
 {
     var mediaType0 = new MediaTypeHeaderValue("text/plain");
     var mediaType1 = mediaType0.Copy();
     Assert.NotSame(mediaType0, mediaType1);
     Assert.Same(mediaType0.MediaType, mediaType1.MediaType);
     Assert.NotSame(mediaType0.Parameters, mediaType1.Parameters);
     Assert.Equal(mediaType0.Parameters.Count, mediaType1.Parameters.Count);
 }

        /// <summary>
        /// Creates a new <see cref="FileResult"/> instance with
        /// the provided <paramref name="contentType"/>.
        /// </summary>
        /// <param name="contentType">The Content-Type header of the response.</param>
        protected FileResult(MediaTypeHeaderValue contentType)
        {
            if (contentType == null)
            {
                throw new ArgumentNullException(nameof(contentType));
            }

            ContentType = contentType;
        }

        public void GetT_KnownTypeWithValidValue_Success()
        {
            var context = new DefaultHttpContext();
            context.Request.Headers[HeaderNames.ContentType] = "text/plain";

            var result = context.Request.GetTypedHeaders().Get<MediaTypeHeaderValue>(HeaderNames.ContentType);

            var expected = new MediaTypeHeaderValue("text/plain");
            Assert.Equal(expected, result);
        }

        /// <summary>
        /// Creates a new <see cref="FileStreamResult"/> instance with
        /// the provided <paramref name="fileStream"/> and the
        /// provided <paramref name="contentType"/>.
        /// </summary>
        /// <param name="fileStream">The stream with the file.</param>
        /// <param name="contentType">The Content-Type header of the response.</param>
        public FileStreamResult(Stream fileStream, MediaTypeHeaderValue contentType)
            : base(contentType?.ToString())
        {
            if (fileStream == null)
            {
                throw new ArgumentNullException(nameof(fileStream));
            }

            FileStream = fileStream;
        }

        /// <summary>
        /// Creates a new <see cref="PhysicalFileResult"/> instance with
        /// the provided <paramref name="fileName"/> and the provided <paramref name="contentType"/>.
        /// </summary>
        /// <param name="fileName">The path to the file. The path must be an absolute path.</param>
        /// <param name="contentType">The Content-Type header of the response.</param>
        public PhysicalFileResult(string fileName, MediaTypeHeaderValue contentType)
            : base(contentType?.ToString())
        {
            if (fileName == null)
            {
                throw new ArgumentNullException(nameof(fileName));
            }

            FileName = fileName;
        }

        /// <summary>
        /// Creates a new <see cref="FileContentResult"/> instance with
        /// the provided <paramref name="fileContents"/> and the
        /// provided <paramref name="contentType"/>.
        /// </summary>
        /// <param name="fileContents">The bytes that represent the file contents.</param>
        /// <param name="contentType">The Content-Type header of the response.</param>
        public FileContentResult(byte[] fileContents, MediaTypeHeaderValue contentType)
            : base(contentType?.ToString())
        {
            if (fileContents == null)
            {
                throw new ArgumentNullException(nameof(fileContents));
            }

            FileContents = fileContents;
        }

        public void GetT_KnownTypeWithValidValue_Success()
        {
            var headers = new HeaderDictionary();
            headers[HeaderNames.ContentType] = "text/plain";

            var result = headers.Get<MediaTypeHeaderValue>(HeaderNames.ContentType);

            var expected = new MediaTypeHeaderValue("text/plain");
            Assert.Equal(expected, result);
        }

        /// <inheritdoc />
        public bool CanWriteResult([NotNull] OutputFormatterContext context, MediaTypeHeaderValue contentType)
        {
            // Ignore the passed in content type, if the object is a Stream.
            if (context.Object is Stream)
            {
                context.SelectedContentType = contentType;
                return true;
            }

            return false;
        }