Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Introduce HttpMessageContentConverter

Browse Source 
This commit introduces an abstraction that allows to convert HTTP
inputs to a data type based on a set of HttpMessageConverter.

Previously, the AssertJ integration was finding the first converter
that is able to convert JSON to a Map (and vice-versa) and used that
in its API. With the introduction of SmartHttpMessageConverter, exposing
a specific converter is fragile.

The added abstraction allows for converting other kind of input than
JSON if we need to do that in the future.

Closes gh-33148
This commit is contained in:
Stéphane Nicoll
2024-07-03 15:51:48 +02:00
parent 206d81ee08
commit 4bdb772d39
14 changed files with 506 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
spring-test/src/main/java/org/springframework/test/http/HttpMessageContentConverter.java Normal file
View File

@@ -0,0 +1,156 @@
/*
* Copyright 2002-2024 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.test.http;
import java.io.IOException;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.List;
import java.util.stream.StreamSupport;
import org.springframework.core.ResolvableType;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.GenericHttpMessageConverter;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.SmartHttpMessageConverter;
import org.springframework.mock.http.MockHttpInputMessage;
import org.springframework.mock.http.MockHttpOutputMessage;
import org.springframework.util.Assert;
import org.springframework.util.function.SingletonSupplier;
/**
* Convert HTTP message content for testing purposes.
*
* @author Stephane Nicoll
* @since 6.2
*/
public class HttpMessageContentConverter {
private static final MediaType JSON = MediaType.APPLICATION_JSON;
private final List<HttpMessageConverter<?>> messageConverters;
HttpMessageContentConverter(Iterable<HttpMessageConverter<?>> messageConverters) {
this.messageConverters = StreamSupport.stream(messageConverters.spliterator(), false).toList();
Assert.notEmpty(this.messageConverters, "At least one message converter needs to be specified");
}
/**
* Create an instance with an iterable of the candidates to use.
* @param candidates the candidates
*/
public static HttpMessageContentConverter of(Iterable<HttpMessageConverter<?>> candidates) {
return new HttpMessageContentConverter(candidates);
}
/**
* Create an instance with a vararg of the candidates to use.
* @param candidates the candidates
*/
public static HttpMessageContentConverter of(HttpMessageConverter<?>... candidates) {
return new HttpMessageContentConverter(Arrays.asList(candidates));
}
/**
* Convert the given {@link HttpInputMessage} whose content must match the
* given {@link MediaType} to the requested {@code targetType}.
* @param message an input message
* @param mediaType the media type of the input
* @param targetType the target type
* @param <T> the converted object type
* @return a value of the given {@code targetType}
*/
@SuppressWarnings("unchecked")
public <T> T convert(HttpInputMessage message, MediaType mediaType, ResolvableType targetType)
throws IOException, HttpMessageNotReadableException {
Class<?> contextClass = targetType.getRawClass();
SingletonSupplier<Type> javaType = SingletonSupplier.of(targetType::getType);
for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
if (messageConverter instanceof GenericHttpMessageConverter<?> genericMessageConverter) {
Type type = javaType.obtain();
if (genericMessageConverter.canRead(type, contextClass, mediaType)) {
return (T) genericMessageConverter.read(type, contextClass, message);
}
}
else if (messageConverter instanceof SmartHttpMessageConverter<?> smartMessageConverter) {
if (smartMessageConverter.canRead(targetType, mediaType)) {
return (T) smartMessageConverter.read(targetType, message, null);
}
}
else {
Class<?> targetClass = (contextClass != null ? contextClass : Object.class);
if (messageConverter.canRead(targetClass, mediaType)) {
HttpMessageConverter<T> simpleMessageConverter = (HttpMessageConverter<T>) messageConverter;
Class<? extends T> clazz = (Class<? extends T>) targetClass;
return simpleMessageConverter.read(clazz, message);
}
}
}
throw new IllegalStateException("No converter found to read [%s] to [%s]".formatted(mediaType, targetType));
}
/**
* Convert the given raw value to the given {@code targetType} by writing
* it first to JSON and reading it back.
* @param value the value to convert
* @param targetType the target type
* @param <T> the converted object type
* @return a value of the given {@code targetType}
*/
public <T> T convertViaJson(Object value, ResolvableType targetType) throws IOException {
MockHttpOutputMessage outputMessage = convertToJson(value, ResolvableType.forInstance(value));
return convert(fromHttpOutputMessage(outputMessage), JSON, targetType);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
private MockHttpOutputMessage convertToJson(Object value, ResolvableType valueType) throws IOException {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
Class<?> valueClass = value.getClass();
SingletonSupplier<Type> javaType = SingletonSupplier.of(valueType::getType);
for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
if (messageConverter instanceof GenericHttpMessageConverter genericMessageConverter) {
Type type = javaType.obtain();
if (genericMessageConverter.canWrite(type, valueClass, JSON)) {
genericMessageConverter.write(value, type, JSON, outputMessage);
return outputMessage;
}
}
else if (messageConverter instanceof SmartHttpMessageConverter smartMessageConverter) {
if (smartMessageConverter.canWrite(valueType, valueClass, JSON)) {
smartMessageConverter.write(value, valueType, JSON, outputMessage, null);
return outputMessage;
}
}
else if (messageConverter.canWrite(valueClass, JSON)) {
((HttpMessageConverter<Object>) messageConverter).write(value, JSON, outputMessage);
return outputMessage;
}
}
throw new IllegalStateException("No converter found to convert [%s] to JSON".formatted(valueType));
}
private static HttpInputMessage fromHttpOutputMessage(MockHttpOutputMessage message) {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(message.getBodyAsBytes());
inputMessage.getHeaders().addAll(message.getHeaders());
return inputMessage;
}
}

