Increased ResolvableType unit test coverage

Issue: SPR-11034

spring-core/src/main/java/org/springframework/core/ResolvableType.java

@@ -358,18 +358,16 @@ public final class ResolvableType implements Serializable {
 	 * The result will be {@code true} only in those two scenarios.
 	 */
 	public boolean hasUnresolvableGenerics() {
-		ResolvableType[] generics = getGenerics();
+		for (Class<?> generic : resolveGenerics()) {
-		for (ResolvableType generic : generics) {
+			if (generic == null) {
-			if (generic.resolve() == null) {
 				return true;
 			}
 		}
 		Class<?> resolved = resolve();
 		if (resolved != null) {
-			Type[] ifcs = resolved.getGenericInterfaces();
+			for (Type genericInterface : resolved.getGenericInterfaces()) {
-			for (Type ifc : ifcs) {
+				if (genericInterface instanceof Class) {
-				if (ifc instanceof Class) {
+					if (forClass((Class<?>) genericInterface).hasGenerics()) {
-					if (forClass((Class) ifc).hasGenerics()) {
 						return true;
 					}
 				}

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

@@ -48,7 +48,6 @@ import org.junit.runner.RunWith;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Captor;
 import org.mockito.runners.MockitoJUnitRunner;
-
 import org.springframework.core.ResolvableType.VariableResolver;
 import org.springframework.util.MultiValueMap;
 
@@ -57,6 +56,8 @@ import static org.junit.Assert.*;
 import static org.mockito.BDDMockito.*;
 
 /**
+ * Tests for {@link ResolvableType}.
+ *
  * @author Phillip Webb
  */
 @SuppressWarnings("rawtypes")
@@ -89,6 +90,7 @@ public class ResolvableTypeTests {
 		assertThat(none.resolveGeneric(0), nullValue());
 		assertThat(none.resolveGenerics().length, equalTo(0));
 		assertThat(none.toString(), equalTo("?"));
+		assertThat(none.hasUnresolvableGenerics(), equalTo(false));
 		assertThat(none.isAssignableFrom(ResolvableType.forClass(Object.class)), equalTo(false));
 	}
 
@@ -1121,6 +1123,42 @@ public class ResolvableTypeTests {
 		assertThat(narrow.getGeneric().resolve(), equalTo((Class) String.class));
 	}
 
+	@Test
+	public void hasUnresolvableGenerics() throws Exception {
+		ResolvableType type = ResolvableType.forField(Fields.class.getField("stringList"));
+		assertThat(type.hasUnresolvableGenerics(), equalTo(false));
+	}
+
+	@Test
+	public void hasUnresolvableGenericsBasedOnOwnGenerics() throws Exception {
+		ResolvableType type = ResolvableType.forClass(List.class);
+		assertThat(type.hasUnresolvableGenerics(), equalTo(true));
+	}
+
+	@Test
+	public void hasUnresolvableGenericsWhenSelfNotResolvable() throws Exception {
+		ResolvableType type = ResolvableType.forClass(List.class).getGeneric();
+		assertThat(type.hasUnresolvableGenerics(), equalTo(false));
+	}
+
+	@Test
+	public void hasUnresolvableGenericsWhenImplementesRawInterface() throws Exception {
+		ResolvableType type = ResolvableType.forClass(MySimpleInterfaceTypeWithImplementsRaw.class);
+		for (ResolvableType generic : type.getGenerics()) {
+			assertThat(generic.resolve(), not(nullValue()));
+		}
+		assertThat(type.hasUnresolvableGenerics(), equalTo(true));
+	}
+
+	@Test
+	public void hasUnresolvableGenericsWhenExtends() throws Exception {
+		ResolvableType type = ResolvableType.forClass(ExtendsMySimpleInterfaceTypeWithImplementsRaw.class);
+		for (ResolvableType generic : type.getGenerics()) {
+			assertThat(generic.resolve(), not(nullValue()));
+		}
+		assertThat(type.hasUnresolvableGenerics(), equalTo(true));
+	}
+
 
 	private ResolvableType testSerialization(ResolvableType type) throws Exception {
 		ByteArrayOutputStream bos = new ByteArrayOutputStream();
@@ -1332,6 +1370,14 @@ public class ResolvableTypeTests {
 
 	}
 
+	public abstract class MySimpleInterfaceTypeWithImplementsRaw implements MyInterfaceType<String>, List {
+
+	}
+
+	public abstract class ExtendsMySimpleInterfaceTypeWithImplementsRaw extends MySimpleInterfaceTypeWithImplementsRaw {
+
+	}
+
 
 	public class MyCollectionInterfaceType implements MyInterfaceType<Collection<String>> {