org.springframework.util.MimeTypeUtils.TEXT_PLAIN

private void replacedertStringEncoder(Encoder<?> encoder, boolean textOnly) {
    replacedertEquals(CharSequenceEncoder.clreplaced, encoder.getClreplaced());
    replacedertTrue(encoder.canEncode(forClreplaced(String.clreplaced), MimeTypeUtils.TEXT_PLAIN));
    replacedertEquals(!textOnly, encoder.canEncode(forClreplaced(String.clreplaced), MediaType.TEXT_EVENT_STREAM));
}

// SPR-17220
@Test
public void emptyBodyWritten() {
    HttpMessageWriter<String> writer = getWriter(MimeTypeUtils.TEXT_PLAIN);
    writer.write(Mono.empty(), forClreplaced(String.clreplaced), TEXT_PLAIN, this.response, NO_HINTS).block();
    StepVerifier.create(this.response.getBody()).expectComplete();
    replacedertEquals(0, this.response.getHeaders().getContentLength());
}

@Test
public void getShortLogMessagePayload() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setContentType(MimeTypeUtils.TEXT_PLAIN);
    String expected = "headers={contentType=text/plain} payload=p";
    replacedertEquals(expected, accessor.getShortLogMessage("p"));
    replacedertEquals(expected, accessor.getShortLogMessage("p".getBytes(StandardCharsets.UTF_8)));
    replacedertEquals(expected, accessor.getShortLogMessage(new Object() {

        @Override
        public String toString() {
            return "p";
        }
    }));
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 80; i++) {
        sb.append("a");
    }
    final String payload = sb.toString() + " > 80";
    String actual = accessor.getShortLogMessage(payload);
    replacedertEquals("headers={contentType=text/plain} payload=" + sb + "...(truncated)", actual);
    actual = accessor.getShortLogMessage(payload.getBytes(StandardCharsets.UTF_8));
    replacedertEquals("headers={contentType=text/plain} payload=" + sb + "...(truncated)", actual);
    actual = accessor.getShortLogMessage(new Object() {

        @Override
        public String toString() {
            return payload;
        }
    });
    replacedertThat(actual, startsWith("headers={contentType=text/plain} payload=" + getClreplaced().getName() + "$"));
}

@Test
public void getDetailedLogMessagePayload() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setContentType(MimeTypeUtils.TEXT_PLAIN);
    String expected = "headers={contentType=text/plain} payload=p";
    replacedertEquals(expected, accessor.getDetailedLogMessage("p"));
    replacedertEquals(expected, accessor.getDetailedLogMessage("p".getBytes(StandardCharsets.UTF_8)));
    replacedertEquals(expected, accessor.getDetailedLogMessage(new Object() {

        @Override
        public String toString() {
            return "p";
        }
    }));
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 80; i++) {
        sb.append("a");
    }
    final String payload = sb.toString() + " > 80";
    String actual = accessor.getDetailedLogMessage(payload);
    replacedertEquals("headers={contentType=text/plain} payload=" + sb + " > 80", actual);
    actual = accessor.getDetailedLogMessage(payload.getBytes(StandardCharsets.UTF_8));
    replacedertEquals("headers={contentType=text/plain} payload=" + sb + " > 80", actual);
    actual = accessor.getDetailedLogMessage(new Object() {

        @Override
        public String toString() {
            return payload;
        }
    });
    replacedertEquals("headers={contentType=text/plain} payload=" + sb + " > 80", actual);
}

@Override
@Test
public void canDecode() {
    replacedertTrue(this.decoder.canDecode(TYPE, MimeTypeUtils.TEXT_PLAIN));
    replacedertTrue(this.decoder.canDecode(TYPE, MimeTypeUtils.TEXT_HTML));
    replacedertTrue(this.decoder.canDecode(TYPE, MimeTypeUtils.APPLICATION_JSON));
    replacedertTrue(this.decoder.canDecode(TYPE, MimeTypeUtils.parseMimeType("text/plain;charset=utf-8")));
    replacedertFalse(this.decoder.canDecode(ResolvableType.forClreplaced(Integer.clreplaced), MimeTypeUtils.TEXT_PLAIN));
    replacedertFalse(this.decoder.canDecode(ResolvableType.forClreplaced(Object.clreplaced), MimeTypeUtils.APPLICATION_JSON));
}

private void replacedertStringEncoder(Encoder<?> encoder, boolean textOnly) {
    replacedertThat(encoder.getClreplaced()).isEqualTo(CharSequenceEncoder.clreplaced);
    replacedertThat(encoder.canEncode(forClreplaced(String.clreplaced), MimeTypeUtils.TEXT_PLAIN)).isTrue();
    Object expected = !textOnly;
    replacedertThat(encoder.canEncode(forClreplaced(String.clreplaced), MediaType.TEXT_EVENT_STREAM)).isEqualTo(expected);
}

