c, _ := istio.DefaultConfig(ctx)
			return c.EnableCNI
		}).
		SetupParallel(
			namespace.Setup(&userGroup1NS, namespace.Config{Prefix: "usergroup-1", Labels: map[string]string{"usergroup": "usergroup-1"}}),
			namespace.Setup(&userGroup2NS, namespace.Config{Prefix: "usergroup-2", Labels: map[string]string{"usergroup": "usergroup-2"}})).
		Setup(istio.Setup(nil, func(ctx resource.Context, cfg *istio.Config) {
			s := ctx.Settings()

        setup:
        file("src/main/groovy/Person.groovy") << """
            @Grab(group='commons-lang', module='commons-lang', version='2.4')
            class Person { }
        """

        expect:
        succeeds 'compileGroovy'
    }

    def "Dependencies defined @Grab annotation are not present on the classpath"() {
        setup:
        file("src/main/groovy/Person.groovy") << """

    @Rule
    public final TestResources testResources = new TestResources(testDirectoryProvider)

    @ToBeFixedForConfigurationCache
    def "Source set defined on dependencies"() {
        setup:
        buildFile << """
            apply plugin: 'java'
            apply plugin: 'eclipse'

            ${mavenCentralRepository()}

            dependencies {

    String artifactVersion = "1.45-SNAPSHOT"
    MavenGcsModule module

    def setup() {
        module = getMavenGcsRepo().module("org.gradle", "test", artifactVersion)
    }

    def "resolves a maven snapshot module stored in Gcs"() {
        setup:
        module.publish()

        buildFile << mavenGcsRepoDsl()
        buildFile << """
configurations { compile }

    }
    File gitignoreFile = tmpDir.file(".gitignore")

    def setup() {
        Directory target = Mock()
        RegularFile ignoreFile = Mock()
        1 * settings.target >> target
        1 * target.file('.gitignore') >> ignoreFile
        1 * ignoreFile.asFile >> gitignoreFile
    }

    def "generates .gitignore file"() {
        setup:
        def generator = new GitIgnoreGenerator()

        when:

    @TempDir File testProjectDir
    File settingsFile
    File buildFile

    def setup() {
        settingsFile = new File(testProjectDir, 'settings.gradle')
        buildFile = new File(testProjectDir, 'build.gradle')
    }

    // tag::functional-test-classpath-setup-automatic[]
    def "hello world task prints hello world"() {
        given:

      return Collections.<Class<? extends AbstractTester>>singletonList(MyTester.class);
    }
  }

  public void testLifecycle() {
    boolean[] setUp = {false};
    Runnable setUpRunnable =
        new Runnable() {
          @Override
          public void run() {
            setUp[0] = true;
          }
        };

    boolean[] tearDown = {false};
    Runnable tearDownRunnable =
        new Runnable() {

        platform: [ ubuntu-latest ]
    runs-on: ${{ matrix.platform }}

    steps:
      - name: Setup TiDB
        uses: Icemap/tidb-action@main
        with:
          port: 9940
          version: ${{matrix.dbversion}}

      - name: Set up Go 1.x
        uses: actions/setup-go@v4
        with:
          go-version: ${{ matrix.go }}

      - name: Check out code into the Go module directory

class ResolvedGeneratedJarsIntegrationTest extends BaseGradleImplDepsTestCodeIntegrationTest {

    def setup() {
        executer.requireOwnGradleUserHomeDir()
        buildFile << testablePluginProject(['java-gradle-plugin'])
    }

    def "gradle api jar is generated only when requested"() {
        setup:
        productionCode()

        def version = distribution.version.version

        """

        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 {
                    println "verified = " + java.nio.charset.Charset.defaultCharset().name()
                }
            }
        """