[3.27] Backport detection of Junit misconfiguration

core/deployment/src/main/java/io/quarkus/runner/bootstrap/StartupActionImpl.java

@@ -316,6 +316,13 @@ private void ensureDevServicesStarted() {
      * Runs the application, and returns a handle that can be used to shut it down.
      */
     public RunningQuarkusApplication run(String... args) throws Exception {
+
+        if (runtimeClassLoader.isClosed()) {
+            throw new RuntimeException(
+                    "Internal error: An attempt was made to start an application which had already been started and closed. The affected ClassLoader is "
+                            + runtimeClassLoader);
+
+        }
         // Start dev services that weren't started in the augmentation phase
         ensureDevServicesStarted();
         InitialConfigurator.DELAYED_HANDLER.buildTimeComplete();

core/runtime/src/main/java/io/quarkus/runtime/configuration/ConfigRecorder.java

@@ -111,7 +111,7 @@ public void releaseConfig(ShutdownContext shutdownContext) {
 
         if (shutdownContext == null) {
             throw new RuntimeException(
-                    "Internal errror: shutdownContext is null. This probably happened because Quarkus failed to start properly in an earlier step, or because tests were run on a Quarkus instance that had already been shut down.");
+                    "Internal error: shutdownContext is null. This probably happened because Quarkus failed to start properly in an earlier step, or because tests were run on a Quarkus instance that had already been shut down.");
         }
         shutdownContext.addLastShutdownTask(QuarkusConfigFactory::releaseTCCLConfig);
     }

test-framework/junit5/src/main/java/io/quarkus/test/junit/QuarkusTestExtension.java

@@ -621,9 +621,10 @@ private QuarkusTestExtensionState ensureStarted(ExtensionContext extensionContex
         }
         cl.getCuratedApplication().setEligibleForReuse(isSameCuratedApplication);
 
-        // TODO if classes are misordered, say because someone overrode the ordering, and there are profiles or resources,
-        // we could try to start and application which has already been started, and fail with a mysterious error about
-        // null shutdown contexts; we should try and detect that case, and give a friendlier error message
+        if (cl.isClosed()) {
+            throw new IllegalStateException(
+                    "Internal error. Attempting to run tests using an application which has already been closed. Is a non-default test order being used?");
+        }
 
         // We want to start if the profile changed (or there are new test resources),
         // or if we don't have an app and that's not because the previous attempt to start it failed

test-framework/junit5/src/main/java/io/quarkus/test/junit/classloading/FacadeClassLoader.java

@@ -571,6 +571,14 @@ public boolean isServiceLoaderMechanism() {
         return isServiceLoaderMechanism;
     }
 
+    /**
+     * Returns true if, after test discovery, multiple classloaders have been created. This would mean multiple Quarkus
+     * applications will be started to run the tests.
+     */
+    public boolean hasMultipleClassLoaders() {
+        return runtimeClassLoaders != null && runtimeClassLoaders.size() > 1;
+    }
+
     @Override
     public String getName() {
         return NAME;
@@ -589,5 +597,4 @@ public void close() throws IOException {
         runtimeClassLoaders.clear();
 
     }
-
 }

test-framework/junit5/src/main/java/io/quarkus/test/junit/launcher/CustomLauncherInterceptor.java

@@ -1,17 +1,25 @@
 package io.quarkus.test.junit.launcher;
 
+import java.util.Optional;
+
+import org.jboss.logging.Logger;
+import org.junit.jupiter.api.ClassOrderer;
 import org.junit.platform.launcher.LauncherDiscoveryListener;
 import org.junit.platform.launcher.LauncherDiscoveryRequest;
 import org.junit.platform.launcher.LauncherSession;
 import org.junit.platform.launcher.LauncherSessionListener;
 import org.junit.platform.launcher.TestExecutionListener;
 import org.junit.platform.launcher.TestPlan;
 
+import io.quarkus.test.config.QuarkusClassOrderer;
 import io.quarkus.test.junit.classloading.FacadeClassLoader;
 
 public class CustomLauncherInterceptor
         implements LauncherDiscoveryListener, LauncherSessionListener, TestExecutionListener {
 
+    private static final Class<? extends ClassOrderer> DESIRED_CLASS_ORDERER = QuarkusClassOrderer.class;
+    private static final Logger log = Logger.getLogger(CustomLauncherInterceptor.class);
+
     private static FacadeClassLoader facadeLoader = null;
     // Also use a static variable to store a 'first' starting state that we can reset to
     private static ClassLoader origCl = null;
@@ -51,7 +59,6 @@ private void actuallyIntercept() {
             origCl = Thread.currentThread()
                     .getContextClassLoader();
         }
-        // We might not be in the same classloader as the Facade ClassLoader, so use a name comparison instead of an instanceof
         initializeFacadeClassLoader();
         adjustContextClassLoader();
 
@@ -118,7 +125,41 @@ public void launcherDiscoveryFinished(LauncherDiscoveryRequest request) {
                 Thread.currentThread().setContextClassLoader(origCl);
 
             }
+
+            Optional<String> orderer = request.getConfigurationParameters().get("junit.jupiter.testclass.order.default");
+
+            if (orderer.isEmpty() || !orderer.get().equals(DESIRED_CLASS_ORDERER.getName())) {
+                if (facadeLoader != null && facadeLoader.hasMultipleClassLoaders()) {
+                    String message = getFailureMessageForJUnitMisconfiguration(orderer);
+                    // This is likely to be quite a serious problem for tests, but as this is a maintenance stream, be conservative
+                    log.warn(message);
+                }
+            }
+        }
+    }
+
+    private static String getFailureMessageForJUnitMisconfiguration(Optional<String> orderer) {
+        String generalExplanation = """
+                Critical problem. Quarkus tests are likely to fail with corrupted application errors.
+                The reason is that they will not run in the right order, because the Quarkus JUnit configuration has been overridden.
+                When there are multiple test profiles or resources, Quarkus uses a JUnit ClassOrderer to sort tests so that test with the same profile run one after each other.
+                Running tests with a different sorting risks tests running on an application that has been cleaned up.
+                """;
+
+        String message;
+        if (orderer.isPresent()) {
+            message = String.format(
+                    "%sTo set a test order while preserving the Quarkus required sorting, please use the Quarkus configuration to set junit.quarkus.orderer.secondary-orderer=%s, and remove the junit-platform.properties (if any) from the classpath.",
+                    generalExplanation, orderer.get());
+        } else {
+            message = String.format(
+                    """
+                            %sIt looks like there is a junit-platform.properties configuration file on the project classpath.
+                            The JUnit framework will only read the first properties it finds, which prevents Quarkus from setting the class orderer it needs.
+                            Please either add junit.jupiter.testclass.order.default=%s to your project's junit-platform.properties file, or remove the file and use system properties to configure JUnit.""",
+                    generalExplanation, DESIRED_CLASS_ORDERER.getName());
         }
+        return message;
     }
 
     @Override