== Release 0.11.5

- Feature – Auto-fallback to JVM JUnit when -H:+CompatibilityMode is enabled

+

* When -H:+CompatibilityMode is present in native-image options, native-image JUnit tests are disabled and JVM tests run automatically.

* Detection sources: native-image build arguments and NATIVE_IMAGE_OPTIONS environment variable.

* Gradle: test image wiring for the native JUnit launcher and JUnit Platform feature is gated; native test image build/run tasks are skipped via onlyIf; once-per-build log:

+

"Compatibility Mode detected (-H:+CompatibilityMode); The native test image will be built using the original JUnit ConsoleLauncher."

* Maven: native test goal short-circuits after environment setup; once-per-build log:

+

"Compatibility Mode detected (-H:+CompatibilityMode); The native test image will be built using the original JUnit ConsoleLauncher."

* Default behavior unchanged when the flag is absent (native-image JUnit path continues as before).

import org.graalvm.buildtools.gradle.internal.NativeImageExecutableLocator;

import org.graalvm.buildtools.gradle.tasks.scanner.JarAnalyzerTransform;

// Compatibility Mode detection constants

private static final String COMPATIBILITY_MODE_TOKEN = "-H:+CompatibilityMode";

private static final String NATIVE_IMAGE_OPTIONS_ENV = "NATIVE_IMAGE_OPTIONS";

// Exposed detection provider for test binaries (to be used by follow-up tasks)

private Provider<Boolean> compatModeEnabled;

// Compute and expose the Compatibility Mode detection provider for test binary

this.compatModeEnabled = computeCompatibilityModeEnabledProvider(project, testOptions);

// Unified once-per-build log at configuration time if Compatibility Mode is enabled

project.afterEvaluate(p -> {

if (compatModeEnabled().getOrElse(false)) {

logger.logOnce("Compatibility Mode detected (-H:+CompatibilityMode); The native test image will be built using the original JUnit ConsoleLauncher.");

}

});

// Wire main class based on Compatibility Mode, mirroring Maven plugin behavior.

testOptions.getMainClass().convention(compatModeEnabled().map(c -> c

? "org.junit.platform.console.ConsoleLauncher"

: "org.graalvm.junit.platform.NativeImageJUnitLauncher"));

// Add the JUnit Platform Feature flag and exclude JUnit class init files only when NOT in Compatibility Mode.

final String junitPlatformFeatureFlag = "--features=org.graalvm.junit.platform.JUnitPlatformFeature";

project.afterEvaluate(p -> {

boolean compat = compatModeEnabled().getOrElse(false);

if (!compat) {

List<String> current = testOptions.getBuildArgs().getOrElse(Collections.emptyList());

if (!current.contains(junitPlatformFeatureFlag)) {

testOptions.getBuildArgs().add(junitPlatformFeatureFlag);

}

/* in version 5.12.0 JUnit added initialize-at-build-time properties files which we need to exclude */

testOptions.getBuildArgs().addAll(JUnitUtils.excludeJUnitClassInitializationFiles());

}

});

// Add XML output dir only in regular mode (not in Compatibility Mode)

Provider<String> xmlOutputDir = project.getLayout().getBuildDirectory()

.dir("test-results/" + name + "-native")

.map(d -> d.getAsFile().getAbsolutePath());

testOptions.getRuntimeArgs().addAll(

compatModeEnabled().zip(xmlOutputDir, serializableBiFunctionOf((compat, dir) ->

compat ? Collections.emptyList() : Arrays.asList("--xml-output-dir", dir)

))

);

// In Compatibility Mode, pass classpath and scan directive to the JUnit ConsoleLauncher to avoid

// "Please specify an explicit selector option or use --scan-class-path or --scan-modules"

Provider<String> cpString = project.getProviders().provider(() -> testOptions.getClasspath().getAsPath());

testOptions.getRuntimeArgs().addAll(

compatModeEnabled().zip(cpString, serializableBiFunctionOf((compat, cp) ->

compat ? Arrays.asList("-Djava.class.path=" + cp, "--scan-classpath") : Collections.<String>emptyList()

))

);

// In Compatibility Mode, also pass -Djava.home from the GraalVM used for the build

Provider<String> graalVmHome = project.getProviders().provider(() -> {

NativeImageExecutableLocator.Diagnostics d = new NativeImageExecutableLocator.Diagnostics();

File nativeImage = NativeImageExecutableLocator.findNativeImageExecutable(

testOptions.getJavaLauncher(),

graalExtension.getToolchainDetection().map(enabled -> !enabled),

graalvmHomeProvider(project.getProviders(), d),

getExecOperations(),

logger,

d

);

File parent = nativeImage.getParentFile();

return parent != null ? parent.getParent() : null;

});

testOptions.getRuntimeArgs().addAll(

compatModeEnabled().zip(graalVmHome, serializableBiFunctionOf((compat, home) ->

compat && home != null ? Collections.singletonList("-Djava.home=" + home) : Collections.<String>emptyList()

))

);

// -----------------------------

// Compatibility Mode Detection

// -----------------------------

/**

public Provider<Boolean> compatModeEnabled() {

return compatModeEnabled;

}

private static Provider<Boolean> computeCompatibilityModeEnabledProvider(Project project, NativeImageOptions options) {

ProviderFactory providers = project.getProviders();

// System environment: NATIVE_IMAGE_OPTIONS

Provider<Boolean> fromSystemEnv = providers.environmentVariable(NATIVE_IMAGE_OPTIONS_ENV)

.map(NativeImagePlugin::containsCompatibilityTokenInString)

.orElse(false);

// Options-level environment variables

Provider<Boolean> fromOptionsEnv = options.getEnvironmentVariables()

.map(env -> {

Object v = env.get(NATIVE_IMAGE_OPTIONS_ENV);

return v != null && containsCompatibilityTokenInString(String.valueOf(v));

})

.orElse(false);

// Build args on the test options

Provider<Boolean> fromBuildArgs = options.getBuildArgs()

.map(NativeImagePlugin::containsCompatibilityTokenInArgs)

.orElse(false);

// Combine: true if any source enables compatibility mode

Provider<Boolean> anyEnv = fromSystemEnv.zip(fromOptionsEnv, (a, b) -> a || b);

return anyEnv.zip(fromBuildArgs, (ab, c) -> ab || c);

}

private static boolean containsCompatibilityTokenInString(String value) {

return value != null && value.contains(COMPATIBILITY_MODE_TOKEN);

}

public static boolean containsCompatibilityTokenInArgs(List<String> args) {

return args != null && args.stream()

.filter(Objects::nonNull)

.anyMatch(s -> s.equals(COMPATIBILITY_MODE_TOKEN));

}

if (Files.exists(Path.of(outputDirectory.getPath(), "dynamic-access-metadata.json"))) {

imageClasspath.add(Path.of(outputDirectory.getPath(), "dynamic-access-metadata.json"));