// SPR-17220
@Test
void emptyBodyWritten() {
    configureEncoder(MimeTypeUtils.TEXT_PLAIN);
    HttpMessageWriter<String> writer = new EncoderHttpMessageWriter<>(this.encoder);
    writer.write(Mono.empty(), forClreplaced(String.clreplaced), TEXT_PLAIN, this.response, NO_HINTS).block();
    StepVerifier.create(this.response.getBody()).verifyComplete();
    replacedertThat(this.response.getHeaders().getContentLength()).isEqualTo(0);
}

@Test
public void getShortLogMessagePayload() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setContentType(MimeTypeUtils.TEXT_PLAIN);
    String expected = "headers={contentType=text/plain} payload=p";
    replacedertThat(accessor.getShortLogMessage("p")).isEqualTo(expected);
    replacedertThat(accessor.getShortLogMessage("p".getBytes(StandardCharsets.UTF_8))).isEqualTo(expected);
    replacedertThat(accessor.getShortLogMessage(new Object() {

        @Override
        public String toString() {
            return "p";
        }
    })).isEqualTo(expected);
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 80; i++) {
        sb.append("a");
    }
    final String payload = sb.toString() + " > 80";
    String actual = accessor.getShortLogMessage(payload);
    replacedertThat(actual).isEqualTo("headers={contentType=text/plain} payload=" + sb + "...(truncated)");
    actual = accessor.getShortLogMessage(payload.getBytes(StandardCharsets.UTF_8));
    replacedertThat(actual).isEqualTo("headers={contentType=text/plain} payload=" + sb + "...(truncated)");
    actual = accessor.getShortLogMessage(new Object() {

        @Override
        public String toString() {
            return payload;
        }
    });
    replacedertThat(actual).startsWith("headers={contentType=text/plain} payload=" + getClreplaced().getName() + "$");
}

@Test
public void getDetailedLogMessagePayload() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setContentType(MimeTypeUtils.TEXT_PLAIN);
    String expected = "headers={contentType=text/plain} payload=p";
    replacedertThat(accessor.getDetailedLogMessage("p")).isEqualTo(expected);
    replacedertThat(accessor.getDetailedLogMessage("p".getBytes(StandardCharsets.UTF_8))).isEqualTo(expected);
    replacedertThat(accessor.getDetailedLogMessage(new Object() {

        @Override
        public String toString() {
            return "p";
        }
    })).isEqualTo(expected);
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 80; i++) {
        sb.append("a");
    }
    final String payload = sb.toString() + " > 80";
    String actual = accessor.getDetailedLogMessage(payload);
    replacedertThat(actual).isEqualTo("headers={contentType=text/plain} payload=" + sb + " > 80");
    actual = accessor.getDetailedLogMessage(payload.getBytes(StandardCharsets.UTF_8));
    replacedertThat(actual).isEqualTo("headers={contentType=text/plain} payload=" + sb + " > 80");
    actual = accessor.getDetailedLogMessage(new Object() {

        @Override
        public String toString() {
            return payload;
        }
    });
    replacedertThat(actual).isEqualTo("headers={contentType=text/plain} payload=" + sb + " > 80");
}

@Test
public void compositeRequiredForMultipleEntries() {
    // Route, metadata
    MetadataEncoder encoder1 = new MetadataEncoder(MimeTypeUtils.TEXT_PLAIN, this.strategies);
    encoder1.route("toA");
    replacedertThatThrownBy(() -> encoder1.metadata("My metadata", MimeTypeUtils.TEXT_PLAIN)).hasMessage("Composite metadata required for multiple metadata entries.");
    // Metadata, route
    MetadataEncoder encoder2 = new MetadataEncoder(MimeTypeUtils.TEXT_PLAIN, this.strategies);
    encoder2.metadata("My metadata", MimeTypeUtils.TEXT_PLAIN);
    replacedertThatThrownBy(() -> encoder2.route("toA")).hasMessage("Composite metadata required for multiple metadata entries.");
    // Route and metadata
    MetadataEncoder encoder3 = new MetadataEncoder(MimeTypeUtils.TEXT_PLAIN, this.strategies);
    Map<Object, MimeType> metadata = Collections.singletonMap("My metadata", MimeTypeUtils.TEXT_PLAIN);
    replacedertThatThrownBy(() -> encoder3.metadataAndOrRoute(metadata, "toA", new Object[0])).hasMessage("Composite metadata required for multiple metadata entries.");
}

@Test
public void defaultDataMimeType() {
    RSocketRequester requester = RSocketRequester.builder().connect(this.transport).block();
    replacedertThat(requester.dataMimeType()).as("Default data MimeType, based on the first Decoder").isEqualTo(MimeTypeUtils.TEXT_PLAIN);
}

