org.springframework.http.MediaType.isCompatibleWith()

/**
 * Returns {@code true} if the given media type includes any of the
 * {@linkplain #setSupportedMediaTypes(List) supported media types}.
 * @param mediaType the media type to write, can be {@code null} if not specified.
 * Typically the value of an {@code Accept} header.
 * @return {@code true} if the supported media types are compatible with the media type,
 * or if the media type is {@code null}
 */
protected boolean canWrite(@Nullable MediaType mediaType) {
    if (mediaType == null || MediaType.ALL.equalsTypeAndSubtype(mediaType)) {
        return true;
    }
    for (MediaType supportedMediaType : getSupportedMediaTypes()) {
        if (supportedMediaType.isCompatibleWith(mediaType)) {
            return true;
        }
    }
    return false;
}

/**
 * replacedert the request content type is compatible with the given
 * content type as defined by {@link MediaType#isCompatibleWith(MediaType)}.
 */
public RequestMatcher contentTypeCompatibleWith(final MediaType contentType) {
    return request -> {
        MediaType actualContentType = request.getHeaders().getContentType();
        replacedertTrue("Content type not set", actualContentType != null);
        if (actualContentType != null) {
            replacedertTrue("Content type [" + actualContentType + "] is not compatible with [" + contentType + "]", actualContentType.isCompatibleWith(contentType));
        }
    };
}

/**
 * replacedert the request content type is compatible with the given
 * content type as defined by {@link MediaType#isCompatibleWith(MediaType)}.
 */
public RequestMatcher contentTypeCompatibleWith(MediaType contentType) {
    return request -> {
        MediaType actualContentType = request.getHeaders().getContentType();
        replacedertTrue("Content type not set", actualContentType != null);
        if (actualContentType != null) {
            replacedertTrue("Content type [" + actualContentType + "] is not compatible with [" + contentType + "]", actualContentType.isCompatibleWith(contentType));
        }
    };
}

/**
 * Returns {@code true} if the given media type includes any of the
 * {@linkplain #setSupportedMediaTypes(List) supported media types}.
 * @param mediaType the media type to write, can be {@code null} if not specified.
 * Typically the value of an {@code Accept} header.
 * @return {@code true} if the supported media types are compatible with the media type,
 * or if the media type is {@code null}
 */
protected boolean canWrite(MediaType mediaType) {
    if (mediaType == null || MediaType.ALL.equals(mediaType)) {
        return true;
    }
    for (MediaType supportedMediaType : getSupportedMediaTypes()) {
        if (supportedMediaType.isCompatibleWith(mediaType)) {
            return true;
        }
    }
    return false;
}

@Override
public boolean canWrite(Clreplaced<?> clazz, MediaType mediaType) {
    if (!MultiValueMap.clreplaced.isreplacedignableFrom(clazz)) {
        return false;
    }
    if (mediaType == null || MediaType.ALL.equals(mediaType)) {
        return true;
    }
    for (MediaType supportedMediaType : getSupportedMediaTypes()) {
        if (supportedMediaType.isCompatibleWith(mediaType)) {
            return true;
        }
    }
    return false;
}

@Override
public boolean canWrite(Clreplaced<?> clazz, @Nullable MediaType mediaType) {
    if (!MultiValueMap.clreplaced.isreplacedignableFrom(clazz)) {
        return false;
    }
    if (mediaType == null || MediaType.ALL.equals(mediaType)) {
        return true;
    }
    for (MediaType supportedMediaType : getSupportedMediaTypes()) {
        if (supportedMediaType.isCompatibleWith(mediaType)) {
            return true;
        }
    }
    return false;
}

/**
 * replacedert the ServletResponse content type is compatible with the given
 * content type as defined by {@link MediaType#isCompatibleWith(MediaType)}.
 */
public ResultMatcher contentTypeCompatibleWith(final MediaType contentType) {
    return result -> {
        String actual = result.getResponse().getContentType();
        replacedertTrue("Content type not set", actual != null);
        if (actual != null) {
            MediaType actualContentType = MediaType.parseMediaType(actual);
            replacedertTrue("Content type [" + actual + "] is not compatible with [" + contentType + "]", actualContentType.isCompatibleWith(contentType));
        }
    };
}

/**
 * replacedert the ServletResponse content type is compatible with the given
 * content type as defined by {@link MediaType#isCompatibleWith(MediaType)}.
 */
public ResultMatcher contentTypeCompatibleWith(MediaType contentType) {
    return result -> {
        String actual = result.getResponse().getContentType();
        replacedertNotNull("Content type not set", actual);
        MediaType actualContentType = MediaType.parseMediaType(actual);
        replacedertTrue("Content type [" + actual + "] is not compatible with [" + contentType + "]", actualContentType.isCompatibleWith(contentType));
    };
}

@Override
protected boolean canWrite(MediaType mediaType) {
    if (mediaType == null || MediaType.ALL.equals(mediaType)) {
        return true;
    }
    for (MediaType supportedMediaType : getSupportedMediaTypes()) {
        if (supportedMediaType.isCompatibleWith(mediaType)) {
            return true;
        }
    }
    return false;
}

@Override
protected boolean canRead(MediaType mediaType) {
    if (mediaType == null) {
        return true;
    }
    for (MediaType supportedMediaType : getSupportedMediaTypes()) {
        if (supportedMediaType.isCompatibleWith(mediaType)) {
            return true;
        }
    }
    return false;
}

private Mono<? extends Void> render(List<View> views, Map<String, Object> model, ServerWebExchange exchange) {
    for (View view : views) {
        if (view.isRedirectView()) {
            return view.render(model, null, exchange);
        }
    }
    List<MediaType> mediaTypes = getMediaTypes(views);
    MediaType bestMediaType = selectMediaType(exchange, () -> mediaTypes);
    if (bestMediaType != null) {
        for (View view : views) {
            for (MediaType mediaType : view.getSupportedMediaTypes()) {
                if (mediaType.isCompatibleWith(bestMediaType)) {
                    return view.render(model, mediaType, exchange);
                }
            }
        }
    }
    throw new NotAcceptableStatusException(mediaTypes);
}

private Mono<? extends Void> render(List<View> views, Map<String, Object> model, BindingContext bindingContext, ServerWebExchange exchange) {
    for (View view : views) {
        if (view.isRedirectView()) {
            return renderWith(view, model, null, exchange, bindingContext);
        }
    }
    List<MediaType> mediaTypes = getMediaTypes(views);
    MediaType bestMediaType = selectMediaType(exchange, () -> mediaTypes);
    if (bestMediaType != null) {
        for (View view : views) {
            for (MediaType mediaType : view.getSupportedMediaTypes()) {
                if (mediaType.isCompatibleWith(bestMediaType)) {
                    return renderWith(view, model, mediaType, exchange, bindingContext);
                }
            }
        }
    }
    throw new NotAcceptableStatusException(mediaTypes);
}

private void replacedertMultipart(RecordedRequest request, MediaType mediaType) {
    replacedertThat(mediaType.isCompatibleWith(new MediaType("multipart", "*"))).as("multipart/*").isTrue();
    String boundary = mediaType.getParameter("boundary");
    replacedertThat(boundary).as("boundary").isNotBlank();
    Buffer body = request.getBody();
    try {
        replacedertPart(body, "form-data", boundary, "name 1", "text/plain", "value 1");
        replacedertPart(body, "form-data", boundary, "name 2", "text/plain", "value 2+1");
        replacedertPart(body, "form-data", boundary, "name 2", "text/plain", "value 2+2");
        replacedertFilePart(body, "form-data", boundary, "logo", "logo.jpg", "image/jpeg");
    } catch (EOFException ex) {
        throw new replacedertionError(ex);
    }
}

/**
 * GET /user/{username} : Get user by user name
 *
 * @param username The name that needs to be fetched. Use user1 for testing. (required)
 * @return successful operation (status code 200)
 *         or Invalid username supplied (status code 400)
 *         or User not found (status code 404)
 * @see UserApi#getUserByName
 */
public ResponseEnreplacedy<User> getUserByName(@ApiParam(value = "The name that needs to be fetched. Use user1 for testing.", required = true) @PathVariable("username") String username) {
    for (MediaType mediaType : MediaType.parseMediaTypes(request.getHeader("Accept"))) {
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/json"))) {
            String exampleString = "{ \"firstName\" : \"firstName\", \"lastName\" : \"lastName\", \"preplacedword\" : \"preplacedword\", \"userStatus\" : 6, \"phone\" : \"phone\", \"id\" : 0, \"email\" : \"email\", \"username\" : \"username\" }";
            ApiUtil.setExampleResponse(request, "application/json", exampleString);
            break;
        }
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/xml"))) {
            String exampleString = "<User> <id>123456789</id> <username>aeiou</username> <firstName>aeiou</firstName> <lastName>aeiou</lastName> <email>aeiou</email> <preplacedword>aeiou</preplacedword> <phone>aeiou</phone> <userStatus>123</userStatus> </User>";
            ApiUtil.setExampleResponse(request, "application/xml", exampleString);
            break;
        }
    }
    return new ResponseEnreplacedy<>(HttpStatus.NOT_IMPLEMENTED);
}

