Polishing

spring-core/src/main/java/org/springframework/util/RouteMatcher.java

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.springframework.util;
 
 import java.util.Comparator;
@@ -23,13 +24,14 @@
 /**
  * Contract for matching routes to patterns.
  *
- * <p>Equivalent to {@link PathMatcher}, but enables use of parsed
- * representations of routes and patterns for efficiency reasons in scenarios
- * where routes from incoming messages are continuously matched against a
- * large number of message handler patterns.
+ * <p>Equivalent to {@link PathMatcher}, but enables use of parsed representations
+ * of routes and patterns for efficiency reasons in scenarios where routes from
+ * incoming messages are continuously matched against a large number of message
+ * handler patterns.
  *
  * @author Rossen Stoyanchev
  * @since 5.2
+ * @see PathMatcher
  */
 public interface RouteMatcher {
 

spring-core/src/test/java/org/springframework/core/ResolvableTypeTests.java

@@ -147,28 +147,28 @@ public void forRawClassAssignableFromTypeVariable() { // gh-23321
 	}
 
 	@Test
-	public void forInstanceMustNotBeNull() {
+	public void forInstanceMustNotBeNull() throws Exception {
 		assertThatIllegalArgumentException().isThrownBy(() ->
 				ResolvableType.forInstance(null))
 			.withMessageContaining("Instance must not be null");
 	}
 
 	@Test
-	public void forInstanceNoProvider() {
+	public void forInstanceNoProvider() throws Exception {
 		ResolvableType type = ResolvableType.forInstance(new Object());
 		assertThat(type.getType()).isEqualTo(Object.class);
 		assertThat(type.resolve()).isEqualTo(Object.class);
 	}
 
 	@Test
-	public void forInstanceProvider() {
+	public void forInstanceProvider() throws Exception {
 		ResolvableType type = ResolvableType.forInstance(new MyGenericInterfaceType<>(String.class));
 		assertThat(type.getRawClass()).isEqualTo(MyGenericInterfaceType.class);
 		assertThat(type.getGeneric().resolve()).isEqualTo(String.class);
 	}
 
 	@Test
-	public void forInstanceProviderNull() {
+	public void forInstanceProviderNull() throws Exception {
 		ResolvableType type = ResolvableType.forInstance(new MyGenericInterfaceType<String>(null));
 		assertThat(type.getType()).isEqualTo(MyGenericInterfaceType.class);
 		assertThat(type.resolve()).isEqualTo(MyGenericInterfaceType.class);
@@ -1348,6 +1348,7 @@ private static ResolvableTypeAssert assertThatResolvableType(ResolvableType type
 		return new ResolvableTypeAssert(type);
 	}
 
+
 	@SuppressWarnings("unused")
 	private HashMap<Integer, List<String>> myMap;
 
@@ -1356,7 +1357,6 @@ private static ResolvableTypeAssert assertThatResolvableType(ResolvableType type
 	static class ExtendsList extends ArrayList<CharSequence> {
 	}
 
-
 	@SuppressWarnings("serial")
 	static class ExtendsMap extends HashMap<String, Integer> {
 	}
@@ -1615,6 +1615,7 @@ public abstract class UnresolvedWithGenerics {
 		Set<Integer> set;
 	}
 
+
 	private static class ResolvableTypeAssert extends AbstractAssert<ResolvableTypeAssert, ResolvableType>{
 
 		public ResolvableTypeAssert(ResolvableType actual) {
@@ -1648,7 +1649,6 @@ private String decribe(ResolvableType type) {
 			}
 			return type.getType() + ":" + type;
 		}
-
 	}
 
 }