/// <summary>
        /// Renders just the selection set completely.
        /// </summary>
        ///
        /// <param name="outputFormatter">
        /// The output formatter.
        /// </param>
        ///
        /// <returns>
        /// A string of HTML.
        /// </returns>

        public string RenderSelection(IOutputFormatter outputFormatter)
        {
            StringWriter writer = new StringWriter();
            RenderSelection(outputFormatter, writer);

            return writer.ToString();
        }

        public MixinReferenceReportGenerator(
        InvolvedType involvedType, 
        IIdentifierGenerator<Assembly> assemblyIdentifierGenerator, 
        IIdentifierGenerator<Type> involvedTypeIdentifierGenerator, 
        IIdentifierGenerator<Type> interfaceIdentifierGenerator, 
        IIdentifierGenerator<Type> attributeIdentifierGenerator, 
        IRemotionReflector remotionReflector, 
        IOutputFormatter outputFormatter
        )
        {
            ArgumentUtility.CheckNotNull ("involvedType", involvedType);
              ArgumentUtility.CheckNotNull ("assemblyIdentifierGenerator", assemblyIdentifierGenerator);
              ArgumentUtility.CheckNotNull ("involvedTypeIdentifierGenerator", involvedTypeIdentifierGenerator);
              ArgumentUtility.CheckNotNull ("interfaceIdentifierGenerator", interfaceIdentifierGenerator);
              ArgumentUtility.CheckNotNull ("attributeIdentifierGenerator", attributeIdentifierGenerator);
              ArgumentUtility.CheckNotNull ("remotionReflector", remotionReflector);
              ArgumentUtility.CheckNotNull ("outputFormatter", outputFormatter);

              _involvedType = involvedType;
              _assemblyIdentifierGenerator = assemblyIdentifierGenerator;
              _involvedTypeIdentifierGenerator = involvedTypeIdentifierGenerator;
              _interfaceIdentifierGenerator = interfaceIdentifierGenerator;
              _attributeIdentifierGenerator = attributeIdentifierGenerator;
              _remotionReflector = remotionReflector;
              _outputFormatter = outputFormatter;
        }

        /// <summary>
        /// Creates a new <see cref="JsonResult"/> with the given <paramref name="value"/>.
        /// </summary>
        /// <param name="value">The value to format as JSON.</param>
        /// <param name="formatter">The formatter to use, or <c>null</c> to choose a formatter dynamically.</param>
        public JsonResult(object value, IOutputFormatter formatter)
        {
            Value = value;
            Formatter = formatter;

            ContentTypes = new List<MediaTypeHeaderValue>();
        }

        public InvolvedTypeReportGenerator(
      InvolvedType[] involvedTypes,
      IIdentifierGenerator<Assembly> assemblyIdentifierGenerator,
      IIdentifierGenerator<Type> involvedTypeIdentifierGenerator,
      IIdentifierGenerator<MemberInfo> memberIdentifierGenerator,
      IIdentifierGenerator<Type> interfaceIdentifierGenerator,
      IIdentifierGenerator<Type> attributeIdentifierGenerator,
      IRemotionReflector remotionReflector,
      IOutputFormatter outputFormatter)
        {
            ArgumentUtility.CheckNotNull ("involvedTypes", involvedTypes);
              ArgumentUtility.CheckNotNull ("assemblyIdentifierGenerator", assemblyIdentifierGenerator);
              ArgumentUtility.CheckNotNull ("involvedTypeIdentifierGenerator", involvedTypeIdentifierGenerator);
              ArgumentUtility.CheckNotNull ("memberIdentifierGenerator", memberIdentifierGenerator);
              ArgumentUtility.CheckNotNull ("interfaceIdentifierGenerator", interfaceIdentifierGenerator);
              ArgumentUtility.CheckNotNull ("attributeIdentifierGenerator", attributeIdentifierGenerator);
              ArgumentUtility.CheckNotNull ("remotionReflector", remotionReflector);
              ArgumentUtility.CheckNotNull ("outputFormatter", outputFormatter);

              _involvedTypes = involvedTypes;
              _assemblyIdentifierGenerator = assemblyIdentifierGenerator;
              _involvedTypeIdentifierGenerator = involvedTypeIdentifierGenerator;
              _memberIdentifierGenerator = memberIdentifierGenerator;
              _interfaceIdentifierGenerator = interfaceIdentifierGenerator;
              _attributeIdentifierGenerator = attributeIdentifierGenerator;
              _remotionReflector = remotionReflector;
              _outputFormatter = outputFormatter;
        }

 public TargetCallDependenciesReportGenerator(ReflectedObject mixinDefinition, IIdentifierGenerator<Assembly> assemblyIdentifierGenerator, IRemotionReflector remotionReflector, IOutputFormatter outputFormatter)
 {
     _mixinDefinition = mixinDefinition;
       _assemblyIdentifierGenerator = assemblyIdentifierGenerator;
       _remotionReflector = remotionReflector;
       _outputFormatter = outputFormatter;
 }

 public static void FormatterSelected(
     this ILogger logger,
     IOutputFormatter outputFormatter,
     OutputFormatterWriteContext context)
 {
     var contentType = Convert.ToString(context.ContentType);
     _formatterSelected(logger, outputFormatter, contentType, null);
 }

 public DecoratedOutputFormatter(IOutputFormatter formatter, IAstVisitor visitor)
 {
     if (formatter == null)
         throw new ArgumentNullException(nameof(formatter));
     if (visitor == null)
         throw new ArgumentNullException(nameof(visitor));
     _formatter = formatter;
     _visitor = visitor;
 }

 /// <summary>
 /// Initializes a new instance of <see cref="CodeCommentDecorator"/> with the provided
 /// <paramref name="outputFormatter"/>.
 /// </summary>
 /// 
 /// <param name="outputFormatter">
 /// An <see cref="IOutputFormatter"/> implementation to which code documentation comments will be written.
 /// </param>
 public CodeCommentDecorator(IOutputFormatter outputFormatter)
 {
     if (outputFormatter == null)
     {
         Debug.Assert(false, "outputFormatter is null");
         throw new ArgumentNullException("outputFormatter");
     }
     _formatter = outputFormatter;
 }

 public static InterfaceReportGenerator CreateInterfaceReportGenerator(IRemotionReflector remotionReflector, IOutputFormatter outputFormatter, params InvolvedType[] types)
 {
     return new InterfaceReportGenerator (types,
                                    new IdentifierGenerator<Assembly> (),
                                    new IdentifierGenerator<Type> (),
                                    new IdentifierGenerator<MemberInfo> (),
                                    new IdentifierGenerator<Type> (),
                                    remotionReflector,
                                    outputFormatter);
 }

		public CSharpOutputVisitor (IOutputFormatter formatter, CSharpFormattingOptions formattingPolicy)
		{
			if (formatter == null) {
				throw new ArgumentNullException ("formatter");
			}
			if (formattingPolicy == null) {
				throw new ArgumentNullException ("formattingPolicy");
			}
			this.formatter = formatter;
			this.policy = formattingPolicy;
		}

 public Configuration(IEnumerable<IFieldHarvester> fieldHarvesters, 
   IEnumerable<IValueConverter> valueConverters, 
   string indentIncrement, 
   IOutputFormatter outputFormatter,
   CultureInfo culture)
 {
   this.valueConverters = valueConverters.ToList();
   this.fieldHarvesters = fieldHarvesters.ToList();
   IndentIncrement = indentIncrement;
   OutputFormatter = outputFormatter;
   Culture = culture;
 }

        public AdditionalDependencyReportGenerator(
        ReflectedObject explicitDependencies,
        IIdentifierGenerator<Type> involvedTypeIdentifierGenerator,
        IOutputFormatter outputFormatter)
        {
            ArgumentUtility.CheckNotNull ("explicitDependencies", explicitDependencies);
              ArgumentUtility.CheckNotNull ("involvedTypeIdentifierGenerator", involvedTypeIdentifierGenerator);
              ArgumentUtility.CheckNotNull ("outputFormatter", outputFormatter);

              _explicitDependencies = explicitDependencies;
              _involvedTypeIdentifierGenerator = involvedTypeIdentifierGenerator;
              _outputFormatter = outputFormatter;
        }

        public static InvolvedTypeReportGenerator CreateInvolvedTypeReportGenerator(IRemotionReflector remotionReflector, IOutputFormatter outputFormatter, params InvolvedType[] involvedTypes)
        {
            var assemblyIdentifierGenerator = StubFactory.CreateIdentifierGeneratorStub (new Assembly[0]);
              var involvedTypeIdentifierGenerator = StubFactory.CreateIdentifierGeneratorStub (involvedTypes.Select (t => t.Type));

              return new InvolvedTypeReportGenerator (involvedTypes,
                                              assemblyIdentifierGenerator,
                                              involvedTypeIdentifierGenerator,
                                              new IdentifierGenerator<MemberInfo> (),
                                              new IdentifierGenerator<Type> (),
                                              new IdentifierGenerator<Type> (),
                                              remotionReflector,
                                              outputFormatter);
        }

        public FullReportGenerator(
        InvolvedType[] involvedTypes,
        ErrorAggregator<Exception> configurationErrors,
        ErrorAggregator<Exception> validationErrors,
        IRemotionReflector remotionReflector,
        IOutputFormatter outputFormatter)
        {
            ArgumentUtility.CheckNotNull ("_involvedTypes", involvedTypes);
              ArgumentUtility.CheckNotNull ("configurationErrors", configurationErrors);
              ArgumentUtility.CheckNotNull ("validationErrors", validationErrors);
              ArgumentUtility.CheckNotNull ("remotionReflector", remotionReflector);
              ArgumentUtility.CheckNotNull ("outputFormatter", outputFormatter);

              _involvedTypes = involvedTypes;
              _configurationErrors = configurationErrors;
              _validationErrors = validationErrors;
              _remotionReflector = remotionReflector;
              _outputFormatter = outputFormatter;
        }

        public MemberReportGenerator(
      Type type,
      InvolvedType involvedTypeOrNull,
      IIdentifierGenerator<Type> involvedTypeIdentifierGeneratorOrNull,
      IIdentifierGenerator<MemberInfo> memberIdentifierGeneratorOrNull,
      IOutputFormatter outputFormatter)
        {
            ArgumentUtility.CheckNotNull ("type", type);
              // may be null
              // ArgumentUtility.CheckNotNull ("involvedTypeOrNull", involvedTypeOrNull);
              // ArgumentUtility.CheckNotNull ("involvedTypeIdentifierGeneratorOrNull", involvedTypeIdentifierGeneratorOrNull);
              // ArgumentUtility.CheckNotNull ("memberIdentifierGeneratorOrNull", memberIdentifierGeneratorOrNull);
              ArgumentUtility.CheckNotNull ("outputFormatter", outputFormatter);

              _type = type;
              _involvedType = involvedTypeOrNull;
              _involvedTypeIdentifierGenerator = involvedTypeIdentifierGeneratorOrNull;
              _memberIdentifierGenerator = memberIdentifierGeneratorOrNull;
              _outputFormatter = outputFormatter;
              _memberSignatureUtility = new MemberSignatureUtility (outputFormatter);
        }

        private static ActionContext CreateMockActionContext(
                                                             HttpResponse response = null,
                                                             string requestAcceptHeader = "application/*",
                                                             string requestContentType = "application/json",
                                                             string requestAcceptCharsetHeader = "",
                                                             bool respectBrowserAcceptHeader = false)
        {
            var formatters = new IOutputFormatter[] { new StringOutputFormatter(), new JsonOutputFormatter() };
            var httpContext = new Mock<HttpContext>();
            if (response != null)
            {
                httpContext.Setup(o => o.Response).Returns(response);
            }

            var content = "{name: 'Person Name', Age: 'not-an-age'}";
            var contentBytes = Encoding.UTF8.GetBytes(content);

            var request = new DefaultHttpContext().Request;
            request.Headers["Accept-Charset"] = requestAcceptCharsetHeader;
            request.Headers["Accept"] = requestAcceptHeader;
            request.ContentType = requestContentType;
            request.Body = new MemoryStream(contentBytes);

            httpContext.Setup(o => o.Request).Returns(request);
            httpContext.Setup(o => o.RequestServices).Returns(GetServiceProvider());
            httpContext.Setup(o => o.RequestServices.GetService(typeof(IOutputFormattersProvider)))
                       .Returns(new TestOutputFormatterProvider(formatters));

            var options = new Mock<IOptions<MvcOptions>>();
            options.SetupGet(o => o.Options)
                       .Returns(new MvcOptions()
                       {
                           RespectBrowserAcceptHeader = respectBrowserAcceptHeader
                       });
            httpContext.Setup(o => o.RequestServices.GetService(typeof(IOptions<MvcOptions>)))
                       .Returns(options.Object);

            return new ActionContext(httpContext.Object, new RouteData(), new ActionDescriptor());
        }

        public async Task ObjectResult_PerformsContentNegotiation_OnAllMediaRangeAcceptHeaderMediaType(
            string acceptHeader,
            string expectedResponseContentType)
        {
            // Arrange
            var objectResult = new ObjectResult(new Person() { Name = "John" });
            var outputFormatters = new IOutputFormatter[] {
                new HttpNoContentOutputFormatter(),
                new StringOutputFormatter(),
                new JsonOutputFormatter(),
                new XmlDataContractSerializerOutputFormatter()
            };
            var response = GetMockHttpResponse();

            var actionContext = CreateMockActionContext(
                                    outputFormatters,
                                    response.Object,
                                    requestAcceptHeader: acceptHeader,
                                    respectBrowserAcceptHeader: true);

            // Act
            await objectResult.ExecuteResultAsync(actionContext);

            // Assert
            response.VerifySet(resp => resp.ContentType = expectedResponseContentType);
        }

        public MemberSignatureUtility(IOutputFormatter outputFormatter)
        {
            ArgumentUtility.CheckNotNull ("outputFormatter", outputFormatter);

              _outputFormatter = outputFormatter;
        }

        public async Task ObjectResult_WithStream_SetsExplicitContentType()
        {
            // Arrange
            var objectResult = new ObjectResult(new MemoryStream(Encoding.UTF8.GetBytes("Name=James")));
            objectResult.ContentTypes.Add(new MediaTypeHeaderValue("application/foo"));
            var outputFormatters = new IOutputFormatter[]
            {
                new StreamOutputFormatter(),
                new JsonOutputFormatter()
            };
            var response = new Mock<HttpResponse>();
            var responseStream = new MemoryStream();
            response.SetupGet(r => r.Body).Returns(responseStream);
            var expectedData = "Name=James";

            var actionContext = CreateMockActionContext(
                                    outputFormatters,
                                    response.Object,
                                    requestAcceptHeader: "application/json",
                                    requestContentType: null);

            // Act
            await objectResult.ExecuteResultAsync(actionContext);

            // Assert
            response.VerifySet(r => r.ContentType = "application/foo");
            responseStream.Position = 0;
            var actual = new StreamReader(responseStream).ReadToEnd();
            Assert.Equal(expectedData, actual);
        }

        private static ActionContext CreateMockActionContext(
            HttpResponse response = null,
            string requestAcceptHeader = "application/*",
            string requestContentType = "application/json",
            string requestAcceptCharsetHeader = "",
            bool respectBrowserAcceptHeader = false)
        {
            var formatters = new IOutputFormatter[] { new StringOutputFormatter(), new JsonOutputFormatter() };

            return CreateMockActionContext(
                                            formatters,
                                            response: response,
                                            requestAcceptHeader: requestAcceptHeader,
                                            requestContentType: requestContentType,
                                            requestAcceptCharsetHeader: requestAcceptCharsetHeader,
                                            respectBrowserAcceptHeader: respectBrowserAcceptHeader);
        }