/**
 * GET /store/order/{order_id} : Find purchase order by ID
 * For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
 *
 * @param orderId ID of pet that needs to be fetched (required)
 * @return successful operation (status code 200)
 *         or Invalid ID supplied (status code 400)
 *         or Order not found (status code 404)
 * @see StoreApi#getOrderById
 */
public ResponseEnreplacedy<Order> getOrderById(@Min(1L) @Max(5L) @ApiParam(value = "ID of pet that needs to be fetched", required = true) @PathVariable("order_id") Long orderId) {
    for (MediaType mediaType : MediaType.parseMediaTypes(request.getHeader("Accept"))) {
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/json"))) {
            String exampleString = "{ \"petId\" : 6, \"quanreplacedy\" : 1, \"id\" : 0, \"shipDate\" : \"2000-01-23T04:56:07.000+00:00\", \"complete\" : false, \"status\" : \"placed\" }";
            ApiUtil.setExampleResponse(request, "application/json", exampleString);
            break;
        }
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/xml"))) {
            String exampleString = "<Order> <id>123456789</id> <petId>123456789</petId> <quanreplacedy>123</quanreplacedy> <shipDate>2000-01-23T04:56:07.000Z</shipDate> <status>aeiou</status> <complete>true</complete> </Order>";
            ApiUtil.setExampleResponse(request, "application/xml", exampleString);
            break;
        }
    }
    return new ResponseEnreplacedy<>(HttpStatus.NOT_IMPLEMENTED);
}

/**
 * GET /pet/{petId} : Find pet by ID
 * Returns a single pet
 *
 * @param petId ID of pet to return (required)
 * @return successful operation (status code 200)
 *         or Invalid ID supplied (status code 400)
 *         or Pet not found (status code 404)
 * @see PetApi#getPetById
 */
public ResponseEnreplacedy<Pet> getPetById(@ApiParam(value = "ID of pet to return", required = true) @PathVariable("petId") Long petId) {
    for (MediaType mediaType : MediaType.parseMediaTypes(request.getHeader("Accept"))) {
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/json"))) {
            String exampleString = "{ \"photoUrls\" : [ \"photoUrls\", \"photoUrls\" ], \"name\" : \"doggie\", \"id\" : 0, \"category\" : { \"name\" : \"default-name\", \"id\" : 6 }, \"tags\" : [ { \"name\" : \"name\", \"id\" : 1 }, { \"name\" : \"name\", \"id\" : 1 } ], \"status\" : \"available\" }";
            ApiUtil.setExampleResponse(request, "application/json", exampleString);
            break;
        }
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/xml"))) {
            String exampleString = "<Pet> <id>123456789</id> <name>doggie</name> <photoUrls> <photoUrls>aeiou</photoUrls> </photoUrls> <tags> </tags> <status>aeiou</status> </Pet>";
            ApiUtil.setExampleResponse(request, "application/xml", exampleString);
            break;
        }
    }
    return new ResponseEnreplacedy<>(HttpStatus.NOT_IMPLEMENTED);
}

/**
 * POST /fake/outer/composite
 * Test serialization of object with outer number type
 *
 * @param body Input composite as post body (optional)
 * @return Output composite (status code 200)
 * @see FakeApi#fakeOuterCompositeSerialize
 */
public ResponseEnreplacedy<OuterComposite> fakeOuterCompositeSerialize(@ApiParam(value = "Input composite as post body") @Valid @RequestBody(required = false) OuterComposite body) {
    for (MediaType mediaType : MediaType.parseMediaTypes(request.getHeader("Accept"))) {
        if (mediaType.isCompatibleWith(MediaType.valueOf("*/*"))) {
            String exampleString = "{ \"my_string\" : \"my_string\", \"my_number\" : 0.8008281904610115, \"my_boolean\" : true }";
            ApiUtil.setExampleResponse(request, "*/*", exampleString);
            break;
        }
    }
    return new ResponseEnreplacedy<>(HttpStatus.NOT_IMPLEMENTED);
}

/**
 * GET /pet/findByStatus : Finds Pets by status
 * Multiple status values can be provided with comma separated strings
 *
 * @param status Status values that need to be considered for filter (required)
 * @return successful operation (status code 200)
 *         or Invalid status value (status code 400)
 * @see PetApi#findPetsByStatus
 */
public ResponseEnreplacedy<List<Pet>> findPetsByStatus(@NotNull @ApiParam(value = "Status values that need to be considered for filter", required = true, allowableValues = "available, pending, sold") @Valid @RequestParam(value = "status", required = true) List<String> status) {
    for (MediaType mediaType : MediaType.parseMediaTypes(request.getHeader("Accept"))) {
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/json"))) {
            String exampleString = "{ \"photoUrls\" : [ \"photoUrls\", \"photoUrls\" ], \"name\" : \"doggie\", \"id\" : 0, \"category\" : { \"name\" : \"default-name\", \"id\" : 6 }, \"tags\" : [ { \"name\" : \"name\", \"id\" : 1 }, { \"name\" : \"name\", \"id\" : 1 } ], \"status\" : \"available\" }";
            ApiUtil.setExampleResponse(request, "application/json", exampleString);
            break;
        }
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/xml"))) {
            String exampleString = "<Pet> <id>123456789</id> <name>doggie</name> <photoUrls> <photoUrls>aeiou</photoUrls> </photoUrls> <tags> </tags> <status>aeiou</status> </Pet>";
            ApiUtil.setExampleResponse(request, "application/xml", exampleString);
            break;
        }
    }
    return new ResponseEnreplacedy<>(HttpStatus.NOT_IMPLEMENTED);
}

/**
 * GET /pet/findByTags : Finds Pets by tags
 * Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
 *
 * @param tags Tags to filter by (required)
 * @return successful operation (status code 200)
 *         or Invalid tag value (status code 400)
 * @deprecated
 * @see PetApi#findPetsByTags
 */
public ResponseEnreplacedy<Set<Pet>> findPetsByTags(@NotNull @ApiParam(value = "Tags to filter by", required = true) @Valid @RequestParam(value = "tags", required = true) Set<String> tags) {
    for (MediaType mediaType : MediaType.parseMediaTypes(request.getHeader("Accept"))) {
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/json"))) {
            String exampleString = "{ \"photoUrls\" : [ \"photoUrls\", \"photoUrls\" ], \"name\" : \"doggie\", \"id\" : 0, \"category\" : { \"name\" : \"default-name\", \"id\" : 6 }, \"tags\" : [ { \"name\" : \"name\", \"id\" : 1 }, { \"name\" : \"name\", \"id\" : 1 } ], \"status\" : \"available\" }";
            ApiUtil.setExampleResponse(request, "application/json", exampleString);
            break;
        }
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/xml"))) {
            String exampleString = "<Pet> <id>123456789</id> <name>doggie</name> <photoUrls> <photoUrls>aeiou</photoUrls> </photoUrls> <tags> </tags> <status>aeiou</status> </Pet>";
            ApiUtil.setExampleResponse(request, "application/xml", exampleString);
            break;
        }
    }
    return new ResponseEnreplacedy<>(HttpStatus.NOT_IMPLEMENTED);
}

private MockResponse multipartRelatedRequest(RecordedRequest request) {
    MediaType mediaType = MediaType.parseMediaType(request.getHeader(CONTENT_TYPE));
    replacedertThat(mediaType.isCompatibleWith(MULTIPART_RELATED)).as(MULTIPART_RELATED.toString()).isTrue();
    replacedertMultipart(request, mediaType);
    return new MockResponse().setResponseCode(200);
}

private MockResponse multipartMixedRequest(RecordedRequest request) {
    MediaType mediaType = MediaType.parseMediaType(request.getHeader(CONTENT_TYPE));
    replacedertThat(mediaType.isCompatibleWith(MULTIPART_MIXED)).as(MULTIPART_MIXED.toString()).isTrue();
    replacedertMultipart(request, mediaType);
    return new MockResponse().setResponseCode(200);
}

private MockResponse multipartFormDataRequest(RecordedRequest request) {
    MediaType mediaType = MediaType.parseMediaType(request.getHeader(CONTENT_TYPE));
    replacedertThat(mediaType.isCompatibleWith(MULTIPART_FORM_DATA)).as(MULTIPART_FORM_DATA.toString()).isTrue();
    replacedertMultipart(request, mediaType);
    return new MockResponse().setResponseCode(200);
}

