Add tests to validate recent fixes

Treiblesschorle · ctrueden · commit 12476ba53b61 · 2019-04-18T12:02:50.000-05:00
These tests cover commits:
- "Use the bound of the TypeVariable as search class"
- "Get correct type arguments if src is not parameterized itself"
diff --git a/src/test/java/org/scijava/ops/util/TypesTest.java b/src/test/java/org/scijava/ops/util/TypesTest.java
@@ -63,6 +63,8 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Function;
 import java.util.jar.JarOutputStream;
 import java.util.zip.ZipEntry;
 
@@ -828,6 +830,68 @@ public <T> void testSatisfiesMatchingT() {
 		assertNotEquals(Types.satisfies(argsMiss, params), -1);
 
 	}
+	
+	/**
+	 * Tests {@link Types#satisfies(Type[], Type[])} when the given type is indirectly parameterized by
+	 * implementing an parameterized interface.
+	 */
+	@Test
+	public <I1, I2> void testSatisfiesIndirectTypeVariables() {
+
+		class NestedThingImplOK1 implements NestedThing<Double, Double> {
+			@Override
+			public Double apply(Double t) {
+				// NB: No implementation needed.
+				return null;
+			}
+		}
+		
+		final Type[] param = new Type[]{new Nil<Function<I1, I2>>() {}.getType()};
+		Type[] argOK = new Type[]{NestedThingImplOK1.class};
+		assertEquals(-1, Types.satisfies(argOK, param));
+	}
+	
+	/**
+	 * Tests {@link Types#satisfies(Type[], Type[])} when unbounded type variables are expected 
+	 * but the given ones are nested and bounded.
+	 */
+	@Test
+	public <I1, I2> void testSatisfiesUnboundedTypeVariables() {
+
+		class NestedThingImplOK1 implements Function<Iterable<Double>, Consumer<Double>> {
+			@Override
+			public Consumer<Double> apply(Iterable<Double> t) {
+				// NB: No implementation needed.
+				return null;
+			}
+		}
+		
+		class NestedThingImplOK2 implements Function<Iterable<Double>, Consumer<Integer>> {
+			@Override
+			public Consumer<Integer> apply(Iterable<Double> t) {
+				// NB: No implementation needed.
+				return null;
+			}
+		}
+		
+		class NestedThingImplOK3 implements Function<Double, Consumer<Integer>> {
+			@Override
+			public Consumer<Integer> apply(Double t) {
+				// NB: No implementation needed.
+				return null;
+			}
+		}
+		
+		final Type[] param = new Type[]{new Nil<Function<I1, I2>>() {}.getType()};
+		Type[] argOK = new Type[]{NestedThingImplOK1.class};
+		assertEquals(-1, Types.satisfies(argOK, param));
+
+		argOK = new Type[]{NestedThingImplOK2.class};
+		assertEquals(-1, Types.satisfies(argOK, param));
+		
+		final Type[] argNotOK = new Type[]{NestedThingImplOK3.class};
+		assertEquals(-1, Types.satisfies(argNotOK, param));
+	}
 
 	/** Tests {@link Types#cast(Object, Class)}. */
 	@Test
@@ -951,6 +1015,11 @@ private static class LoopingThing extends RecursiveThing<LoopingThing>
 	{
 		// NB: No implementation needed.
 	}
+	
+	interface NestedThing<I1, I2> extends Function<I1, I2>
+	{
+		// NB: No implementation needed.
+	}
 
 	/** Enumeration for testing conversion to enum types. */
 	public static enum Words {