17
spring-test/src/main/java/org/springframework/test/json/AbstractJsonContentAssert.java
View File

@@ -35,6 +35,7 @@ import org.assertj.core.api.InstanceOfAssertFactories;
import org.assertj.core.error.BasicErrorMessageFactory;
import org.assertj.core.internal.Failures;
import org.springframework.core.ResolvableType;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.FileSystemResource;
@@ -43,9 +44,9 @@ import org.springframework.core.io.Resource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.GenericHttpMessageConverter;
import org.springframework.lang.Nullable;
import org.springframework.mock.http.MockHttpInputMessage;
import org.springframework.test.http.HttpMessageContentConverter;
import org.springframework.util.Assert;
/**
@@ -77,7 +78,7 @@ public abstract class AbstractJsonContentAssert<SELF extends AbstractJsonContent
@Nullable
private final GenericHttpMessageConverter<Object> jsonMessageConverter;
private final HttpMessageContentConverter contentConverter;
@Nullable
private Class<?> resourceLoadClass;
@@ -94,7 +95,7 @@ public abstract class AbstractJsonContentAssert<SELF extends AbstractJsonContent
*/
protected AbstractJsonContentAssert(@Nullable JsonContent actual, Class<?> selfType) {
super(actual, selfType);
this.jsonMessageConverter = (actual != null ? actual.getJsonMessageConverter() : null);
this.contentConverter = (actual != null ? actual.getContentConverter() : null);
this.jsonLoader = new JsonLoader(null, null);
as("JSON content");
}
@@ -131,15 +132,15 @@ public abstract class AbstractJsonContentAssert<SELF extends AbstractJsonContent
return assertFactory.createAssert(this::convertToTargetType);
}
@SuppressWarnings("unchecked")
private <T> T convertToTargetType(Type targetType) {
String json = this.actual.getJson();
if (this.jsonMessageConverter == null) {
if (this.contentConverter == null) {
throw new IllegalStateException(
"No JSON message converter available to convert %s".formatted(json));
}
try {
return (T) this.jsonMessageConverter.read(targetType, getClass(), fromJson(json));
return this.contentConverter.convert(fromJson(json), MediaType.APPLICATION_JSON,
ResolvableType.forType(targetType));
}
catch (Exception ex) {
throw failure(new ValueProcessingFailed(json,
@@ -165,7 +166,7 @@ public abstract class AbstractJsonContentAssert<SELF extends AbstractJsonContent
*/
public JsonPathValueAssert extractingPath(String path) {
Object value = new JsonPathValue(path).getValue();
return new JsonPathValueAssert(value, path, this.jsonMessageConverter);
return new JsonPathValueAssert(value, path, this.contentConverter);
}
/**
@@ -176,7 +177,7 @@ public abstract class AbstractJsonContentAssert<SELF extends AbstractJsonContent
*/
public SELF hasPathSatisfying(String path, Consumer<AssertProvider<JsonPathValueAssert>> valueRequirements) {
Object value = new JsonPathValue(path).assertHasPath();
JsonPathValueAssert valueAssert = new JsonPathValueAssert(value, path, this.jsonMessageConverter);
JsonPathValueAssert valueAssert = new JsonPathValueAssert(value, path, this.contentConverter);
valueRequirements.accept(() -> valueAssert);
return this.myself;
}

27
spring-test/src/main/java/org/springframework/test/json/AbstractJsonValueAssert.java
View File

@@ -33,12 +33,9 @@ import org.assertj.core.error.BasicErrorMessageFactory;
import org.assertj.core.internal.Failures;
import org.springframework.core.ResolvableType;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.GenericHttpMessageConverter;
import org.springframework.lang.Nullable;
import org.springframework.mock.http.MockHttpInputMessage;
import org.springframework.mock.http.MockHttpOutputMessage;
import org.springframework.test.http.HttpMessageContentConverter;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;
@@ -68,14 +65,14 @@ public abstract class AbstractJsonValueAssert<SELF extends AbstractJsonValueAsse
private final Failures failures = Failures.instance();
@Nullable
private final GenericHttpMessageConverter<Object> httpMessageConverter;
private final HttpMessageContentConverter contentConverter;
protected AbstractJsonValueAssert(@Nullable Object actual, Class<?> selfType,
@Nullable GenericHttpMessageConverter<Object> httpMessageConverter) {
@Nullable HttpMessageContentConverter contentConverter) {
super(actual, selfType);
this.httpMessageConverter = httpMessageConverter;
this.contentConverter = contentConverter;
}
@@ -199,19 +196,13 @@ public abstract class AbstractJsonValueAssert<SELF extends AbstractJsonValueAsse
return this.myself;
}
@SuppressWarnings("unchecked")
private <T> T convertToTargetType(Type targetType) {
if (this.httpMessageConverter == null) {
if (this.contentConverter == null) {
throw new IllegalStateException(
"No JSON message converter available to convert %s".formatted(actualToString()));
}
try {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
this.httpMessageConverter.write(this.actual, ResolvableType.forInstance(this.actual).getType(),
MediaType.APPLICATION_JSON, outputMessage);
return (T) this.httpMessageConverter.read(targetType, getClass(),
fromHttpOutputMessage(outputMessage));
return this.contentConverter.convertViaJson(this.actual, ResolvableType.forType(targetType));
}
catch (Exception ex) {
throw valueProcessingFailed("To convert successfully to:%n %s%nBut it failed:%n %s%n"
@@ -219,12 +210,6 @@ public abstract class AbstractJsonValueAssert<SELF extends AbstractJsonValueAsse
}
}
private HttpInputMessage fromHttpOutputMessage(MockHttpOutputMessage message) {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(message.getBodyAsBytes());
inputMessage.getHeaders().addAll(message.getHeaders());
return inputMessage;
}
protected String getExpectedErrorMessagePrefix() {
return "Expected:";
}

18
spring-test/src/main/java/org/springframework/test/json/JsonContent.java
View File

@@ -18,8 +18,8 @@ package org.springframework.test.json;
import org.assertj.core.api.AssertProvider;
import org.springframework.http.converter.GenericHttpMessageConverter;
import org.springframework.lang.Nullable;
import org.springframework.test.http.HttpMessageContentConverter;
import org.springframework.util.Assert;
/**
@@ -35,22 +35,21 @@ public final class JsonContent implements AssertProvider<JsonContentAssert> {
private final String json;
@Nullable
private final GenericHttpMessageConverter<Object> jsonMessageConverter;
private final HttpMessageContentConverter contentConverter;
/**
* Create a new {@code JsonContent} instance with the message converter to
* use to deserialize content.
* @param json the actual JSON content
* @param jsonMessageConverter the message converter to use
* @param contentConverter the content converter to use
*/
public JsonContent(String json, @Nullable GenericHttpMessageConverter<Object> jsonMessageConverter) {
public JsonContent(String json, @Nullable HttpMessageContentConverter contentConverter) {
Assert.notNull(json, "JSON must not be null");
this.json = json;
this.jsonMessageConverter = jsonMessageConverter;
this.contentConverter = contentConverter;
}
/**
* Create a new {@code JsonContent} instance.
* @param json the actual JSON content
@@ -59,6 +58,7 @@ public final class JsonContent implements AssertProvider<JsonContentAssert> {
this(json, null);
}
/**
* Use AssertJ's {@link org.assertj.core.api.Assertions#assertThat assertThat}
* instead.
@@ -76,11 +76,11 @@ public final class JsonContent implements AssertProvider<JsonContentAssert> {
}
/**
* Return the message converter to use to deserialize content.
* Return the {@link HttpMessageContentConverter} to use to deserialize content.
*/
@Nullable
GenericHttpMessageConverter<Object> getJsonMessageConverter() {
return this.jsonMessageConverter;
HttpMessageContentConverter getContentConverter() {
return this.contentConverter;
}
@Override

6
spring-test/src/main/java/org/springframework/test/json/JsonPathValueAssert.java
View File

@@ -18,8 +18,8 @@ package org.springframework.test.json;
import com.jayway.jsonpath.JsonPath;
import org.springframework.http.converter.GenericHttpMessageConverter;
import org.springframework.lang.Nullable;
import org.springframework.test.http.HttpMessageContentConverter;
/**
* AssertJ {@linkplain org.assertj.core.api.Assert assertions} that can be applied
@@ -35,9 +35,9 @@ public class JsonPathValueAssert extends AbstractJsonValueAssert<JsonPathValueAs
JsonPathValueAssert(@Nullable Object actual, String expression,
@Nullable GenericHttpMessageConverter<Object> httpMessageConverter) {
@Nullable HttpMessageContentConverter contentConverter) {
super(actual, JsonPathValueAssert.class, httpMessageConverter);
super(actual, JsonPathValueAssert.class, contentConverter);
this.expression = expression;
}

10
spring-test/src/main/java/org/springframework/test/web/servlet/assertj/AbstractMockHttpServletResponseAssert.java
View File

@@ -23,9 +23,9 @@ import org.assertj.core.api.AbstractStringAssert;
import org.assertj.core.api.Assertions;
import org.assertj.core.api.ByteArrayAssert;
import org.springframework.http.converter.GenericHttpMessageConverter;
import org.springframework.lang.Nullable;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.http.HttpMessageContentConverter;
import org.springframework.test.json.AbstractJsonContentAssert;
import org.springframework.test.json.JsonContent;
import org.springframework.test.json.JsonContentAssert;
@@ -44,13 +44,13 @@ public abstract class AbstractMockHttpServletResponseAssert<SELF extends Abstrac
extends AbstractHttpServletResponseAssert<MockHttpServletResponse, SELF, ACTUAL> {
@Nullable
private final GenericHttpMessageConverter<Object> jsonMessageConverter;
private final HttpMessageContentConverter contentConverter;
protected AbstractMockHttpServletResponseAssert(
@Nullable GenericHttpMessageConverter<Object> jsonMessageConverter, ACTUAL actual, Class<?> selfType) {
@Nullable HttpMessageContentConverter contentConverter, ACTUAL actual, Class<?> selfType) {
super(actual, selfType);
this.jsonMessageConverter = jsonMessageConverter;
this.contentConverter = contentConverter;
}
@@ -93,7 +93,7 @@ public abstract class AbstractMockHttpServletResponseAssert<SELF extends Abstrac
* </code></pre>
*/
public AbstractJsonContentAssert<?> bodyJson() {
return new JsonContentAssert(new JsonContent(readBody(), this.jsonMessageConverter));
return new JsonContentAssert(new JsonContent(readBody(), this.contentConverter));
}
private String readBody() {

10
spring-test/src/main/java/org/springframework/test/web/servlet/assertj/DefaultMvcTestResult.java
View File

@@ -16,8 +16,8 @@
package org.springframework.test.web.servlet.assertj;
import org.springframework.http.converter.GenericHttpMessageConverter;
import org.springframework.lang.Nullable;
import org.springframework.test.http.HttpMessageContentConverter;
import org.springframework.test.web.servlet.MvcResult;
/**
@@ -35,15 +35,15 @@ final class DefaultMvcTestResult implements MvcTestResult {
private final Exception unresolvedException;
@Nullable
private final GenericHttpMessageConverter<Object> jsonMessageConverter;
private final HttpMessageContentConverter contentConverter;
DefaultMvcTestResult(@Nullable MvcResult mvcResult, @Nullable Exception unresolvedException,
@Nullable GenericHttpMessageConverter<Object> jsonMessageConverter) {
@Nullable HttpMessageContentConverter contentConverter) {
this.mvcResult = mvcResult;
this.unresolvedException = unresolvedException;
this.jsonMessageConverter = jsonMessageConverter;
this.contentConverter = contentConverter;
}
@@ -74,7 +74,7 @@ final class DefaultMvcTestResult implements MvcTestResult {
*/
@Override
public MvcTestResultAssert assertThat() {
return new MvcTestResultAssert(this, this.jsonMessageConverter);
return new MvcTestResultAssert(this, this.contentConverter);
}
}

36
spring-test/src/main/java/org/springframework/test/web/servlet/assertj/MockMvcTester.java
View File

@@ -20,20 +20,17 @@ import java.net.URI;
import java.time.Duration;
import java.util.Arrays;
import java.util.Collection;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.StreamSupport;
import jakarta.servlet.DispatcherType;
import org.assertj.core.api.AssertProvider;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.converter.GenericHttpMessageConverter;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.lang.Nullable;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockMultipartHttpServletRequest;
import org.springframework.test.http.HttpMessageContentConverter;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.RequestBuilder;
@@ -133,18 +130,16 @@ import org.springframework.web.context.WebApplicationContext;
*/
public final class MockMvcTester {
private static final MediaType JSON = MediaType.APPLICATION_JSON;
private final MockMvc mockMvc;
@Nullable
private final GenericHttpMessageConverter<Object> jsonMessageConverter;
private final HttpMessageContentConverter contentConverter;
private MockMvcTester(MockMvc mockMvc, @Nullable GenericHttpMessageConverter<Object> jsonMessageConverter) {
private MockMvcTester(MockMvc mockMvc, @Nullable HttpMessageContentConverter contentConverter) {
Assert.notNull(mockMvc, "mockMVC should not be null");
this.mockMvc = mockMvc;
this.jsonMessageConverter = jsonMessageConverter;
this.contentConverter = contentConverter;
}
/**
@@ -238,7 +233,7 @@ public final class MockMvcTester {
* @return a new instance using the specified converters
*/
public MockMvcTester withHttpMessageConverters(Iterable<HttpMessageConverter<?>> httpMessageConverters) {
return new MockMvcTester(this.mockMvc, findJsonMessageConverter(httpMessageConverters));
return new MockMvcTester(this.mockMvc, HttpMessageContentConverter.of(httpMessageConverters));
}
/**
@@ -380,10 +375,10 @@ public final class MockMvcTester {
public MvcTestResult perform(RequestBuilder requestBuilder) {
Object result = getMvcResultOrFailure(requestBuilder);
if (result instanceof MvcResult mvcResult) {
return new DefaultMvcTestResult(mvcResult, null, this.jsonMessageConverter);
return new DefaultMvcTestResult(mvcResult, null, this.contentConverter);
}
else {
return new DefaultMvcTestResult(null, (Exception) result, this.jsonMessageConverter);
return new DefaultMvcTestResult(null, (Exception) result, this.contentConverter);
}
}
@@ -396,19 +391,6 @@ public final class MockMvcTester {
}
}
@SuppressWarnings("unchecked")
@Nullable
private GenericHttpMessageConverter<Object> findJsonMessageConverter(
Iterable<HttpMessageConverter<?>> messageConverters) {
return StreamSupport.stream(messageConverters.spliterator(), false)
.filter(GenericHttpMessageConverter.class::isInstance)
.map(GenericHttpMessageConverter.class::cast)
.filter(converter -> converter.canWrite(null, Map.class, JSON))
.filter(converter -> converter.canRead(Map.class, JSON))
.findFirst().orElse(null);
}
/**
* Execute the request using the specified {@link RequestBuilder}. If the
* request is processing asynchronously, wait at most the given
@@ -502,7 +484,7 @@ public final class MockMvcTester {
@Override
public MvcTestResultAssert assertThat() {
return new MvcTestResultAssert(exchange(), MockMvcTester.this.jsonMessageConverter);
return new MvcTestResultAssert(exchange(), MockMvcTester.this.contentConverter);
}
}
@@ -560,7 +542,7 @@ public final class MockMvcTester {
@Override
public MvcTestResultAssert assertThat() {
return new MvcTestResultAssert(exchange(), MockMvcTester.this.jsonMessageConverter);
return new MvcTestResultAssert(exchange(), MockMvcTester.this.contentConverter);
}
}

6
spring-test/src/main/java/org/springframework/test/web/servlet/assertj/MvcTestResultAssert.java
View File

@@ -31,10 +31,10 @@ import org.assertj.core.api.MapAssert;
import org.assertj.core.error.BasicErrorMessageFactory;
import org.assertj.core.internal.Failures;
import org.springframework.http.converter.GenericHttpMessageConverter;
import org.springframework.lang.Nullable;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.http.HttpMessageContentConverter;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.ResultHandler;
import org.springframework.test.web.servlet.ResultMatcher;
@@ -51,8 +51,8 @@ import org.springframework.web.servlet.ModelAndView;
*/
public class MvcTestResultAssert extends AbstractMockHttpServletResponseAssert<MvcTestResultAssert, MvcTestResult> {
MvcTestResultAssert(MvcTestResult actual, @Nullable GenericHttpMessageConverter<Object> jsonMessageConverter) {
super(jsonMessageConverter, actual, MvcTestResultAssert.class);
MvcTestResultAssert(MvcTestResult actual, @Nullable HttpMessageContentConverter contentConverter) {
super(contentConverter, actual, MvcTestResultAssert.class);
}
@Override