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"

    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
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.tasks.compile;

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

import org.apache.maven.api.annotations.Nonnull;

/**
 * Used if your Mojo needs to fork a <a href="/ref/3.0.4/maven-core/lifecycles.html">lifecycle</a>.
 *
 * @since 4.0.0
 */
@Experimental
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface Execute {
    /**
     * Lifecycle phase to fork. Note that specifying a phase overrides specifying a goal.
     * @return the phase