/**
 * POST /store/order : Place an order for a pet
 *
 * @param body order placed for purchasing the pet (required)
 * @return successful operation (status code 200)
 *         or Invalid Order (status code 400)
 * @see StoreApi#placeOrder
 */
public ResponseEnreplacedy<Order> placeOrder(@ApiParam(value = "order placed for purchasing the pet", required = true) @Valid @RequestBody Order body) {
    for (MediaType mediaType : MediaType.parseMediaTypes(request.getHeader("Accept"))) {
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/json"))) {
            String exampleString = "{ \"petId\" : 6, \"quanreplacedy\" : 1, \"id\" : 0, \"shipDate\" : \"2000-01-23T04:56:07.000+00:00\", \"complete\" : false, \"status\" : \"placed\" }";
            ApiUtil.setExampleResponse(request, "application/json", exampleString);
            break;
        }
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/xml"))) {
            String exampleString = "<Order> <id>123456789</id> <petId>123456789</petId> <quanreplacedy>123</quanreplacedy> <shipDate>2000-01-23T04:56:07.000Z</shipDate> <status>aeiou</status> <complete>true</complete> </Order>";
            ApiUtil.setExampleResponse(request, "application/xml", exampleString);
            break;
        }
    }
    return new ResponseEnreplacedy<>(HttpStatus.NOT_IMPLEMENTED);
}

/**
 * POST /pet/{petId}/uploadImage : uploads an image
 *
 * @param petId ID of pet to update (required)
 * @param additionalMetadata Additional data to preplaced to server (optional)
 * @param file file to upload (optional)
 * @return successful operation (status code 200)
 * @see PetApi#uploadFile
 */
public ResponseEnreplacedy<ModelApiResponse> uploadFile(@ApiParam(value = "ID of pet to update", required = true) @PathVariable("petId") Long petId, @ApiParam(value = "Additional data to preplaced to server") @Valid @RequestPart(value = "additionalMetadata", required = false) String additionalMetadata, @ApiParam(value = "file to upload") @Valid @RequestPart(value = "file", required = false) MultipartFile file) {
    for (MediaType mediaType : MediaType.parseMediaTypes(request.getHeader("Accept"))) {
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/json"))) {
            String exampleString = "{ \"code\" : 0, \"type\" : \"type\", \"message\" : \"message\" }";
            ApiUtil.setExampleResponse(request, "application/json", exampleString);
            break;
        }
    }
    return new ResponseEnreplacedy<>(HttpStatus.NOT_IMPLEMENTED);
}

/**
 * GET /pet/findByStatus : Finds Pets by status
 * Multiple status values can be provided with comma separated strings
 *
 * @param status Status values that need to be considered for filter (required)
 * @return successful operation (status code 200)
 *         or Invalid status value (status code 400)
 * @see PetApi#findPetsByStatus
 */
public ResponseEnreplacedy<List<Pet>> findPetsByStatus(@NotNull @ApiParam(value = "Status values that need to be considered for filter", required = true, allowableValues = "available, pending, sold") @Valid @RequestParam(value = "status", required = true) List<String> status, @ApiIgnore final Pageable pageable) {
    for (MediaType mediaType : MediaType.parseMediaTypes(request.getHeader("Accept"))) {
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/json"))) {
            String exampleString = "{ \"photoUrls\" : [ \"photoUrls\", \"photoUrls\" ], \"name\" : \"doggie\", \"id\" : 0, \"category\" : { \"name\" : \"default-name\", \"id\" : 6 }, \"tags\" : [ { \"name\" : \"name\", \"id\" : 1 }, { \"name\" : \"name\", \"id\" : 1 } ], \"status\" : \"available\" }";
            ApiUtil.setExampleResponse(request, "application/json", exampleString);
            break;
        }
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/xml"))) {
            String exampleString = "<Pet> <id>123456789</id> <name>doggie</name> <photoUrls> <photoUrls>aeiou</photoUrls> </photoUrls> <tags> </tags> <status>aeiou</status> </Pet>";
            ApiUtil.setExampleResponse(request, "application/xml", exampleString);
            break;
        }
    }
    return new ResponseEnreplacedy<>(HttpStatus.NOT_IMPLEMENTED);
}

/**
 * GET /pet/findByTags : Finds Pets by tags
 * Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
 *
 * @param tags Tags to filter by (required)
 * @return successful operation (status code 200)
 *         or Invalid tag value (status code 400)
 * @deprecated
 * @see PetApi#findPetsByTags
 */
public ResponseEnreplacedy<List<Pet>> findPetsByTags(@NotNull @ApiParam(value = "Tags to filter by", required = true) @Valid @RequestParam(value = "tags", required = true) List<String> tags, @ApiIgnore final Pageable pageable) {
    for (MediaType mediaType : MediaType.parseMediaTypes(request.getHeader("Accept"))) {
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/json"))) {
            String exampleString = "{ \"photoUrls\" : [ \"photoUrls\", \"photoUrls\" ], \"name\" : \"doggie\", \"id\" : 0, \"category\" : { \"name\" : \"default-name\", \"id\" : 6 }, \"tags\" : [ { \"name\" : \"name\", \"id\" : 1 }, { \"name\" : \"name\", \"id\" : 1 } ], \"status\" : \"available\" }";
            ApiUtil.setExampleResponse(request, "application/json", exampleString);
            break;
        }
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/xml"))) {
            String exampleString = "<Pet> <id>123456789</id> <name>doggie</name> <photoUrls> <photoUrls>aeiou</photoUrls> </photoUrls> <tags> </tags> <status>aeiou</status> </Pet>";
            ApiUtil.setExampleResponse(request, "application/xml", exampleString);
            break;
        }
    }
    return new ResponseEnreplacedy<>(HttpStatus.NOT_IMPLEMENTED);
}

/**
 * PATCH /fake_clreplacedname_test : To test clreplaced name in snake case
 * To test clreplaced name in snake case
 *
 * @param body client model (required)
 * @return successful operation (status code 200)
 * @see FakeClreplacednameTestApi#testClreplacedname
 */
public ResponseEnreplacedy<Client> testClreplacedname(@ApiParam(value = "client model", required = true) @Valid @RequestBody Client body) {
    for (MediaType mediaType : MediaType.parseMediaTypes(request.getHeader("Accept"))) {
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/json"))) {
            String exampleString = "{ \"client\" : \"client\" }";
            ApiUtil.setExampleResponse(request, "application/json", exampleString);
            break;
        }
    }
    return new ResponseEnreplacedy<>(HttpStatus.NOT_IMPLEMENTED);
}

/**
 * POST /fake/{petId}/uploadImageWithRequiredFile : uploads an image (required)
 *
 * @param petId ID of pet to update (required)
 * @param requiredFile file to upload (required)
 * @param additionalMetadata Additional data to preplaced to server (optional)
 * @return successful operation (status code 200)
 * @see FakeApi#uploadFileWithRequiredFile
 */
public ResponseEnreplacedy<ModelApiResponse> uploadFileWithRequiredFile(@ApiParam(value = "ID of pet to update", required = true) @PathVariable("petId") Long petId, @ApiParam(value = "file to upload") @Valid @RequestPart(value = "requiredFile", required = true) MultipartFile requiredFile, @ApiParam(value = "Additional data to preplaced to server") @Valid @RequestPart(value = "additionalMetadata", required = false) String additionalMetadata) {
    for (MediaType mediaType : MediaType.parseMediaTypes(request.getHeader("Accept"))) {
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/json"))) {
            String exampleString = "{ \"code\" : 0, \"type\" : \"type\", \"message\" : \"message\" }";
            ApiUtil.setExampleResponse(request, "application/json", exampleString);
            break;
        }
    }
    return new ResponseEnreplacedy<>(HttpStatus.NOT_IMPLEMENTED);
}

/**
 * PATCH /fake : To test \"client\" model
 * To test \"client\" model
 *
 * @param body client model (required)
 * @return successful operation (status code 200)
 * @see FakeApi#testClientModel
 */
public ResponseEnreplacedy<Client> testClientModel(@ApiParam(value = "client model", required = true) @Valid @RequestBody Client body) {
    for (MediaType mediaType : MediaType.parseMediaTypes(request.getHeader("Accept"))) {
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/json"))) {
            String exampleString = "{ \"client\" : \"client\" }";
            ApiUtil.setExampleResponse(request, "application/json", exampleString);
            break;
        }
    }
    return new ResponseEnreplacedy<>(HttpStatus.NOT_IMPLEMENTED);
}

/**
 * PATCH /another-fake/dummy : To test special tags
 * To test special tags and operation ID starting with number
 *
 * @param body client model (required)
 * @return successful operation (status code 200)
 * @see AnotherFakeApi#call123testSpecialTags
 */
