assertFalse(compileOptions.parameters)
    }

    @Test
    void testFork() {
        compileOptions.fork = false
        assertNull(compileOptions.forkOptions.memoryMaximumSize)

        compileOptions.fork([memoryMaximumSize: '1g'])
        assertTrue(compileOptions.fork)
        assertEquals(compileOptions.forkOptions.memoryMaximumSize, '1g')
    }

    @Test
    void testDefine() {

        if (!forkedExecutions.isEmpty()) {
            for (Map.Entry<String, List<MojoExecution>> fork : forkedExecutions.entrySet()) {
                logger.debug("--- init fork of " + fork.getKey() + " for " + mojoExecId + " ---");

                debugDependencyRequirements(fork.getValue());

                for (MojoExecution forkedExecution : fork.getValue()) {
                    debugMojoExecution(forkedExecution);
                }

        return encoding;
    }

    public void setEncoding(String encoding) {
        this.encoding = encoding;
    }

    public boolean isFork() {
        return fork;
    }

    public void setFork(boolean fork) {
        this.fork = fork;
    }

    public boolean isKeepStubs() {
        return keepStubs;
    }

    public void setKeepStubs(boolean keepStubs) {
        this.keepStubs = keepStubs;

    doLast {
        assert System.getProperty("foo.bar") == "baz"
    }
}
        """

        expect:
        executer.withBuildJvmOpts("-Dfoo.bar=baz").withTasks("verify").run()
    }


    def "forks new daemon when file encoding set to different value via commandline"() {
        setup:
        buildScript """
            task verify {
                doFirst {

import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.Internal;
import org.gradle.api.tasks.Optional;

import javax.annotation.Nullable;
import java.io.File;

/**
 * Fork options for Java compilation. Only take effect if {@code CompileOptions.fork} is {@code true}.
 */
public abstract class ForkOptions extends ProviderAwareCompilerDaemonForkOptions {
    private static final long serialVersionUID = 0;

    private String executable;

    def "produces correct spec type" () {
        CompileOptions options = TestUtil.newInstance(CompileOptions.class, TestUtil.objectFactory())
        options.fork = fork
        options.forkOptions.executable = executable ? Jvm.current().javacExecutable.absolutePath : null
        DefaultGroovyJavaJointCompileSpecFactory factory = new DefaultGroovyJavaJointCompileSpecFactory(options, null)

 */

package org.gradle.smoketests

import org.gradle.testkit.runner.GradleRunner

class AnnotationProcessingSmokeTest extends AbstractSmokeTest {

    def 'project lombok works when options.fork=#fork'() {
        given:
        buildFile << """
            plugins {
                id("java")
            }
            ${mavenCentralRepository()}
            dependencies {

import spock.lang.Specification

class BaseForkOptionsConverterTest extends Specification {
    BaseForkOptionsConverter converter = new BaseForkOptionsConverter(TestFiles.execFactory())

    def "converts a base fork options to a java fork options"() {
        BaseForkOptions baseForkOptions = new BaseForkOptions()
        baseForkOptions.memoryInitialSize = "128m"
        baseForkOptions.memoryMaximumSize = "1g"

     */
    @Input
    public boolean isFork() {
        return fork;
    }

    /**
     * Sets whether to run the Groovy compiler in a separate process. Defaults to {@code true}.
     */
    public void setFork(boolean fork) {
        this.fork = fork;
    }

    /**

    def "forks new daemon when priority is set to a different value via command line"() {
        when:
        run("help")

        then:
        daemons.daemons.size() == 1

        when:
        executer.withArguments("--priority", "low")
        run("help")

        then:
        daemons.daemons.size() == 2
    }