@Test
public void setupWithAsyncValues() {
    Mono<String> asyncMeta1 = Mono.delay(Duration.ofMillis(1)).map(aLong -> "Async Metadata 1");
    Mono<String> asyncMeta2 = Mono.delay(Duration.ofMillis(1)).map(aLong -> "Async Metadata 2");
    Mono<String> data = Mono.delay(Duration.ofMillis(1)).map(aLong -> "Async data");
    RSocketRequester.builder().dataMimeType(MimeTypeUtils.TEXT_PLAIN).setupRoute("toA").setupMetadata(asyncMeta1, new MimeType("text", "x.test.metadata1")).setupMetadata(asyncMeta2, new MimeType("text", "x.test.metadata2")).setupData(data).connect(this.transport).block();
    ConnectionSetupPayload payload = Mono.from(this.connection.sentFrames()).map(ConnectionSetupPayload::create).block();
    MimeType compositeMimeType = MimeTypeUtils.parseMimeType(WellKnownMimeType.MESSAGE_RSOCKET_COMPOSITE_METADATA.getString());
    DefaultMetadataExtractor extractor = new DefaultMetadataExtractor(StringDecoder.allMimeTypes());
    extractor.metadataToExtract(new MimeType("text", "x.test.metadata1"), String.clreplaced, "asyncMeta1");
    extractor.metadataToExtract(new MimeType("text", "x.test.metadata2"), String.clreplaced, "asyncMeta2");
    Map<String, Object> metadataValues = extractor.extract(payload, compositeMimeType);
    replacedertThat(metadataValues.get("asyncMeta1")).isEqualTo("Async Metadata 1");
    replacedertThat(metadataValues.get("asyncMeta2")).isEqualTo("Async Metadata 2");
    replacedertThat(payload.getDataUtf8()).isEqualTo("Async data");
}

@Test
public void setupRoute() {
    RSocketRequester.builder().dataMimeType(MimeTypeUtils.TEXT_PLAIN).metadataMimeType(MimeTypeUtils.TEXT_PLAIN).setupRoute("toA").setupData("My data").connect(this.transport).block();
    ConnectionSetupPayload setupPayload = Mono.from(this.connection.sentFrames()).map(ConnectionSetupPayload::create).block();
    replacedertThat(setupPayload.getMetadataUtf8()).isEqualTo("toA");
    replacedertThat(setupPayload.getDataUtf8()).isEqualTo("My data");
}

@Override
@Test
public void canDecode() {
    replacedertThat(this.decoder.canDecode(TYPE, MimeTypeUtils.TEXT_PLAIN)).isTrue();
    replacedertThat(this.decoder.canDecode(TYPE, MimeTypeUtils.TEXT_HTML)).isTrue();
    replacedertThat(this.decoder.canDecode(TYPE, MimeTypeUtils.APPLICATION_JSON)).isTrue();
    replacedertThat(this.decoder.canDecode(TYPE, MimeTypeUtils.parseMimeType("text/plain;charset=utf-8"))).isTrue();
    replacedertThat(this.decoder.canDecode(ResolvableType.forClreplaced(Integer.clreplaced), MimeTypeUtils.TEXT_PLAIN)).isFalse();
    replacedertThat(this.decoder.canDecode(ResolvableType.forClreplaced(Object.clreplaced), MimeTypeUtils.APPLICATION_JSON)).isFalse();
}

@Test
public void getShortLogMessagePayload() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setContentType(MimeTypeUtils.TEXT_PLAIN);
    replacedertEquals("headers={contentType=text/plain} payload=p", accessor.getShortLogMessage("p"));
    replacedertEquals("headers={contentType=text/plain} payload=p", accessor.getShortLogMessage("p".getBytes(UTF_8)));
    replacedertEquals("headers={contentType=text/plain} payload=p", accessor.getShortLogMessage(new Object() {

        @Override
        public String toString() {
            return "p";
        }
    }));
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 80; i++) {
        sb.append("a");
    }
    final String payload = sb.toString() + " > 80";
    String actual = accessor.getShortLogMessage(payload);
    replacedertEquals("headers={contentType=text/plain} payload=" + sb + "...(truncated)", actual);
    actual = accessor.getShortLogMessage(payload.getBytes(UTF_8));
    replacedertEquals("headers={contentType=text/plain} payload=" + sb + "...(truncated)", actual);
    actual = accessor.getShortLogMessage(new Object() {

        @Override
        public String toString() {
            return payload;
        }
    });
    replacedertThat(actual, startsWith("headers={contentType=text/plain} payload=" + getClreplaced().getName() + "$"));
}

@Test
public void getDetailedLogMessagePayload() {
    MessageHeaderAccessor accessor = new MessageHeaderAccessor();
    accessor.setContentType(MimeTypeUtils.TEXT_PLAIN);
    replacedertEquals("headers={contentType=text/plain} payload=p", accessor.getDetailedLogMessage("p"));
    replacedertEquals("headers={contentType=text/plain} payload=p", accessor.getDetailedLogMessage("p".getBytes(UTF_8)));
    replacedertEquals("headers={contentType=text/plain} payload=p", accessor.getDetailedLogMessage(new Object() {

        @Override
        public String toString() {
            return "p";
        }
    }));
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 80; i++) {
        sb.append("a");
    }
    final String payload = sb.toString() + " > 80";
    String actual = accessor.getDetailedLogMessage(payload);
    replacedertEquals("headers={contentType=text/plain} payload=" + sb + " > 80", actual);
    actual = accessor.getDetailedLogMessage(payload.getBytes(UTF_8));
    replacedertEquals("headers={contentType=text/plain} payload=" + sb + " > 80", actual);
    actual = accessor.getDetailedLogMessage(new Object() {

        @Override
        public String toString() {
            return payload;
        }
    });
    replacedertEquals("headers={contentType=text/plain} payload=" + sb + " > 80", actual);
}