public ResponseEnreplacedy<Client> call123testSpecialTags(@ApiParam(value = "client model", required = true) @Valid @RequestBody Client body) {
    for (MediaType mediaType : MediaType.parseMediaTypes(request.getHeader("Accept"))) {
        if (mediaType.isCompatibleWith(MediaType.valueOf("application/json"))) {
            String exampleString = "{ \"client\" : \"client\" }";
            ApiUtil.setExampleResponse(request, "application/json", exampleString);
            break;
        }
    }
    return new ResponseEnreplacedy<>(HttpStatus.NOT_IMPLEMENTED);
}

private void replacedertThatPathProducesExpectedResponse(String path, MediaType accept, MediaType contentType) {
    RequestEnreplacedy<Void> request = RequestEnreplacedy.get(URI.create("http://localhost:" + this.port + path)).accept(accept).build();
    ResponseEnreplacedy<String> response = this.rest.exchange(request, String.clreplaced);
    replacedertThat(response.getStatusCode()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR);
    replacedertThat(contentType.isCompatibleWith(response.getHeaders().getContentType())).as("%s is compatible with %s", contentType, response.getHeaders().getContentType()).isTrue();
}

@Override
public String extractData(ClientHttpResponse response) throws IOException {
    MediaType contentType = response.getHeaders().getContentType();
    if (contentType.isCompatibleWith(MediaType.TEXT_HTML)) {
        String body = getBody(response);
        Pattern pattern = Pattern.compile("\\Qwindow.location.href=\"\\E(\\Qhttp://www.moddb.com/downloads/\\E.*?)\"", Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(body);
        if (matcher.find()) {
            return matcher.group(1);
        }
        throw new SourceException("Received unexpected text/html response.");
    }
    long contentLength = response.getHeaders().getContentLength();
    this.progressListeners.detail(StringUtils.formatByteCount(contentLength));
    Files.createDirectories(this.targetFile.getParent());
    long copied = 0;
    this.progressListeners.stepProgress((int) copied, (int) contentLength);
    byte[] buffer = new byte[4096];
    try (InputStream inputStream = response.getBody();
        OutputStream outputStream = Files.newOutputStream(this.targetFile)) {
        while (true) {
            int count = inputStream.read(buffer);
            if (count == -1) {
                break;
            }
            copied += count;
            outputStream.write(buffer, 0, count);
            this.progressListeners.stepProgress((int) copied, (int) contentLength);
        }
    }
    return null;
}

private MockResponse multipartRequest(RecordedRequest request) {
    MediaType mediaType = MediaType.parseMediaType(request.getHeader("Content-Type"));
    replacedertTrue(mediaType.isCompatibleWith(MediaType.MULTIPART_FORM_DATA));
    String boundary = mediaType.getParameter("boundary");
    Buffer body = request.getBody();
    try {
        replacedertPart(body, "form-data", boundary, "name 1", "text/plain", "value 1");
        replacedertPart(body, "form-data", boundary, "name 2", "text/plain", "value 2+1");
        replacedertPart(body, "form-data", boundary, "name 2", "text/plain", "value 2+2");
        replacedertFilePart(body, "form-data", boundary, "logo", "logo.jpg", "image/jpeg");
    } catch (EOFException ex) {
        throw new IllegalStateException(ex);
    }
    return new MockResponse().setResponseCode(200);
}

/**
 * Determines the list of {@link MediaType} for the given {@link HttpServletRequest}.
 * @param request the current servlet request
 * @return the list of media types requested, if any
 */
protected List<MediaType> getMediaTypes(HttpServletRequest request) {
    try {
        ServletWebRequest webRequest = new ServletWebRequest(request);
        List<MediaType> acceptableMediaTypes = this.contentNegotiationManager.resolveMediaTypes(webRequest);
        acceptableMediaTypes = (!acceptableMediaTypes.isEmpty() ? acceptableMediaTypes : Collections.singletonList(MediaType.ALL));
        List<MediaType> producibleMediaTypes = getProducibleMediaTypes(request);
        Set<MediaType> compatibleMediaTypes = new LinkedHashSet<MediaType>();
        for (MediaType acceptable : acceptableMediaTypes) {
            for (MediaType producible : producibleMediaTypes) {
                if (acceptable.isCompatibleWith(producible)) {
                    compatibleMediaTypes.add(getMostSpecificMediaType(acceptable, producible));
                }
            }
        }
        List<MediaType> selectedMediaTypes = new ArrayList<MediaType>(compatibleMediaTypes);
        MediaType.sortBySpecificityAndQuality(selectedMediaTypes);
        if (logger.isDebugEnabled()) {
            logger.debug("Requested media types are " + selectedMediaTypes + " based on Accept header types " + "and producible media types " + producibleMediaTypes + ")");
        }
        return selectedMediaTypes;
    } catch (HttpMediaTypeNotAcceptableException ex) {
        return null;
    }
}

/**
 * Determines the list of {@link MediaType} for the given {@link HttpServletRequest}.
 * @param request the current servlet request
 * @return the list of media types requested, if any
 */
@Nullable
protected List<MediaType> getMediaTypes(HttpServletRequest request) {
    replacedert.state(this.contentNegotiationManager != null, "No ContentNegotiationManager set");
    try {
        ServletWebRequest webRequest = new ServletWebRequest(request);
        List<MediaType> acceptableMediaTypes = this.contentNegotiationManager.resolveMediaTypes(webRequest);
        List<MediaType> producibleMediaTypes = getProducibleMediaTypes(request);
        Set<MediaType> compatibleMediaTypes = new LinkedHashSet<>();
        for (MediaType acceptable : acceptableMediaTypes) {
            for (MediaType producible : producibleMediaTypes) {
                if (acceptable.isCompatibleWith(producible)) {
                    compatibleMediaTypes.add(getMostSpecificMediaType(acceptable, producible));
                }
            }
        }
        List<MediaType> selectedMediaTypes = new ArrayList<>(compatibleMediaTypes);
        MediaType.sortBySpecificityAndQuality(selectedMediaTypes);
        return selectedMediaTypes;
    } catch (HttpMediaTypeNotAcceptableException ex) {
        if (logger.isDebugEnabled()) {
            logger.debug(ex.getMessage());
        }
        return null;
    }
}

@Override
protected Message readInternal(Clreplaced<? extends Message> clazz, HttpInputMessage httpInputMessage) throws IOException {
    MediaType contentType = httpInputMessage.getHeaders().getContentType();
    if (contentType == null) {
        log.error("Accept must be set");
        throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Content Type must not be null!");
    }
    MediaType targetContentType = null;
    String targetContentTypeVersion = null;
    if (PROTOBUF_MEDIA_TYPE.isCompatibleWith(contentType)) {
        targetContentType = PROTOBUF_MEDIA_TYPE;
        targetContentTypeVersion = properties.getContentNegotiation().getProtobufVersion();
    } else if (JSON_MEDIA_TYPE.isCompatibleWith(contentType)) {
        targetContentType = JSON_MEDIA_TYPE;
        targetContentTypeVersion = properties.getContentNegotiation().getJsonVersion();
    }
    EfgsMdc.put("requestedMediaType", contentType.toString());
    if (targetContentType == null) {
        log.error("Accepted Content-Type is not compatible");
        throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Unknown Content-Type!");
    }
    if (contentType.getParameter(VERSION_STRING) == null) {
        log.error("Version parameter of Accepted Content-Type is required");
        throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Version parameter of Content-Type is required!");
    }
    try {
        if (!SemVerUtils.parseSemVerAndCheckCompatibility(targetContentTypeVersion, contentType.getParameter(VERSION_STRING))) {
            log.error("Serialization: Protocol version is not compatible");
            throw new ResponseStatusException(HttpStatus.NOT_ACCEPTABLE, "Protocol version is not compatible!");
        }
    } catch (SemVerUtils.SemVerParsingException e) {
        throw new ResponseStatusException(HttpStatus.BAD_REQUEST, e.getMessage());
    }
    Message.Builder builder;
    try {
        builder = (Message.Builder) clazz.getMethod("newBuilder").invoke(clazz);
    } catch (IllegalAccessException | IllegalArgumentException | NoSuchMethodException | SecurityException | InvocationTargetException e) {
        throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Invalid Protobuf Message type: no invocable newBuilder() method on " + clazz);
    }
    if (targetContentType == PROTOBUF_MEDIA_TYPE) {
        return builder.mergeFrom(httpInputMessage.getBody()).build();
    } else {
        ProtobufFormatter formatter = new ProtobufConverter();
        formatter.merge(httpInputMessage.getBody(), builder);
        return builder.build();
    }
}

@Override
protected Message readInternal(Clreplaced<? extends Message> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
    MediaType contentType = inputMessage.getHeaders().getContentType();
    if (contentType == null) {
        contentType = PROTOBUF;
    }
    Charset charset = contentType.getCharset();
    if (charset == null) {
        charset = DEFAULT_CHARSET;
    }
    Message.Builder builder = getMessageBuilder(clazz);
    if (PROTOBUF.isCompatibleWith(contentType)) {
        builder.mergeFrom(inputMessage.getBody(), this.extensionRegistry);
    } else if (TEXT_PLAIN.isCompatibleWith(contentType)) {
        InputStreamReader reader = new InputStreamReader(inputMessage.getBody(), charset);
        TextFormat.merge(reader, this.extensionRegistry, builder);
    } else if (this.protobufFormatSupport != null) {
        this.protobufFormatSupport.merge(inputMessage.getBody(), charset, contentType, this.extensionRegistry, builder);
    }
    return builder.build();
}

@Nullable
private View getBestView(List<View> candidateViews, List<MediaType> requestedMediaTypes, RequestAttributes attrs) {
    for (View candidateView : candidateViews) {
        if (candidateView instanceof SmartView) {
            SmartView smartView = (SmartView) candidateView;
            if (smartView.isRedirectView()) {
                return candidateView;
            }
        }
    }
    for (MediaType mediaType : requestedMediaTypes) {
        for (View candidateView : candidateViews) {
            if (StringUtils.hasText(candidateView.getContentType())) {
                MediaType candidateContentType = MediaType.parseMediaType(candidateView.getContentType());
                if (mediaType.isCompatibleWith(candidateContentType)) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Selected '" + mediaType + "' given " + requestedMediaTypes);
                    }
                    attrs.setAttribute(View.SELECTED_CONTENT_TYPE, mediaType, RequestAttributes.SCOPE_REQUEST);
                    return candidateView;
                }
            }
        }
    }
    return null;
}

