Fix support for package-private test methods (#5100)

Prior to this commit, when the test super class wss declared in another
package and declared a package-private test method with the same
signature as the subclass, the method from the subclass was silently
ignored. With the changes in this commit, both test methods are
executed, albeit with the same display name.

Fixes #5098.

Author: marcphilipp

documentation/src/docs/asciidoc/release-notes/release-notes-5.14.1.adoc

@@ -35,7 +35,8 @@ repository on GitHub.
 [[release-notes-5.14.1-junit-jupiter-bug-fixes]]
 ==== Bug Fixes
 
-* ❓
+* Fix support for test methods with the same signature as a package-private methods
+  declared in super classes in different packages.
 
 [[release-notes-5.14.1-junit-jupiter-deprecations-and-breaking-changes]]
 ==== Deprecations and Breaking Changes

junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/discovery/ClassSelectorResolver.java

@@ -329,11 +329,7 @@ private DiscoverySelector selectClass(List<Class<?>> classes) {
 	}
 
 	private DiscoverySelector selectMethod(List<Class<?>> classes, Method method) {
-		if (classes.size() == 1) {
-			return DiscoverySelectors.selectMethod(classes.get(0), method);
-		}
-		int lastIndex = classes.size() - 1;
-		return DiscoverySelectors.selectNestedMethod(classes.subList(0, lastIndex), classes.get(lastIndex), method);
+		return new DeclaredMethodSelector(classes, method);
 	}
 
 	static class DummyClassTemplateInvocationContext implements ClassTemplateInvocationContext {

junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/discovery/DeclaredMethodSelector.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2015-2025 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * https://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.junit.jupiter.engine.discovery;
+
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.Objects;
+
+import org.junit.platform.commons.util.Preconditions;
+import org.junit.platform.engine.DiscoverySelector;
+import org.junit.platform.engine.discovery.MethodSelector;
+
+/**
+ * Jupiter-specific selector for methods, potentially in nested classes.
+ *
+ * <p>The important difference to {@link MethodSelector} is that this selector's
+ * {@link #equals(Object)} method takes into account the selected method's
+ * {@linkplain Method#getDeclaringClass() declaring class} to support cases
+ * where a package-private method is declared in a super class in a different
+ * package and a method with the same signature is declared in a subclass. In
+ * that case both methods should be discovered because the one declared in the
+ * subclass does <em>not</em> override the one in the super class.
+ *
+ * @since 6.0.1
+ */
+final class DeclaredMethodSelector implements DiscoverySelector {
+
+	private final List<Class<?>> testClasses;
+	private final Method method;
+
+	DeclaredMethodSelector(List<Class<?>> testClasses, Method method) {
+		Preconditions.notEmpty(testClasses, "testClasses must not be empty");
+		this.testClasses = Preconditions.containsNoNullElements(testClasses,
+			"testClasses must not contain null elements");
+		this.method = Preconditions.notNull(method, "method must not be null");
+	}
+
+	List<Class<?>> testClasses() {
+		return testClasses;
+	}
+
+	Method method() {
+		return method;
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (!(o instanceof DeclaredMethodSelector)) {
+			return false;
+		}
+		DeclaredMethodSelector that = (DeclaredMethodSelector) o;
+		return Objects.equals(testClasses, that.testClasses) //
+				&& Objects.equals(method, that.method);
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(testClasses, method);
+	}
+}

junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/discovery/MethodFinder.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2015-2025 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * https://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.junit.jupiter.engine.discovery;
+
+import static org.junit.platform.commons.util.ReflectionUtils.isDeclaredInSamePackage;
+import static org.junit.platform.commons.util.ReflectionUtils.isPackagePrivate;
+
+import java.lang.reflect.Method;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.junit.platform.commons.PreconditionViolationException;
+import org.junit.platform.commons.support.ReflectionSupport;
+import org.junit.platform.commons.util.ClassUtils;
+import org.junit.platform.commons.util.Preconditions;
+import org.junit.platform.commons.util.ReflectionUtils;
+
+/**
+ * @since 5.0
+ */
+class MethodSegmentResolver {
+
+	// Pattern: [declaringClassName#]methodName(comma-separated list of parameter type names)
+	private static final Pattern METHOD_PATTERN = Pattern.compile(
+		"(?:(?<declaringClass>.+)#)?(?<method>.+)\\((?<parameters>.*)\\)");
+
+	/**
+	 * If the {@code method} is package-private and declared a class in a
+	 * different package than {@code testClass}, the declaring class name is
+	 * included in the method's unique ID segment. Otherwise, it only
+	 * consists of the method name and its parameter types.
+	 */
+	String formatMethodSpecPart(Method method, Class<?> testClass) {
+		String parameterTypes = ClassUtils.nullSafeToString(method.getParameterTypes());
+		if (isPackagePrivate(method) && !isDeclaredInSamePackage(method.getDeclaringClass(), testClass)) {
+			return String.format("%s#%s(%s)", method.getDeclaringClass().getName(), method.getName(), parameterTypes);
+		}
+		return String.format("%s(%s)", method.getName(), parameterTypes);
+	}
+
+	Optional<Method> findMethod(String methodSpecPart, Class<?> testClass) {
+		Matcher matcher = METHOD_PATTERN.matcher(methodSpecPart);
+
+		Preconditions.condition(matcher.matches(),
+			() -> String.format("Method [%s] does not match pattern [%s]", methodSpecPart, METHOD_PATTERN));
+
+		Class<?> targetClass = testClass;
+		String declaringClass = matcher.group("declaringClass");
+		if (declaringClass != null) {
+			targetClass = ReflectionUtils.tryToLoadClass(declaringClass).getOrThrow(
+				cause -> new PreconditionViolationException(
+					"Could not load declaring class with name: " + declaringClass, cause));
+		}
+		String methodName = matcher.group("method");
+		String parameterTypeNames = matcher.group("parameters");
+		return ReflectionSupport.findMethod(targetClass, methodName, parameterTypeNames);
+	}
+
+}

junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/discovery/MethodSegmentResolver.java

@@ -40,7 +40,6 @@
 import org.junit.jupiter.engine.discovery.predicates.IsTestMethod;
 import org.junit.jupiter.engine.discovery.predicates.IsTestTemplateMethod;
 import org.junit.jupiter.engine.discovery.predicates.TestClassPredicates;
-import org.junit.platform.commons.util.ClassUtils;
 import org.junit.platform.engine.DiscoveryIssue;
 import org.junit.platform.engine.DiscoveryIssue.Severity;
 import org.junit.platform.engine.DiscoverySelector;
@@ -60,7 +59,7 @@
  */
 class MethodSelectorResolver implements SelectorResolver {
 
-	private static final MethodFinder methodFinder = new MethodFinder();
+	private static final MethodSegmentResolver methodSegmentResolver = new MethodSegmentResolver();
 	private final Predicate<Class<?>> testClassPredicate;
 
 	private final JupiterConfiguration configuration;
@@ -85,6 +84,21 @@ public Resolution resolve(NestedMethodSelector selector, Context context) {
 			Match::exact);
 	}
 
+	@Override
+	public Resolution resolve(DiscoverySelector selector, Context context) {
+		if (selector instanceof DeclaredMethodSelector) {
+			DeclaredMethodSelector methodSelector = (DeclaredMethodSelector) selector;
+			List<Class<?>> testClasses = methodSelector.testClasses();
+			if (testClasses.size() == 1) {
+				return resolve(context, emptyList(), testClasses.get(0), methodSelector::method, Match::exact);
+			}
+			int lastIndex = testClasses.size() - 1;
+			return resolve(context, testClasses.subList(0, lastIndex), testClasses.get(lastIndex),
+				methodSelector::method, Match::exact);
+		}
+		return unresolved();
+	}
+
 	private Resolution resolve(Context context, List<Class<?>> enclosingClasses, Class<?> testClass,
 			Supplier<Method> methodSupplier,
 			BiFunction<TestDescriptor, Supplier<Set<? extends DiscoverySelector>>, Match> matchFactory) {
@@ -216,7 +230,7 @@ Optional<TestDescriptor> resolveUniqueIdIntoTestDescriptor(UniqueId uniqueId, Co
 					String methodSpecPart = lastSegment.getValue();
 					Class<?> testClass = ((TestClassAware) parent).getTestClass();
 					// @formatter:off
-					return methodFinder.findMethod(methodSpecPart, testClass)
+					return methodSegmentResolver.findMethod(methodSpecPart, testClass)
 							.filter(methodPredicate)
 							.map(method -> createTestDescriptor(parent, testClass, method, configuration));
 					// @formatter:on
@@ -230,15 +244,14 @@ Optional<TestDescriptor> resolveUniqueIdIntoTestDescriptor(UniqueId uniqueId, Co
 
 		private TestDescriptor createTestDescriptor(TestDescriptor parent, Class<?> testClass, Method method,
 				JupiterConfiguration configuration) {
-			UniqueId uniqueId = createUniqueId(method, parent);
+			UniqueId uniqueId = createUniqueId(method, parent, testClass);
 			return testDescriptorFactory.create(uniqueId, testClass, method,
 				((TestClassAware) parent)::getEnclosingTestClasses, configuration);
 		}
 
-		private UniqueId createUniqueId(Method method, TestDescriptor parent) {
-			String methodId = String.format("%s(%s)", method.getName(),
-				ClassUtils.nullSafeToString(method.getParameterTypes()));
-			return parent.getUniqueId().append(segmentType, methodId);
+		private UniqueId createUniqueId(Method method, TestDescriptor parent, Class<?> testClass) {
+			return parent.getUniqueId().append(segmentType,
+				methodSegmentResolver.formatMethodSpecPart(method, testClass));
 		}
 
 		interface TestDescriptorFactory {

junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/discovery/MethodSelectorResolver.java

@@ -1997,21 +1997,33 @@ private static boolean isMethodOverriddenBy(Method upper, Method lower) {
 			}
 
 			// Cannot override a package-private method in another package.
-			if (isPackagePrivate(upper) && !declaredInSamePackage(upper, lower)) {
+			if (isPackagePrivate(upper) && !isDeclaredInSamePackage(upper, lower)) {
 				return false;
 			}
 		}
 
 		return hasCompatibleSignature(upper, lower.getName(), lower.getParameterTypes());
 	}
 
-	private static boolean isPackagePrivate(Member member) {
+	/**
+	 * @since 6.0.1
+	 */
+	@API(status = INTERNAL, since = "6.0.1")
+	public static boolean isPackagePrivate(Member member) {
 		int modifiers = member.getModifiers();
 		return !(Modifier.isPublic(modifiers) || Modifier.isProtected(modifiers) || Modifier.isPrivate(modifiers));
 	}
 
-	private static boolean declaredInSamePackage(Method m1, Method m2) {
-		return getPackageName(m1.getDeclaringClass()).equals(getPackageName(m2.getDeclaringClass()));
+	private static boolean isDeclaredInSamePackage(Method m1, Method m2) {
+		return isDeclaredInSamePackage(m1.getDeclaringClass(), m2.getDeclaringClass());
+	}
+
+	/**
+	 * @since 6.0.1
+	 */
+	@API(status = INTERNAL, since = "6.0.1")
+	public static boolean isDeclaredInSamePackage(Class<?> c1, Class<?> c2) {
+		return getPackageName(c1).equals(getPackageName(c2));
 	}
 
 	/**

junit-platform-commons/src/main/java/org/junit/platform/commons/util/ReflectionUtils.java

@@ -80,44 +80,38 @@ public class MethodSelector implements DiscoverySelector {
 	}
 
 	MethodSelector(Class<?> javaClass, String methodName, String parameterTypeNames) {
-		this.classLoader = javaClass.getClassLoader();
+		this(javaClass.getClassLoader(), javaClass.getName(), methodName, parameterTypeNames);
 		this.javaClass = javaClass;
-		this.className = javaClass.getName();
-		this.methodName = methodName;
-		this.parameterTypeNames = parameterTypeNames;
 	}
 
 	/**
 	 * @since 1.10
 	 */
 	MethodSelector(ClassLoader classLoader, String className, String methodName, Class<?>... parameterTypes) {
-		this.classLoader = classLoader;
-		this.className = className;
-		this.methodName = methodName;
+		this(classLoader, className, methodName, ClassUtils.nullSafeToString(Class::getTypeName, parameterTypes));
 		this.parameterTypes = parameterTypes.clone();
-		this.parameterTypeNames = ClassUtils.nullSafeToString(Class::getTypeName, this.parameterTypes);
 	}
 
 	/**
 	 * @since 1.10
 	 */
 	MethodSelector(Class<?> javaClass, String methodName, Class<?>... parameterTypes) {
-		this.classLoader = javaClass.getClassLoader();
+		this(javaClass.getClassLoader(), javaClass.getName(), methodName,
+			ClassUtils.nullSafeToString(Class::getTypeName, parameterTypes));
 		this.javaClass = javaClass;
-		this.className = javaClass.getName();
-		this.methodName = methodName;
 		this.parameterTypes = parameterTypes.clone();
-		this.parameterTypeNames = ClassUtils.nullSafeToString(Class::getTypeName, this.parameterTypes);
 	}
 
 	MethodSelector(Class<?> javaClass, Method method) {
-		this.classLoader = javaClass.getClassLoader();
+		this(javaClass, method, method.getParameterTypes());
+	}
+
+	private MethodSelector(Class<?> javaClass, Method method, Class<?>... parameterTypes) {
+		this(javaClass.getClassLoader(), javaClass.getName(), method.getName(),
+			ClassUtils.nullSafeToString(Class::getTypeName, parameterTypes));
 		this.javaClass = javaClass;
-		this.className = javaClass.getName();
 		this.javaMethod = method;
-		this.methodName = method.getName();
-		this.parameterTypes = method.getParameterTypes();
-		this.parameterTypeNames = ClassUtils.nullSafeToString(Class::getTypeName, this.parameterTypes);
+		this.parameterTypes = parameterTypes;
 	}
 
 	/**