@SuppressWarnings("unchecked")
private void replacedertStringDecoder(Decoder<?> decoder, boolean textOnly) {
    replacedertEquals(StringDecoder.clreplaced, decoder.getClreplaced());
    replacedertTrue(decoder.canDecode(forClreplaced(String.clreplaced), MimeTypeUtils.TEXT_PLAIN));
    replacedertEquals(!textOnly, decoder.canDecode(forClreplaced(String.clreplaced), MediaType.TEXT_EVENT_STREAM));
    Flux<String> flux = (Flux<String>) decoder.decode(Flux.just(new DefaultDataBufferFactory().wrap("line1\nline2".getBytes(StandardCharsets.UTF_8))), ResolvableType.forClreplaced(String.clreplaced), MimeTypeUtils.TEXT_PLAIN, Collections.emptyMap());
    replacedertEquals(Arrays.asList("line1", "line2"), flux.collectList().block(Duration.ZERO));
}

private void replacedertStringDecoder(Decoder<?> decoder, boolean textOnly) {
    replacedertEquals(StringDecoder.clreplaced, decoder.getClreplaced());
    replacedertTrue(decoder.canDecode(ResolvableType.forClreplaced(String.clreplaced), MimeTypeUtils.TEXT_PLAIN));
    replacedertEquals(!textOnly, decoder.canDecode(ResolvableType.forClreplaced(String.clreplaced), MediaType.TEXT_EVENT_STREAM));
}

private void replacedertStringEncoder(Encoder<?> encoder, boolean textOnly) {
    replacedertEquals(CharSequenceEncoder.clreplaced, encoder.getClreplaced());
    replacedertTrue(encoder.canEncode(ResolvableType.forClreplaced(String.clreplaced), MimeTypeUtils.TEXT_PLAIN));
    replacedertEquals(!textOnly, encoder.canEncode(ResolvableType.forClreplaced(String.clreplaced), MediaType.TEXT_EVENT_STREAM));
}

@SuppressWarnings("unchecked")
private void replacedertStringDecoder(Decoder<?> decoder, boolean textOnly) {
    replacedertEquals(StringDecoder.clreplaced, decoder.getClreplaced());
    replacedertTrue(decoder.canDecode(forClreplaced(String.clreplaced), MimeTypeUtils.TEXT_PLAIN));
    replacedertEquals(!textOnly, decoder.canDecode(forClreplaced(String.clreplaced), MediaType.TEXT_EVENT_STREAM));
    Flux<String> decoded = (Flux<String>) decoder.decode(Flux.just(new DefaultDataBufferFactory().wrap("line1\nline2".getBytes(StandardCharsets.UTF_8))), ResolvableType.forClreplaced(String.clreplaced), MimeTypeUtils.TEXT_PLAIN, Collections.emptyMap());
    replacedertEquals(Arrays.asList("line1", "line2"), decoded.collectList().block(Duration.ZERO));
}

@Test
public void setContentLengthForMonoBody() {
    DefaultDataBufferFactory factory = new DefaultDataBufferFactory();
    DataBuffer buffer = factory.wrap("body".getBytes(StandardCharsets.UTF_8));
    HttpMessageWriter<String> writer = getWriter(Flux.just(buffer), MimeTypeUtils.TEXT_PLAIN);
    writer.write(Mono.just("body"), forClreplaced(String.clreplaced), TEXT_PLAIN, this.response, NO_HINTS).block();
    replacedertEquals(4, this.response.getHeaders().getContentLength());
}

@Test
public void serializeMutableHeaders() throws Exception {
    Map<String, Object> headers = new HashMap<>();
    headers.put("foo", "bar");
    Message<String> message = new GenericMessage<>("test", headers);
    MessageHeaderAccessor mutableAccessor = MessageHeaderAccessor.getMutableAccessor(message);
    mutableAccessor.setContentType(MimeTypeUtils.TEXT_PLAIN);
    message = new GenericMessage<>(message.getPayload(), mutableAccessor.getMessageHeaders());
    Message<?> output = (Message<?>) SerializationTestUtils.serializeAndDeserialize(message);
    replacedertEquals("test", output.getPayload());
    replacedertEquals("bar", output.getHeaders().get("foo"));
    replacedertNotNull(output.getHeaders().get(MessageHeaders.CONTENT_TYPE));
}

@Test
public void handleMessageFrame() {
    this.session.afterConnected(this.connection);
    StompFrameHandler frameHandler = mock(StompFrameHandler.clreplaced);
    String destination = "/topic/foo";
    Subscription subscription = this.session.subscribe(destination, frameHandler);
    StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.MESSAGE);
    accessor.setDestination(destination);
    accessor.setSubscriptionId(subscription.getSubscriptionId());
    accessor.setContentType(MimeTypeUtils.TEXT_PLAIN);
    accessor.setMessageId("1");
    accessor.setLeaveMutable(true);
    String payload = "sample payload";
    StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
    given(frameHandler.getPayloadType(stompHeaders)).willReturn(String.clreplaced);
    this.session.handleMessage(MessageBuilder.createMessage(payload.getBytes(StandardCharsets.UTF_8), accessor.getMessageHeaders()));
    verify(frameHandler).getPayloadType(stompHeaders);
    verify(frameHandler).handleFrame(stompHeaders, payload);
    verifyNoMoreInteractions(frameHandler);
}