/**
 * Select the best media type for the current request through a content negotiation algorithm.
 * @param exchange the current request
 * @param producibleTypesSupplier the media types that can be produced for the current request
 * @return the selected media type, or {@code null} if none
 */
@Nullable
protected MediaType selectMediaType(ServerWebExchange exchange, Supplier<List<MediaType>> producibleTypesSupplier) {
    MediaType contentType = exchange.getResponse().getHeaders().getContentType();
    if (contentType != null && contentType.isConcrete()) {
        if (logger.isDebugEnabled()) {
            logger.debug(exchange.getLogPrefix() + "Found 'Content-Type:" + contentType + "' in response");
        }
        return contentType;
    }
    List<MediaType> acceptableTypes = getAcceptableTypes(exchange);
    List<MediaType> producibleTypes = getProducibleTypes(exchange, producibleTypesSupplier);
    Set<MediaType> compatibleMediaTypes = new LinkedHashSet<>();
    for (MediaType acceptable : acceptableTypes) {
        for (MediaType producible : producibleTypes) {
            if (acceptable.isCompatibleWith(producible)) {
                compatibleMediaTypes.add(selectMoreSpecificMediaType(acceptable, producible));
            }
        }
    }
    List<MediaType> result = new ArrayList<>(compatibleMediaTypes);
    MediaType.sortBySpecificityAndQuality(result);
    MediaType selected = null;
    for (MediaType mediaType : result) {
        if (mediaType.isConcrete()) {
            selected = mediaType;
            break;
        } else if (mediaType.isPresentIn(ALL_APPLICATION_MEDIA_TYPES)) {
            selected = MediaType.APPLICATION_OCTET_STREAM;
            break;
        }
    }
    if (selected != null) {
        if (logger.isDebugEnabled()) {
            logger.debug("Using '" + selected + "' given " + acceptableTypes + " and supported " + producibleTypes);
        }
    } else if (logger.isDebugEnabled()) {
        logger.debug(exchange.getLogPrefix() + "No match for " + acceptableTypes + ", supported: " + producibleTypes);
    }
    return selected;
}

/**
 * Select the best media type for the current request through a content negotiation algorithm.
 * @param exchange the current request
 * @param producibleTypesSupplier the media types that can be produced for the current request
 * @return the selected media type, or {@code null} if none
 */
@Nullable
protected MediaType selectMediaType(ServerWebExchange exchange, Supplier<List<MediaType>> producibleTypesSupplier) {
    MediaType contentType = exchange.getResponse().getHeaders().getContentType();
    if (contentType != null && contentType.isConcrete()) {
        if (logger.isDebugEnabled()) {
            logger.debug(exchange.getLogPrefix() + "Found 'Content-Type:" + contentType + "' in response");
        }
        return contentType;
    }
    List<MediaType> acceptableTypes = getAcceptableTypes(exchange);
    List<MediaType> producibleTypes = getProducibleTypes(exchange, producibleTypesSupplier);
    Set<MediaType> compatibleMediaTypes = new LinkedHashSet<>();
    for (MediaType acceptable : acceptableTypes) {
        for (MediaType producible : producibleTypes) {
            if (acceptable.isCompatibleWith(producible)) {
                compatibleMediaTypes.add(selectMoreSpecificMediaType(acceptable, producible));
            }
        }
    }
    List<MediaType> result = new ArrayList<>(compatibleMediaTypes);
    MediaType.sortBySpecificityAndQuality(result);
    MediaType selected = null;
    for (MediaType mediaType : result) {
        if (mediaType.isConcrete()) {
            selected = mediaType;
            break;
        } else if (mediaType.isPresentIn(ALL_APPLICATION_MEDIA_TYPES)) {
            selected = MediaType.APPLICATION_OCTET_STREAM;
            break;
        }
    }
    if (selected != null) {
        selected = selected.removeQualityValue();
        if (logger.isDebugEnabled()) {
            logger.debug("Using '" + selected + "' given " + acceptableTypes + " and supported " + producibleTypes);
        }
    } else if (logger.isDebugEnabled()) {
        logger.debug(exchange.getLogPrefix() + "No match for " + acceptableTypes + ", supported: " + producibleTypes);
    }
    return selected;
}

private View getBestView(List<View> candidateViews, List<MediaType> requestedMediaTypes, RequestAttributes attrs) {
    for (View candidateView : candidateViews) {
        if (candidateView instanceof SmartView) {
            SmartView smartView = (SmartView) candidateView;
            if (smartView.isRedirectView()) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Returning redirect view [" + candidateView + "]");
                }
                return candidateView;
            }
        }
    }
    for (MediaType mediaType : requestedMediaTypes) {
        for (View candidateView : candidateViews) {
            if (StringUtils.hasText(candidateView.getContentType())) {
                MediaType candidateContentType = MediaType.parseMediaType(candidateView.getContentType());
                if (mediaType.isCompatibleWith(candidateContentType)) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Returning [" + candidateView + "] based on requested media type '" + mediaType + "'");
                    }
                    attrs.setAttribute(View.SELECTED_CONTENT_TYPE, mediaType, RequestAttributes.SCOPE_REQUEST);
                    return candidateView;
                }
            }
        }
    }
    return null;
}

@Override
protected void writeInternal(Message message, HttpOutputMessage httpOutputMessage) throws IOException {
    MediaType contentType = httpOutputMessage.getHeaders().getContentType();
    if (contentType == null) {
        log.error("Accept must be set");
        throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Accept must be set!");
    }
    EfgsMdc.put("requestedMediaType", contentType.toString());
    MediaType targetContentType = null;
    String targetContentTypeVersion = null;
    if (PROTOBUF_MEDIA_TYPE.isCompatibleWith(contentType)) {
        targetContentType = PROTOBUF_MEDIA_TYPE;
        targetContentTypeVersion = properties.getContentNegotiation().getProtobufVersion();
    } else if (JSON_MEDIA_TYPE.isCompatibleWith(contentType)) {
        targetContentType = JSON_MEDIA_TYPE;
        targetContentTypeVersion = properties.getContentNegotiation().getJsonVersion();
    }
    if (targetContentType == null) {
        log.error("Accepted Content-Type is not compatible");
        throw new ResponseStatusException(HttpStatus.UNSUPPORTED_MEDIA_TYPE, "Content-Type is not compatible");
    }
    if (contentType.getParameter(VERSION_STRING) == null) {
        log.error("Version parameter of Accepted Content-Type is required");
        throw new ResponseStatusException(HttpStatus.UNSUPPORTED_MEDIA_TYPE, "Version parameter of Content-Type is required!");
    }
    try {
        if (!SemVerUtils.parseSemVerAndCheckCompatibility(targetContentTypeVersion, contentType.getParameter(VERSION_STRING))) {
            log.error("Serialization: Protocol version is not compatible");
            throw new ResponseStatusException(HttpStatus.UNSUPPORTED_MEDIA_TYPE, "Protocol version is not compatible!");
        }
    } catch (SemVerUtils.SemVerParsingException e) {
        throw new ResponseStatusException(HttpStatus.UNSUPPORTED_MEDIA_TYPE, e.getMessage());
    }
    setProtoHeader(httpOutputMessage, message);
    if (targetContentType == PROTOBUF_MEDIA_TYPE) {
        CodedOutputStream codedOutputStream = CodedOutputStream.newInstance(httpOutputMessage.getBody());
        message.writeTo(codedOutputStream);
        codedOutputStream.flush();
    } else {
        ProtobufFormatter formatter = new ProtobufConverter();
        formatter.print(message, httpOutputMessage.getBody());
        httpOutputMessage.getBody().flush();
    }
}

