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

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.infra.Blackhole;

 * limitations under the License.
 */

package org.gradle.caching.internal.tasks;

import org.apache.commons.io.FileUtils;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;

import org.junit.Assume

import static org.gradle.util.internal.TextUtil.normaliseFileSeparators

class DaemonGroovyCompilerIntegrationTest extends AbstractApiGroovyCompilerIntegrationSpec {
    def "respects fork options settings and ignores executable"() {
        Jvm differentJvm = AvailableJavaHomes.differentJdkWithValidJre
        Assume.assumeNotNull(differentJvm)

func runtime_AfterFork()
func runtime_AfterForkInChild()

// Fork, dup fd onto 0..len(fd), and exec(argv0, argvv, envv) in child.
// If a dup or exec fails, write the errno error to pipe.
// (Pipe is close-on-exec so if exec succeeds, it will be closed.)
// In the child, this function must not acquire any locks, because
// they might have been locked at the time of the fork. This means
// no rescheduling, no malloc calls, and no new stack segments.

            plugins {
                id 'java'
            }

            ${dependsOnPidCapturingAnnotationProcessor}

            tasks.withType(JavaCompile).configureEach {
                options.fork = true
            }
        """
        file('src/main/java/Foo.java') << """
            @WorkerPid
            public class Foo {
                public static void main(String[] args) {

    - cron: 0 4 * * *  # 4am UTC is 9pm PDT and 8pm PST
name: Set nightly branch to master HEAD

permissions: {}

jobs:
  master-to-nightly:
    if: github.repository == 'tensorflow/tensorflow' # Don't do this in forks
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
    - uses: zofrex/mirror-branch@a8809f0b42f9dfe9b2c5c2162a46327c23d15266 # v1.0.3
      name: Set nightly branch to master HEAD
      with:

                apply plugin:'groovy'
                dependencies{
                    implementation localGroovy()
                }
                compileGroovy{
                    options.fork = ${forkMode}
                }
                """
        when:
        executer.withJavaHome(jreJavaHome.absolutePath).withTasks("compileGroovy").run().output
        then:

                <td><literal>true</literal></td>
            </tr>
            <tr>
                <td>debugOptions</td>
                <td></td>
            </tr>
            <tr>
                <td>fork</td>
                <td><literal>false</literal></td>
            </tr>
            <tr>
                <td>forkOptions</td>
                <td></td>
            </tr>
            <tr>

            options.fork = true
            options.incremental = true
            options.forkOptions.memoryInitialSize = compilerMemory
            options.forkOptions.memoryMaximumSize = compilerMemory
            options.forkOptions.jvmArgs.addAll(javaCompileJvmArgs)
        }

        tasks.withType(GroovyCompile).configureEach {
            groovyOptions.fork = true

subprojects {
    apply plugin: "groovy"

    dependencies {
        implementation localGroovy()
    }

    compileJava.options.fork = true

    // force creation of multiple daemons for Java compilation by alternating between two distinct sets of JVM args
    def count = (project.name - "project") as int
    compileJava.options.forkOptions.jvmArgs = count % 2 ? ["-dsa"] : ["-esa"]