@Test
public void toMessage() {
    Map<String, Object> map = new HashMap<>();
    map.put(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN);
    MessageHeaders headers = new MessageHeaders(map);
    Message<?> message = this.converter.toMessage("ABC", headers);
    replacedertEquals("ABC", new String(((byte[]) message.getPayload())));
}

@Test
public void fromStringMessage() {
    Message<String> message = MessageBuilder.withPayload("ABC").setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build();
    replacedertEquals("ABC", this.converter.fromMessage(message, String.clreplaced));
}

@Test
public void fromMessageByteArray() {
    Message<byte[]> message = MessageBuilder.withPayload("ABC".getBytes()).setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build();
    replacedertEquals("ABC", this.converter.fromMessage(message, String.clreplaced));
}

@Test
public void fromByteArrayMessage() {
    Message<byte[]> message = MessageBuilder.withPayload("ABC".getBytes()).setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build();
    replacedertEquals("ABC", this.converter.fromMessage(message, String.clreplaced));
}

@Test
public void supportsMimeType() {
    Message<String> message = MessageBuilder.withPayload("ABC").setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build();
    replacedertEquals("success-from", this.converter.fromMessage(message, String.clreplaced));
}

@Test
public void toMessageWithHeaders() {
    Map<String, Object> map = new HashMap<>();
    map.put("foo", "bar");
    MessageHeaders headers = new MessageHeaders(map);
    Message<?> message = this.converter.toMessage("ABC", headers);
    replacedertNotNull(message.getHeaders().getId());
    replacedertNotNull(message.getHeaders().getTimestamp());
    replacedertEquals(MimeTypeUtils.TEXT_PLAIN, message.getHeaders().get(MessageHeaders.CONTENT_TYPE));
    replacedertEquals("bar", message.getHeaders().get("foo"));
}

@Test
public void toMessageContentTypeHeader() {
    Message<?> message = this.converter.toMessage("ABC", null);
    replacedertEquals(MimeTypeUtils.TEXT_PLAIN, message.getHeaders().get(MessageHeaders.CONTENT_TYPE));
}

@Test
public void toMessageWithMutableMessageHeaders() {
    SimpMessageHeaderAccessor accessor = SimpMessageHeaderAccessor.create(SimpMessageType.MESSAGE);
    accessor.setHeader("foo", "bar");
    accessor.setNativeHeader("fooNative", "barNative");
    accessor.setLeaveMutable(true);
    MessageHeaders headers = accessor.getMessageHeaders();
    Message<?> message = this.converter.toMessage("ABC", headers);
    replacedertSame(headers, message.getHeaders());
    replacedertNull(message.getHeaders().getId());
    replacedertNull(message.getHeaders().getTimestamp());
    replacedertEquals(MimeTypeUtils.TEXT_PLAIN, message.getHeaders().get(MessageHeaders.CONTENT_TYPE));
}

@Override
@Test
public void canDecode() {
    replacedertTrue(this.decoder.canDecode(forClreplaced(InputStreamResource.clreplaced), MimeTypeUtils.TEXT_PLAIN));
    replacedertTrue(this.decoder.canDecode(forClreplaced(ByteArrayResource.clreplaced), MimeTypeUtils.TEXT_PLAIN));
    replacedertTrue(this.decoder.canDecode(forClreplaced(Resource.clreplaced), MimeTypeUtils.TEXT_PLAIN));
    replacedertTrue(this.decoder.canDecode(forClreplaced(InputStreamResource.clreplaced), MimeTypeUtils.APPLICATION_JSON));
    replacedertFalse(this.decoder.canDecode(forClreplaced(Object.clreplaced), MimeTypeUtils.APPLICATION_JSON));
}