/**
 * Resolve the most match {@link HttpMessageConverter} from {@link RequestMetadata}.
 * @param requestMetadata {@link RequestMetadata}
 * @param restMethodMetadata {@link RestMethodMetadata}
 * @return instance of {@link HttpMessageConverterHolder}
 */
public HttpMessageConverterHolder resolve(RequestMetadata requestMetadata, RestMethodMetadata restMethodMetadata) {
    HttpMessageConverterHolder httpMessageConverterHolder = null;
    Clreplaced<?> returnValueClreplaced = resolveReturnValueClreplaced(restMethodMetadata);
    /**
     * @see AbstractMessageConverterMethodProcessor#writeWithMessageConverters(T,
     * MethodParameter, ServletServerHttpRequest, ServletServerHttpResponse)
     */
    List<MediaType> requestedMediaTypes = getAcceptableMediaTypes(requestMetadata);
    List<MediaType> producibleMediaTypes = getProducibleMediaTypes(restMethodMetadata, returnValueClreplaced);
    Set<MediaType> compatibleMediaTypes = new LinkedHashSet<MediaType>();
    for (MediaType requestedType : requestedMediaTypes) {
        for (MediaType producibleType : producibleMediaTypes) {
            if (requestedType.isCompatibleWith(producibleType)) {
                compatibleMediaTypes.add(getMostSpecificMediaType(requestedType, producibleType));
            }
        }
    }
    if (compatibleMediaTypes.isEmpty()) {
        return httpMessageConverterHolder;
    }
    List<MediaType> mediaTypes = new ArrayList<>(compatibleMediaTypes);
    MediaType.sortBySpecificityAndQuality(mediaTypes);
    MediaType selectedMediaType = null;
    for (MediaType mediaType : mediaTypes) {
        if (mediaType.isConcrete()) {
            selectedMediaType = mediaType;
            break;
        } else if (mediaType.equals(MediaType.ALL) || mediaType.equals(MEDIA_TYPE_APPLICATION)) {
            selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;
            break;
        }
    }
    if (selectedMediaType != null) {
        selectedMediaType = selectedMediaType.removeQualityValue();
        for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
            if (messageConverter.canWrite(returnValueClreplaced, selectedMediaType)) {
                httpMessageConverterHolder = new HttpMessageConverterHolder(selectedMediaType, messageConverter);
                break;
            }
        }
    }
    return httpMessageConverterHolder;
}

@Override
protected void writeInternal(Message message, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
    MediaType contentType = outputMessage.getHeaders().getContentType();
    if (contentType == null) {
        contentType = getDefaultContentType(message);
        replacedert.state(contentType != null, "No content type");
    }
    Charset charset = contentType.getCharset();
    if (charset == null) {
        charset = DEFAULT_CHARSET;
    }
    if (PROTOBUF.isCompatibleWith(contentType)) {
        setProtoHeader(outputMessage, message);
        CodedOutputStream codedOutputStream = CodedOutputStream.newInstance(outputMessage.getBody());
        message.writeTo(codedOutputStream);
        codedOutputStream.flush();
    } else if (TEXT_PLAIN.isCompatibleWith(contentType)) {
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputMessage.getBody(), charset);
        TextFormat.print(message, outputStreamWriter);
        outputStreamWriter.flush();
        outputMessage.getBody().flush();
    } else if (this.protobufFormatSupport != null) {
        this.protobufFormatSupport.print(message, outputMessage.getBody(), contentType, charset);
        outputMessage.getBody().flush();
    }
}

/**
 * Writes the given return type to the given output message.
 * @param returnValue the value to write to the output message
 * @param returnType the type of the value
 * @param inputMessage the input messages. Used to inspect the {@code Accept} header.
 * @param outputMessage the output message to write to
 * @throws IOException thrown in case of I/O errors
 * @throws HttpMediaTypeNotAcceptableException thrown when the conditions indicated by {@code Accept} header on
 * the request cannot be met by the message converters
 */
@SuppressWarnings("unchecked")
protected <T> void writeWithMessageConverters(T returnValue, MethodParameter returnType, ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage) throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
    Clreplaced<?> returnValueClreplaced = getReturnValueType(returnValue, returnType);
    Type returnValueType = getGenericType(returnType);
    HttpServletRequest servletRequest = inputMessage.getServletRequest();
    List<MediaType> requestedMediaTypes = getAcceptableMediaTypes(servletRequest);
    List<MediaType> producibleMediaTypes = getProducibleMediaTypes(servletRequest, returnValueClreplaced, returnValueType);
    if (returnValue != null && producibleMediaTypes.isEmpty()) {
        throw new IllegalArgumentException("No converter found for return value of type: " + returnValueClreplaced);
    }
    Set<MediaType> compatibleMediaTypes = new LinkedHashSet<MediaType>();
    for (MediaType requestedType : requestedMediaTypes) {
        for (MediaType producibleType : producibleMediaTypes) {
            if (requestedType.isCompatibleWith(producibleType)) {
                compatibleMediaTypes.add(getMostSpecificMediaType(requestedType, producibleType));
            }
        }
    }
    if (compatibleMediaTypes.isEmpty()) {
        if (returnValue != null) {
            throw new HttpMediaTypeNotAcceptableException(producibleMediaTypes);
        }
        return;
    }
    List<MediaType> mediaTypes = new ArrayList<MediaType>(compatibleMediaTypes);
    MediaType.sortBySpecificityAndQuality(mediaTypes);
    MediaType selectedMediaType = null;
    for (MediaType mediaType : mediaTypes) {
        if (mediaType.isConcrete()) {
            selectedMediaType = mediaType;
            break;
        } else if (mediaType.equals(MediaType.ALL) || mediaType.equals(MEDIA_TYPE_APPLICATION)) {
            selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;
            break;
        }
    }
    if (selectedMediaType != null) {
        selectedMediaType = selectedMediaType.removeQualityValue();
        for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
            if (messageConverter instanceof GenericHttpMessageConverter) {
                if (((GenericHttpMessageConverter<T>) messageConverter).canWrite(returnValueType, returnValueClreplaced, selectedMediaType)) {
                    returnValue = (T) getAdvice().beforeBodyWrite(returnValue, returnType, selectedMediaType, (Clreplaced<? extends HttpMessageConverter<?>>) messageConverter.getClreplaced(), inputMessage, outputMessage);
                    if (returnValue != null) {
                        addContentDispositionHeader(inputMessage, outputMessage);
                        ((GenericHttpMessageConverter<T>) messageConverter).write(returnValue, returnValueType, selectedMediaType, outputMessage);
                        if (logger.isDebugEnabled()) {
                            logger.debug("Written [" + returnValue + "] as \"" + selectedMediaType + "\" using [" + messageConverter + "]");
                        }
                    }
                    return;
                }
            } else if (messageConverter.canWrite(returnValueClreplaced, selectedMediaType)) {
                returnValue = (T) getAdvice().beforeBodyWrite(returnValue, returnType, selectedMediaType, (Clreplaced<? extends HttpMessageConverter<?>>) messageConverter.getClreplaced(), inputMessage, outputMessage);
                if (returnValue != null) {
                    addContentDispositionHeader(inputMessage, outputMessage);
                    ((HttpMessageConverter<T>) messageConverter).write(returnValue, selectedMediaType, outputMessage);
                    if (logger.isDebugEnabled()) {
                        logger.debug("Written [" + returnValue + "] as \"" + selectedMediaType + "\" using [" + messageConverter + "]");
                    }
                }
                return;
            }
        }
    }
    if (returnValue != null) {
        throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);
    }
}

