native-image-testing.gradle

/*
 * Copyright (c) 2020, 2021, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * The Universal Permissive License (UPL), Version 1.0
 *
 * Subject to the condition set forth below, permission is hereby granted to any
 * person obtaining a copy of this software, associated documentation and/or
 * data (collectively the "Software"), free of charge and under any and all
 * copyright rights in the Software, and any and all patent rights owned or
 * freely licensable by each licensor hereunder covering either (i) the
 * unmodified Software as contributed to or provided by such licensor, or (ii)
 * the Larger Works (as defined below), to deal in both
 *
 * (a) the Software, and
 *
 * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
 * one is included with the Software each a "Larger Work" to which the Software
 * is contributed by such licensors),
 *
 * without restriction, including without limitation the rights to copy, create
 * derivative works of, display, perform, and distribute the Software and make,
 * use, sell, offer for sale, import, export, have made, and have sold the
 * Software and the Larger Work(s), and to sublicense the foregoing rights on
 * either these or other terms.
 *
 * This license is subject to the following condition:
 *
 * The above copyright notice and either this complete permission notice or at a
 * minimum a reference to the UPL must be included in all copies or substantial
 * portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
def agentOutput = layout.buildDirectory.dir("agent")

ext {
    testIdsDir = layout.buildDirectory.dir("test_ids")
}

tasks.register("testConsoleLauncher", JavaExec) {
    outputs.dir(agentOutput)
    classpath = test.classpath
    main = "org.junit.platform.console.ConsoleLauncher"
    args = ["--scan-class-path"]
    doFirst {
        def agentOutputDir = agentOutput.get().asFile
        if (agentOutputDir.exists()) {
            delete { delete agentOutputDir }
        }
        if (project.hasProperty("agent")) {
            mkdir "${agentOutputDir}"
            new File("${agentOutputDir}", "agent-filter.json").text = """
            {
                "rules":[
                    {
                        "excludeClasses":"org.gradle.**"
                    },
                    {
                        "excludeClasses":"java.**"
                    }
                ]
            }
        """
            jvmArgs = [
                    "-agentlib:native-image-agent=access-filter-file=${agentOutputDir}/agent-filter.json,experimental-class-loader-support,config-output-dir=${agentOutputDir}/agentOutput",
                    "-Dorg.graalvm.nativeimage.imagecode=agent"
            ]
        }
    }
}

abstract class NativeTestArgumentProvider implements CommandLineArgumentProvider {
    @InputFiles
    abstract ConfigurableFileCollection getClasspath()

    @InputDirectory
    abstract DirectoryProperty getTestIdsDir()

    @InputDirectory
    @Optional
    abstract DirectoryProperty getAgentOutputDir()

    @Input
    abstract Property<Boolean> getDiscovery()

    @Override
    Iterable<String> asArguments() {
        def args = [
                "-cp", classpath.asPath,
                "--no-fallback",
                "--features=org.graalvm.junit.platform.JUnitPlatformFeature",
                "-o", "native-image-tests",
                "-Djunit.platform.listeners.uid.tracking.output.dir=${testIdsDir.get().asFile.absolutePath}"
        ]
        if (agentOutputDir.isPresent()) {
            def outputDir = agentOutputDir.get().asFile
            if (!outputDir.exists()) {
                throw new GradleException("Agent output missing when -Pagent is set.\n" +
                        "You need to run `gradle -Pagent test` first.")
            }

            args << "-H:ConfigurationFileDirectories=${outputDir.absolutePath}/agentOutput"
        }

        if (discovery.get()) {
            args << "-DtestDiscovery"
        }

        // Main class comes last
        args << "org.graalvm.junit.platform.NativeImageJUnitLauncher"

        args.collect { it.toString() }
    }
}

tasks.named("test") {
    doFirst {
        agentOutput.get().asFile.mkdirs()
    }
}

tasks.register("nativeTestCompile", Exec) {
    dependsOn(test)
    inputs.files(test.classpath)
    workingDir "${buildDir}"
    executable = System.getenv("GRAALVM_HOME") + "/bin/native-image"
    def argsProvider = objects.newInstance(NativeTestArgumentProvider)
    argsProvider.classpath.from(test.classpath)
    argsProvider.testIdsDir.set(testIdsDir)
    argsProvider.agentOutputDir.set(agentOutput)
    argsProvider.discovery.set(providers.systemProperty("testDiscovery").map(v -> Boolean.valueOf(v)).orElse(false))
    argumentProviders.add(argsProvider)
}

tasks.register("nativeTest", Exec) {
    dependsOn nativeTestCompile
    workingDir = "${buildDir}"
    executable = "${buildDir}/native-image-tests"
}