@Test
@Override
@SuppressWarnings("unchecked")
public void testAnonymousGroup() throws Exception {
    KinesisTestBinder binder = getBinder();
    ExtendedProducerProperties<KinesisProducerProperties> producerProperties = createProducerProperties();
    DirectChannel output = createBindableChannel("output", createProducerBindingProperties(producerProperties));
    Binding<MessageChannel> producerBinding = binder.bindProducer(String.format("defaultGroup%s0", getDestinationNameDelimiter()), output, producerProperties);
    ExtendedConsumerProperties<KinesisConsumerProperties> consumerProperties = createConsumerProperties();
    consumerProperties.setConcurrency(2);
    consumerProperties.setInstanceCount(3);
    consumerProperties.setInstanceIndex(0);
    QueueChannel input1 = new QueueChannel();
    Binding<MessageChannel> binding1 = binder.bindConsumer(String.format("defaultGroup%s0", getDestinationNameDelimiter()), null, input1, consumerProperties);
    consumerProperties.setInstanceIndex(1);
    QueueChannel input2 = new QueueChannel();
    Binding<MessageChannel> binding2 = binder.bindConsumer(String.format("defaultGroup%s0", getDestinationNameDelimiter()), null, input2, consumerProperties);
    String testPayload1 = "foo-" + UUID.randomUUID().toString();
    output.send(MessageBuilder.withPayload(testPayload1).setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build());
    Message<byte[]> receivedMessage1 = (Message<byte[]>) receive(input1);
    replacedertThat(receivedMessage1).isNotNull();
    replacedertThat(new String(receivedMessage1.getPayload())).isEqualTo(testPayload1);
    Message<byte[]> receivedMessage2 = (Message<byte[]>) receive(input2);
    replacedertThat(receivedMessage2).isNotNull();
    replacedertThat(new String(receivedMessage2.getPayload())).isEqualTo(testPayload1);
    binding2.unbind();
    String testPayload2 = "foo-" + UUID.randomUUID().toString();
    output.send(MessageBuilder.withPayload(testPayload2).setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build());
    binding2 = binder.bindConsumer(String.format("defaultGroup%s0", getDestinationNameDelimiter()), null, input2, consumerProperties);
    String testPayload3 = "foo-" + UUID.randomUUID().toString();
    output.send(MessageBuilder.withPayload(testPayload3).setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build());
    receivedMessage1 = (Message<byte[]>) receive(input1);
    replacedertThat(receivedMessage1).isNotNull();
    replacedertThat(new String(receivedMessage1.getPayload())).isEqualTo(testPayload2);
    receivedMessage1 = (Message<byte[]>) receive(input1);
    replacedertThat(receivedMessage1).isNotNull();
    replacedertThat(new String(receivedMessage1.getPayload())).isNotNull();
    receivedMessage2 = (Message<byte[]>) receive(input2);
    replacedertThat(receivedMessage2).isNotNull();
    replacedertThat(new String(receivedMessage2.getPayload())).isEqualTo(testPayload1);
    receivedMessage2 = (Message<byte[]>) receive(input2);
    replacedertThat(receivedMessage2).isNotNull();
    replacedertThat(new String(receivedMessage2.getPayload())).isEqualTo(testPayload2);
    receivedMessage2 = (Message<byte[]>) receive(input2);
    replacedertThat(receivedMessage2).isNotNull();
    replacedertThat(new String(receivedMessage2.getPayload())).isEqualTo(testPayload3);
    producerBinding.unbind();
    binding1.unbind();
    binding2.unbind();
}

@SuppressWarnings("unchecked")
private void replacedertStringDecoder(Decoder<?> decoder, boolean textOnly) {
    replacedertThat(decoder.getClreplaced()).isEqualTo(StringDecoder.clreplaced);
    replacedertThat(decoder.canDecode(forClreplaced(String.clreplaced), MimeTypeUtils.TEXT_PLAIN)).isTrue();
    Object expected = !textOnly;
    replacedertThat(decoder.canDecode(forClreplaced(String.clreplaced), MediaType.TEXT_EVENT_STREAM)).isEqualTo(expected);
    Flux<String> flux = (Flux<String>) decoder.decode(Flux.just(new DefaultDataBufferFactory().wrap("line1\nline2".getBytes(StandardCharsets.UTF_8))), ResolvableType.forClreplaced(String.clreplaced), MimeTypeUtils.TEXT_PLAIN, Collections.emptyMap());
    replacedertThat(flux.collectList().block(Duration.ZERO)).isEqualTo(Arrays.asList("line1", "line2"));
}

private void replacedertStringEncoder(Encoder<?> encoder, boolean textOnly) {
    replacedertThat(encoder.getClreplaced()).isEqualTo(CharSequenceEncoder.clreplaced);
    replacedertThat(encoder.canEncode(ResolvableType.forClreplaced(String.clreplaced), MimeTypeUtils.TEXT_PLAIN)).isTrue();
    Object expected = !textOnly;
    replacedertThat(encoder.canEncode(ResolvableType.forClreplaced(String.clreplaced), MediaType.TEXT_EVENT_STREAM)).isEqualTo(expected);
}

private void replacedertStringDecoder(Decoder<?> decoder, boolean textOnly) {
    replacedertThat(decoder.getClreplaced()).isEqualTo(StringDecoder.clreplaced);
    replacedertThat(decoder.canDecode(ResolvableType.forClreplaced(String.clreplaced), MimeTypeUtils.TEXT_PLAIN)).isTrue();
    Object expected = !textOnly;
    replacedertThat(decoder.canDecode(ResolvableType.forClreplaced(String.clreplaced), MediaType.TEXT_EVENT_STREAM)).isEqualTo(expected);
}