@SuppressWarnings("deprecation")
@Override
protected void writeInternal(Message message, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
    MediaType contentType = outputMessage.getHeaders().getContentType();
    if (contentType == null) {
        contentType = getDefaultContentType(message);
        replacedert.state(contentType != null, "No content type");
    }
    Charset charset = contentType.getCharset();
    if (charset == null) {
        charset = DEFAULT_CHARSET;
    }
    if (PROTOBUF.isCompatibleWith(contentType)) {
        setProtoHeader(outputMessage, message);
        CodedOutputStream codedOutputStream = CodedOutputStream.newInstance(outputMessage.getBody());
        message.writeTo(codedOutputStream);
        codedOutputStream.flush();
    } else if (TEXT_PLAIN.isCompatibleWith(contentType)) {
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputMessage.getBody(), charset);
        // deprecated on Protobuf 3.9
        TextFormat.print(message, outputStreamWriter);
        outputStreamWriter.flush();
        outputMessage.getBody().flush();
    } else if (this.protobufFormatSupport != null) {
        this.protobufFormatSupport.print(message, outputMessage.getBody(), contentType, charset);
        outputMessage.getBody().flush();
    }
}

@Override
protected void writeInternal(Message message, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
    MediaType contentType = outputMessage.getHeaders().getContentType();
    Charset charset = getCharset(contentType);
    if (MediaType.TEXT_HTML.isCompatibleWith(contentType)) {
        final OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputMessage.getBody(), charset);
        HtmlFormat.print(message, outputStreamWriter);
        outputStreamWriter.flush();
    } else if (MediaType.APPLICATION_JSON.isCompatibleWith(contentType)) {
        final OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputMessage.getBody(), charset);
        JsonFormat.print(message, outputStreamWriter);
        outputStreamWriter.flush();
    } else if (MediaType.TEXT_PLAIN.isCompatibleWith(contentType)) {
        final OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputMessage.getBody(), charset);
        TextFormat.print(message, outputStreamWriter);
        outputStreamWriter.flush();
    } else if (MediaType.APPLICATION_XML.isCompatibleWith(contentType)) {
        final OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputMessage.getBody(), charset);
        XmlFormat.print(message, outputStreamWriter);
        outputStreamWriter.flush();
    } else if (PROTOBUF.isCompatibleWith(contentType)) {
        setProtoHeader(outputMessage, message);
        FileCopyUtils.copy(message.toByteArray(), outputMessage.getBody());
    }
}

/**
 * Writes the given return type to the given output message.
 * @param value the value to write to the output message
 * @param returnType the type of the value
 * @param inputMessage the input messages. Used to inspect the {@code Accept} header.
 * @param outputMessage the output message to write to
 * @throws IOException thrown in case of I/O errors
 * @throws HttpMediaTypeNotAcceptableException thrown when the conditions indicated
 * by the {@code Accept} header on the request cannot be met by the message converters
 */
@SuppressWarnings({ "rawtypes", "unchecked" })
protected <T> void writeWithMessageConverters(@Nullable T value, MethodParameter returnType, ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage) throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
    Object body;
    Clreplaced<?> valueType;
    Type targetType;
    if (value instanceof CharSequence) {
        body = value.toString();
        valueType = String.clreplaced;
        targetType = String.clreplaced;
    } else {
        body = value;
        valueType = getReturnValueType(body, returnType);
        targetType = GenericTypeResolver.resolveType(getGenericType(returnType), returnType.getContainingClreplaced());
    }
    if (isResourceType(value, returnType)) {
        outputMessage.getHeaders().set(HttpHeaders.ACCEPT_RANGES, "bytes");
        if (value != null && inputMessage.getHeaders().getFirst(HttpHeaders.RANGE) != null && outputMessage.getServletResponse().getStatus() == 200) {
            Resource resource = (Resource) value;
            try {
                List<HttpRange> httpRanges = inputMessage.getHeaders().getRange();
                outputMessage.getServletResponse().setStatus(HttpStatus.PARTIAL_CONTENT.value());
                body = HttpRange.toResourceRegions(httpRanges, resource);
                valueType = body.getClreplaced();
                targetType = RESOURCE_REGION_LIST_TYPE;
            } catch (IllegalArgumentException ex) {
                outputMessage.getHeaders().set(HttpHeaders.CONTENT_RANGE, "bytes */" + resource.contentLength());
                outputMessage.getServletResponse().setStatus(HttpStatus.REQUESTED_RANGE_NOT_SATISFIABLE.value());
            }
        }
    }
    MediaType selectedMediaType = null;
    MediaType contentType = outputMessage.getHeaders().getContentType();
    if (contentType != null && contentType.isConcrete()) {
        if (logger.isDebugEnabled()) {
            logger.debug("Found 'Content-Type:" + contentType + "' in response");
        }
        selectedMediaType = contentType;
    } else {
        HttpServletRequest request = inputMessage.getServletRequest();
        List<MediaType> acceptableTypes = getAcceptableMediaTypes(request);
        List<MediaType> producibleTypes = getProducibleMediaTypes(request, valueType, targetType);
        if (body != null && producibleTypes.isEmpty()) {
            throw new HttpMessageNotWritableException("No converter found for return value of type: " + valueType);
        }
        List<MediaType> mediaTypesToUse = new ArrayList<>();
        for (MediaType requestedType : acceptableTypes) {
            for (MediaType producibleType : producibleTypes) {
                if (requestedType.isCompatibleWith(producibleType)) {
                    mediaTypesToUse.add(getMostSpecificMediaType(requestedType, producibleType));
                }
            }
        }
        if (mediaTypesToUse.isEmpty()) {
            if (body != null) {
                throw new HttpMediaTypeNotAcceptableException(producibleTypes);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("No match for " + acceptableTypes + ", supported: " + producibleTypes);
            }
            return;
        }
        MediaType.sortBySpecificityAndQuality(mediaTypesToUse);
        for (MediaType mediaType : mediaTypesToUse) {
            if (mediaType.isConcrete()) {
                selectedMediaType = mediaType;
                break;
            } else if (mediaType.isPresentIn(ALL_APPLICATION_MEDIA_TYPES)) {
                selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;
                break;
            }
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Using '" + selectedMediaType + "', given " + acceptableTypes + " and supported " + producibleTypes);
        }
    }
    if (selectedMediaType != null) {
        selectedMediaType = selectedMediaType.removeQualityValue();
        for (HttpMessageConverter<?> converter : this.messageConverters) {
            GenericHttpMessageConverter genericConverter = (converter instanceof GenericHttpMessageConverter ? (GenericHttpMessageConverter<?>) converter : null);
            if (genericConverter != null ? ((GenericHttpMessageConverter) converter).canWrite(targetType, valueType, selectedMediaType) : converter.canWrite(valueType, selectedMediaType)) {
                body = getAdvice().beforeBodyWrite(body, returnType, selectedMediaType, (Clreplaced<? extends HttpMessageConverter<?>>) converter.getClreplaced(), inputMessage, outputMessage);
                if (body != null) {
                    Object theBody = body;
                    LogFormatUtils.traceDebug(logger, traceOn -> "Writing [" + LogFormatUtils.formatValue(theBody, !traceOn) + "]");
                    addContentDispositionHeader(inputMessage, outputMessage);
                    if (genericConverter != null) {
                        genericConverter.write(body, targetType, selectedMediaType, outputMessage);
                    } else {
                        ((HttpMessageConverter) converter).write(body, selectedMediaType, outputMessage);
                    }
                } else {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Nothing to write: null body");
                    }
                }
                return;
            }
        }
    }
    if (body != null) {
        throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);
    }
}

/**
 * Writes the given return type to the given output message.
 * @param value the value to write to the output message
 * @param returnType the type of the value
 * @param inputMessage the input messages. Used to inspect the {@code Accept} header.
 * @param outputMessage the output message to write to
 * @throws IOException thrown in case of I/O errors
 * @throws HttpMediaTypeNotAcceptableException thrown when the conditions indicated
 * by the {@code Accept} header on the request cannot be met by the message converters
 * @throws HttpMessageNotWritableException thrown if a given message cannot
 * be written by a converter, or if the content-type chosen by the server
 * has no compatible converter.
 */
