test method overriding

src/test/java/spoon/test/method_overriding/MethodOverriddingTest.java

@@ -0,0 +1,74 @@
+package spoon.test.method_overriding;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiFunction;
+
+import org.junit.Test;
+
+import spoon.reflect.declaration.CtMethod;
+import spoon.reflect.factory.Factory;
+import spoon.reflect.visitor.filter.TypeFilter;
+import spoon.testing.utils.ModelUtils;
+
+import static org.junit.Assert.*;
+
+public class MethodOverriddingTest {
+
+	@Test
+	public void testMethodOverride() {
+		checkMethodOverride((m1, m2)->m1.isOverriding(m2));
+	}
+	@Test
+	public void testMethodOverrideByReference() {
+		checkMethodOverride((m1, m2)->m1.getReference().isOverriding(m2.getReference()));
+	}
+
+	private void checkMethodOverride(BiFunction<CtMethod<?>, CtMethod<?>, Boolean> isOverriding) {
+		Factory factory = ModelUtils.build(new File("src/test/java/spoon/test/method_overriding/testclasses").listFiles());
+		Map<String, List<CtMethod>> methodsByName = new HashMap<>();
+		factory.getModel().getRootPackage().filterChildren(new TypeFilter<>(CtMethod.class)).forEach((CtMethod m)->{
+			List<CtMethod> methods = methodsByName.get(m.getSimpleName());
+			if(methods==null) {
+				methods = new ArrayList<>();
+				methodsByName.put(m.getSimpleName(), methods);
+			}
+			methods.add(m);
+		});
+		for (Map.Entry<String, List<CtMethod>> e : methodsByName.entrySet()) {
+			combine(e.getValue(), 0, isOverriding);
+		}
+	}
+
+	private void combine(List<CtMethod> value, int start, BiFunction<CtMethod<?>, CtMethod<?>, Boolean> isOverriding) {
+		CtMethod m1 = value.get(start);
+		if(start+1<value.size()) {
+			for (CtMethod m2 : value.subList(start+1, value.size())) {
+				if(m1.getDeclaringType().isSubtypeOf(m2.getDeclaringType().getReference())) {
+					checkOverride(m1, m2, isOverriding);
+				} else if(m2.getDeclaringType().isSubtypeOf(m1.getDeclaringType().getReference())) {
+					checkOverride(m2, m1, isOverriding);
+				} else {
+					checkNotOverride(m1, m2, isOverriding);
+				}
+			}
+			combine(value, start+1, isOverriding);
+		}
+	}
+
+	private void checkOverride(CtMethod m1, CtMethod m2, BiFunction<CtMethod<?>, CtMethod<?>, Boolean> isOverriding) {
+		assertTrue(descr(m1)+" overriding "+descr(m2), 		isOverriding.apply(m1, m2));
+		assertFalse(descr(m2)+" NOT overriding "+descr(m1), isOverriding.apply(m2, m1));
+	}
+	private void checkNotOverride(CtMethod m1, CtMethod m2, BiFunction<CtMethod<?>, CtMethod<?>, Boolean> isOverriding) {
+		assertFalse(descr(m1)+" NOT overriding "+descr(m2), isOverriding.apply(m1, m2));
+		assertFalse(descr(m2)+" NOT overriding "+descr(m1), isOverriding.apply(m2, m1));
+	}
+
+	private String descr(CtMethod m) {
+		return m.getDeclaringType().getSimpleName()+"#"+m.getSimpleName();
+	}
+}

src/test/java/spoon/test/method_overriding/testclasses/A.java

@@ -0,0 +1,24 @@
+package spoon.test.method_overriding.testclasses;
+
+import java.util.List;
+
+public class A<U> {
+
+	public A() {
+	}
+
+	A<U> m1(C c){
+		return null;
+	}
+
+	<T extends A<U>> T m2(C c){
+		return null;
+	}
+
+	void m3(List<? super C> c){
+	}
+	void m4(List<? extends A<U>> c){
+	}
+	void m5(U u) {
+	}
+}

src/test/java/spoon/test/method_overriding/testclasses/B.java

@@ -0,0 +1,32 @@
+package spoon.test.method_overriding.testclasses;
+
+import java.util.List;
+
+public class B<S, R extends S> extends A<S> {
+
+	public B() {
+	}
+
+	@Override
+	B<S, R> m1(C c){
+		return null;
+	}
+
+	@Override
+	<T extends A<S>> T m2(C c){
+		return null;
+	}
+
+	@Override
+	void m3(List<? super C> c){
+	}
+
+	@Override
+	void m5(S u) {
+		super.m5(u);
+	}
+
+	@Override
+	void m4(List<? extends A<S>> c) {
+	}
+}

src/test/java/spoon/test/method_overriding/testclasses/C.java

@@ -0,0 +1,37 @@
+package spoon.test.method_overriding.testclasses;
+
+import java.io.FilterInputStream;
+import java.io.InputStream;
+import java.util.List;
+
+public class C extends B<InputStream, FilterInputStream> {
+
+	public C() {
+	}
+
+	@Override
+	B m1(C c){
+		return null;
+	}
+
+	@Override
+	B<InputStream, FilterInputStream> m2(C c){
+		return null;
+	}
+
+	@Override
+	void m3(List<? super C> c) {
+		// TODO Auto-generated method stub
+		super.m3(c);
+	}
+
+	@Override
+	void m4(List<? extends A<InputStream>> c){
+	}
+
+	@Override
+	void m5(InputStream u) {
+		super.m5(u);
+	}
+
+}

src/test/java/spoon/test/method_overriding/testclasses/D.java

@@ -0,0 +1,24 @@
+package spoon.test.method_overriding.testclasses;
+
+import java.util.List;
+
+public class D extends B<Integer, Integer> {
+
+	public D() {
+	}
+
+	@Override
+	B<Integer, Integer> m1(C c){
+		return null;
+	}
+
+	@Override
+	D m2(C c){
+		return null;
+	}
+
+	@Override
+	void m4(List<? extends A<Integer>> c){
+	}
+
+}

src/test/java/spoon/test/method_overriding/testclasses/IA.java

@@ -0,0 +1,5 @@
+package spoon.test.method_overriding.testclasses;
+
+public interface IA {
+
+}