@SuppressWarnings("unchecked")
private void replacedertStringDecoder(Decoder<?> decoder, boolean textOnly) {
    replacedertThat(decoder.getClreplaced()).isEqualTo(StringDecoder.clreplaced);
    replacedertThat(decoder.canDecode(forClreplaced(String.clreplaced), MimeTypeUtils.TEXT_PLAIN)).isTrue();
    Object expected = !textOnly;
    replacedertThat(decoder.canDecode(forClreplaced(String.clreplaced), MediaType.TEXT_EVENT_STREAM)).isEqualTo(expected);
    Flux<String> decoded = (Flux<String>) decoder.decode(Flux.just(new DefaultDataBufferFactory().wrap("line1\nline2".getBytes(StandardCharsets.UTF_8))), ResolvableType.forClreplaced(String.clreplaced), MimeTypeUtils.TEXT_PLAIN, Collections.emptyMap());
    replacedertThat(decoded.collectList().block(Duration.ZERO)).isEqualTo(Arrays.asList("line1", "line2"));
}

@Test
void setContentLengthForMonoBody() {
    DefaultDataBufferFactory factory = new DefaultDataBufferFactory();
    DataBuffer buffer = factory.wrap("body".getBytes(StandardCharsets.UTF_8));
    configureEncoder(buffer, MimeTypeUtils.TEXT_PLAIN);
    HttpMessageWriter<String> writer = new EncoderHttpMessageWriter<>(this.encoder);
    writer.write(Mono.just("body"), forClreplaced(String.clreplaced), TEXT_PLAIN, this.response, NO_HINTS).block();
    replacedertThat(this.response.getHeaders().getContentLength()).isEqualTo(4);
}

@Test
public void serializeMutableHeaders() throws Exception {
    Map<String, Object> headers = new HashMap<>();
    headers.put("foo", "bar");
    Message<String> message = new GenericMessage<>("test", headers);
    MessageHeaderAccessor mutableAccessor = MessageHeaderAccessor.getMutableAccessor(message);
    mutableAccessor.setContentType(MimeTypeUtils.TEXT_PLAIN);
    message = new GenericMessage<>(message.getPayload(), mutableAccessor.getMessageHeaders());
    Message<?> output = (Message<?>) SerializationTestUtils.serializeAndDeserialize(message);
    replacedertThat(output.getPayload()).isEqualTo("test");
    replacedertThat(output.getHeaders().get("foo")).isEqualTo("bar");
    replacedertThat(output.getHeaders().get(MessageHeaders.CONTENT_TYPE)).isNotNull();
}

@Test
public void compositeMetadata() {
    Mono<String> asyncMeta1 = Mono.delay(Duration.ofMillis(1)).map(aLong -> "Async Metadata 1");
    Mono<String> asyncMeta2 = Mono.delay(Duration.ofMillis(1)).map(aLong -> "Async Metadata 2");
    DataBuffer buffer = new MetadataEncoder(COMPOSITE_METADATA, this.strategies).route("toA").metadata("My metadata", MimeTypeUtils.TEXT_PLAIN).metadata(asyncMeta1, new MimeType("text", "x.test.metadata1")).metadata(Unpooled.wrappedBuffer("Raw data".getBytes(UTF_8)), MimeTypeUtils.APPLICATION_OCTET_STREAM).metadata(asyncMeta2, new MimeType("text", "x.test.metadata2")).encode().block();
    CompositeMetadata entries = new CompositeMetadata(((NettyDataBuffer) buffer).getNativeBuffer(), false);
    Iterator<CompositeMetadata.Entry> iterator = entries.iterator();
    replacedertThat(iterator.hasNext()).isTrue();
    CompositeMetadata.Entry entry = iterator.next();
    replacedertThat(entry.getMimeType()).isEqualTo(WellKnownMimeType.MESSAGE_RSOCKET_ROUTING.getString());
    replacedertRoute("toA", entry.getContent());
    replacedertThat(iterator.hasNext()).isTrue();
    entry = iterator.next();
    replacedertThat(entry.getMimeType()).isEqualTo(MimeTypeUtils.TEXT_PLAIN_VALUE);
    replacedertThat(entry.getContent().toString(UTF_8)).isEqualTo("My metadata");
    replacedertThat(iterator.hasNext()).isTrue();
    entry = iterator.next();
    replacedertThat(entry.getMimeType()).isEqualTo("text/x.test.metadata1");
    replacedertThat(entry.getContent().toString(UTF_8)).isEqualTo("Async Metadata 1");
    replacedertThat(iterator.hasNext()).isTrue();
    entry = iterator.next();
    replacedertThat(entry.getMimeType()).isEqualTo(MimeTypeUtils.APPLICATION_OCTET_STREAM_VALUE);
    replacedertThat(entry.getContent().toString(UTF_8)).isEqualTo("Raw data");
    replacedertThat(iterator.hasNext()).isTrue();
    entry = iterator.next();
    replacedertThat(entry.getMimeType()).isEqualTo("text/x.test.metadata2");
    replacedertThat(entry.getContent().toString(UTF_8)).isEqualTo("Async Metadata 2");
    replacedertThat(iterator.hasNext()).isFalse();
}

@Test
public void toMessageWithHeaders() {
    Map<String, Object> map = new HashMap<>();
    map.put("foo", "bar");
    MessageHeaders headers = new MessageHeaders(map);
    Message<?> message = this.converter.toMessage("ABC", headers);
    replacedertThat(message.getHeaders().getId()).isNotNull();
    replacedertThat(message.getHeaders().getTimestamp()).isNotNull();
    replacedertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE)).isEqualTo(MimeTypeUtils.TEXT_PLAIN);
    replacedertThat(message.getHeaders().get("foo")).isEqualTo("bar");
}