@SuppressWarnings({ "rawtypes", "unchecked" })
protected <T> void writeWithMessageConverters(@Nullable T value, MethodParameter returnType, ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage) throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
    Object body;
    Clreplaced<?> valueType;
    Type targetType;
    if (value instanceof CharSequence) {
        body = value.toString();
        valueType = String.clreplaced;
        targetType = String.clreplaced;
    } else {
        body = value;
        valueType = getReturnValueType(body, returnType);
        targetType = GenericTypeResolver.resolveType(getGenericType(returnType), returnType.getContainingClreplaced());
    }
    if (isResourceType(value, returnType)) {
        outputMessage.getHeaders().set(HttpHeaders.ACCEPT_RANGES, "bytes");
        if (value != null && inputMessage.getHeaders().getFirst(HttpHeaders.RANGE) != null && outputMessage.getServletResponse().getStatus() == 200) {
            Resource resource = (Resource) value;
            try {
                List<HttpRange> httpRanges = inputMessage.getHeaders().getRange();
                outputMessage.getServletResponse().setStatus(HttpStatus.PARTIAL_CONTENT.value());
                body = HttpRange.toResourceRegions(httpRanges, resource);
                valueType = body.getClreplaced();
                targetType = RESOURCE_REGION_LIST_TYPE;
            } catch (IllegalArgumentException ex) {
                outputMessage.getHeaders().set(HttpHeaders.CONTENT_RANGE, "bytes */" + resource.contentLength());
                outputMessage.getServletResponse().setStatus(HttpStatus.REQUESTED_RANGE_NOT_SATISFIABLE.value());
            }
        }
    }
    MediaType selectedMediaType = null;
    MediaType contentType = outputMessage.getHeaders().getContentType();
    boolean isContentTypePreset = contentType != null && contentType.isConcrete();
    if (isContentTypePreset) {
        if (logger.isDebugEnabled()) {
            logger.debug("Found 'Content-Type:" + contentType + "' in response");
        }
        selectedMediaType = contentType;
    } else {
        HttpServletRequest request = inputMessage.getServletRequest();
        List<MediaType> acceptableTypes = getAcceptableMediaTypes(request);
        List<MediaType> producibleTypes = getProducibleMediaTypes(request, valueType, targetType);
        if (body != null && producibleTypes.isEmpty()) {
            throw new HttpMessageNotWritableException("No converter found for return value of type: " + valueType);
        }
        List<MediaType> mediaTypesToUse = new ArrayList<>();
        for (MediaType requestedType : acceptableTypes) {
            for (MediaType producibleType : producibleTypes) {
                if (requestedType.isCompatibleWith(producibleType)) {
                    mediaTypesToUse.add(getMostSpecificMediaType(requestedType, producibleType));
                }
            }
        }
        if (mediaTypesToUse.isEmpty()) {
            if (body != null) {
                throw new HttpMediaTypeNotAcceptableException(producibleTypes);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("No match for " + acceptableTypes + ", supported: " + producibleTypes);
            }
            return;
        }
        MediaType.sortBySpecificityAndQuality(mediaTypesToUse);
        for (MediaType mediaType : mediaTypesToUse) {
            if (mediaType.isConcrete()) {
                selectedMediaType = mediaType;
                break;
            } else if (mediaType.isPresentIn(ALL_APPLICATION_MEDIA_TYPES)) {
                selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;
                break;
            }
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Using '" + selectedMediaType + "', given " + acceptableTypes + " and supported " + producibleTypes);
        }
    }
    if (selectedMediaType != null) {
        selectedMediaType = selectedMediaType.removeQualityValue();
        for (HttpMessageConverter<?> converter : this.messageConverters) {
            GenericHttpMessageConverter genericConverter = (converter instanceof GenericHttpMessageConverter ? (GenericHttpMessageConverter<?>) converter : null);
            if (genericConverter != null ? ((GenericHttpMessageConverter) converter).canWrite(targetType, valueType, selectedMediaType) : converter.canWrite(valueType, selectedMediaType)) {
                body = getAdvice().beforeBodyWrite(body, returnType, selectedMediaType, (Clreplaced<? extends HttpMessageConverter<?>>) converter.getClreplaced(), inputMessage, outputMessage);
                if (body != null) {
                    Object theBody = body;
                    LogFormatUtils.traceDebug(logger, traceOn -> "Writing [" + LogFormatUtils.formatValue(theBody, !traceOn) + "]");
                    addContentDispositionHeader(inputMessage, outputMessage);
                    if (genericConverter != null) {
                        genericConverter.write(body, targetType, selectedMediaType, outputMessage);
                    } else {
                        ((HttpMessageConverter) converter).write(body, selectedMediaType, outputMessage);
                    }
                } else {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Nothing to write: null body");
                    }
                }
                return;
            }
        }
    }
    if (body != null) {
        Set<MediaType> producibleMediaTypes = (Set<MediaType>) inputMessage.getServletRequest().getAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);
        if (isContentTypePreset || !CollectionUtils.isEmpty(producibleMediaTypes)) {
            throw new HttpMessageNotWritableException("No converter for [" + valueType + "] with preset Content-Type '" + contentType + "'");
        }
        throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);
    }
}

/**
 * Read the body from a method argument with {@link HttpMessageReader}.
 * @param bodyParam represents the element type for the body
 * @param actualParam the actual method argument type; possibly different
 * from {@code bodyParam}, e.g. for an {@code HttpEnreplacedy} argument
 * @param isBodyRequired true if the body is required
 * @param bindingContext the binding context to use
 * @param exchange the current exchange
 * @return a Mono with the value to use for the method argument
 * @since 5.0.2
 */
protected Mono<Object> readBody(MethodParameter bodyParam, @Nullable MethodParameter actualParam, boolean isBodyRequired, BindingContext bindingContext, ServerWebExchange exchange) {
    ResolvableType bodyType = ResolvableType.forMethodParameter(bodyParam);
    ResolvableType actualType = (actualParam != null ? ResolvableType.forMethodParameter(actualParam) : bodyType);
    Clreplaced<?> resolvedType = bodyType.resolve();
    ReactiveAdapter adapter = (resolvedType != null ? getAdapterRegistry().getAdapter(resolvedType) : null);
    ResolvableType elementType = (adapter != null ? bodyType.getGeneric() : bodyType);
    isBodyRequired = isBodyRequired || (adapter != null && !adapter.supportsEmpty());
    ServerHttpRequest request = exchange.getRequest();
    ServerHttpResponse response = exchange.getResponse();
    MediaType contentType = request.getHeaders().getContentType();
    MediaType mediaType = (contentType != null ? contentType : MediaType.APPLICATION_OCTET_STREAM);
    Object[] hints = extractValidationHints(bodyParam);
    if (mediaType.isCompatibleWith(MediaType.APPLICATION_FORM_URLENCODED)) {
        return Mono.error(new IllegalStateException("In a WebFlux application, form data is accessed via ServerWebExchange.getFormData()."));
    }
    if (logger.isDebugEnabled()) {
        logger.debug(exchange.getLogPrefix() + (contentType != null ? "Content-Type:" + contentType : "No Content-Type, using " + MediaType.APPLICATION_OCTET_STREAM));
    }
    for (HttpMessageReader<?> reader : getMessageReaders()) {
        if (reader.canRead(elementType, mediaType)) {
            Map<String, Object> readHints = Hints.from(Hints.LOG_PREFIX_HINT, exchange.getLogPrefix());
            if (adapter != null && adapter.isMultiValue()) {
                if (logger.isDebugEnabled()) {
                    logger.debug(exchange.getLogPrefix() + "0..N [" + elementType + "]");
                }
                Flux<?> flux = reader.read(actualType, elementType, request, response, readHints);
                flux = flux.onErrorResume(ex -> Flux.error(handleReadError(bodyParam, ex)));
                if (isBodyRequired) {
                    flux = flux.switchIfEmpty(Flux.error(() -> handleMissingBody(bodyParam)));
                }
                if (hints != null) {
                    flux = flux.doOnNext(target -> validate(target, hints, bodyParam, bindingContext, exchange));
                }
                return Mono.just(adapter.fromPublisher(flux));
            } else {
                // Single-value (with or without reactive type wrapper)
                if (logger.isDebugEnabled()) {
                    logger.debug(exchange.getLogPrefix() + "0..1 [" + elementType + "]");
                }
                Mono<?> mono = reader.readMono(actualType, elementType, request, response, readHints);
                mono = mono.onErrorResume(ex -> Mono.error(handleReadError(bodyParam, ex)));
                if (isBodyRequired) {
                    mono = mono.switchIfEmpty(Mono.error(() -> handleMissingBody(bodyParam)));
                }
                if (hints != null) {
                    mono = mono.doOnNext(target -> validate(target, hints, bodyParam, bindingContext, exchange));
                }
                return (adapter != null ? Mono.just(adapter.fromPublisher(mono)) : Mono.from(mono));
            }
        }
    }
    // No compatible reader but body may be empty..
    HttpMethod method = request.getMethod();
    if (contentType == null && method != null && SUPPORTED_METHODS.contains(method)) {
        Flux<DataBuffer> body = request.getBody().doOnNext(buffer -> {
            DataBufferUtils.release(buffer);
            // Body not empty, back to 415..
            throw new UnsupportedMediaTypeStatusException(mediaType, this.supportedMediaTypes, elementType);
        });
        if (isBodyRequired) {
            body = body.switchIfEmpty(Mono.error(() -> handleMissingBody(bodyParam)));
        }
        return (adapter != null ? Mono.just(adapter.fromPublisher(body)) : Mono.from(body));
    }
    return Mono.error(new UnsupportedMediaTypeStatusException(mediaType, this.supportedMediaTypes, elementType));
}