@Test
public void supportsMimeType() {
    Message<String> message = MessageBuilder.withPayload("ABC").setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN).build();
    replacedertThat(this.converter.fromMessage(message, String.clreplaced)).isEqualTo("success-from");
}

@Test
public void toMessageWithMutableMessageHeaders() {
    SimpMessageHeaderAccessor accessor = SimpMessageHeaderAccessor.create(SimpMessageType.MESSAGE);
    accessor.setHeader("foo", "bar");
    accessor.setNativeHeader("fooNative", "barNative");
    accessor.setLeaveMutable(true);
    MessageHeaders headers = accessor.getMessageHeaders();
    Message<?> message = this.converter.toMessage("ABC", headers);
    replacedertThat(message.getHeaders()).isSameAs(headers);
    replacedertThat(message.getHeaders().getId()).isNull();
    replacedertThat(message.getHeaders().getTimestamp()).isNull();
    replacedertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE)).isEqualTo(MimeTypeUtils.TEXT_PLAIN);
}

@Test
public void toMessageContentTypeHeader() {
    Message<?> message = this.converter.toMessage("ABC", null);
    replacedertThat(message.getHeaders().get(MessageHeaders.CONTENT_TYPE)).isEqualTo(MimeTypeUtils.TEXT_PLAIN);
}

@Test
public void handleMessageFrame() {
    this.session.afterConnected(this.connection);
    StompFrameHandler frameHandler = mock(StompFrameHandler.clreplaced);
    String destination = "/topic/foo";
    Subscription subscription = this.session.subscribe(destination, frameHandler);
    StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.MESSAGE);
    accessor.setDestination(destination);
    accessor.setSubscriptionId(subscription.getSubscriptionId());
    accessor.setContentType(MimeTypeUtils.TEXT_PLAIN);
    accessor.setMessageId("1");
    accessor.setLeaveMutable(true);
    String payload = "sample payload";
    StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
    when(frameHandler.getPayloadType(stompHeaders)).thenReturn(String.clreplaced);
    this.session.handleMessage(MessageBuilder.createMessage(payload.getBytes(StandardCharsets.UTF_8), accessor.getMessageHeaders()));
    verify(frameHandler).getPayloadType(stompHeaders);
    verify(frameHandler).handleFrame(stompHeaders, payload);
    verifyNoMoreInteractions(frameHandler);
}

@Test
public void handleMessageFrame() throws Exception {
    this.session.afterConnected(this.connection);
    StompFrameHandler frameHandler = mock(StompFrameHandler.clreplaced);
    String destination = "/topic/foo";
    Subscription subscription = this.session.subscribe(destination, frameHandler);
    StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.MESSAGE);
    accessor.setDestination(destination);
    accessor.setSubscriptionId(subscription.getSubscriptionId());
    accessor.setContentType(MimeTypeUtils.TEXT_PLAIN);
    accessor.setMessageId("1");
    accessor.setLeaveMutable(true);
    String payload = "sample payload";
    StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
    when(frameHandler.getPayloadType(stompHeaders)).thenReturn(String.clreplaced);
    this.session.handleMessage(MessageBuilder.createMessage(payload.getBytes(UTF_8), accessor.getMessageHeaders()));
    verify(frameHandler).getPayloadType(stompHeaders);
    verify(frameHandler).handleFrame(stompHeaders, payload);
    verifyNoMoreInteractions(frameHandler);
}

@Test
public void toMessage() {
    Map<String, Object> map = new HashMap<String, Object>();
    map.put(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN);
    MessageHeaders headers = new MessageHeaders(map);
    Message<?> message = this.converter.toMessage("ABC", headers);
    replacedertEquals("ABC", new String(((byte[]) message.getPayload())));
}

@Test
public void toMessageWithHeaders() {
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("foo", "bar");
    MessageHeaders headers = new MessageHeaders(map);
    Message<?> message = this.converter.toMessage("ABC", headers);
    replacedertNotNull(message.getHeaders().getId());
    replacedertNotNull(message.getHeaders().getTimestamp());
    replacedertEquals(MimeTypeUtils.TEXT_PLAIN, message.getHeaders().get(MessageHeaders.CONTENT_TYPE));
    replacedertEquals("bar", message.getHeaders().get("foo"));
}

@Bean
public RSocketRequester rsocketRequester() {
    return RSocketRequester.builder().dataMimeType(MimeTypeUtils.TEXT_PLAIN).connectTcp(helloServiceHostname, helloServicePort).block();
}

@Override
protected Message<?> doConvert(Object payload, Map<String, Object> headers, MessagePostProcessor postProcessor) {
    Message<?> message = super.doConvert(payload, headers, postProcessor);
    MessageBuilder<?> builder = MessageBuilder.fromMessage(message);
    builder.setHeaderIfAbsent(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN);
    return builder.build();
}

See More Examples