}

    def cleanupSpec() {
        jdkRepository.stop()
    }

    def setup() {
        jdkRepository.reset()

        executer.requireOwnGradleUserHomeDir()
            .withToolchainDownloadEnabled()
    }

    def cleanup() {
        executer.gradleUserHomeDir.file("jdks").deleteDir()
    }

    def "multiple subprojects with identical toolchain definitions"() {
        given:

        assertTwoCompilerDaemonsAreRunning()

        when:
        executer.withWorkerDaemonsExpirationDisabled()
        succeeds("clean", "compileAll", "--info")

        then:
        executedAndNotSkipped "${compileTaskPath('main')}", "${compileTaskPath('main2')}"

        and:

import org.gradle.integtests.fixtures.ToBeFixedForIsolatedProjects
import spock.lang.Issue

import static org.gradle.integtests.fixtures.executer.GradleContextualExecuter.isConfigCache
import static org.gradle.integtests.fixtures.executer.GradleContextualExecuter.isNotConfigCache

/**
 * Tests build cache configuration within composite builds and buildSrc.
 */

import org.jetbrains.kotlin.analysis.project.structure.KtModuleStructureInternals
import org.jetbrains.kotlin.analysis.project.structure.withDanglingFileResolutionMode
import org.jetbrains.kotlin.psi.KtElement

/**
 * Executes the given [action] in a [KaSession] context.
 *
 * The project will be analyzed from the perspective of [useSiteKtElement]'s module, also called the use-site module.
 *
 * @see KaSession
 */

 * limitations under the License.
 */

package org.gradle.integtests.tooling.r33

import org.gradle.integtests.fixtures.executer.GradleBackedArtifactBuilder
import org.gradle.integtests.fixtures.executer.GradleDistribution
import org.gradle.integtests.fixtures.executer.NoDaemonGradleExecuter
import org.gradle.integtests.tooling.fixture.TargetGradleVersion
import org.gradle.integtests.tooling.fixture.ToolingApiSpecification

		<module>fess-crawler-es</module>
	</modules>
	<build>
		<pluginManagement>
			<plugins>
				<plugin>
					<groupId>org.apache.maven.plugins</groupId>
					<artifactId>maven-shade-plugin</artifactId>
					<executions>
						<execution>
							<phase>package</phase>
							<goals>
								<goal>shade</goal>
							</goals>
							<configuration>
								<artifactSet>
									<includes>

// RUN: tf-tfrt-opt -tf-executor-to-tfrt-pipeline=decompose-resource-ops=true %s | FileCheck %s --dump-input=fail

module attributes {tf.versions = {bad_consumers = [], min_consumer = 12 : i32, producer = 293 : i32}} {

// CHECK-LABEL: func @gather
// CHECK-SAME: ([[in_chain:%.*]]: !tfrt.chain
// CHECK-SAME: [[arg0:%.*]]: !tfrt_fallback.tf_tensor, [[arg1:%.*]]: !tfrt_fallback.tf_tensor)
// CHECK: [[const:%.*]] = tfrt_fallback_async.const_dense_tensor

                    languageVersion = JavaLanguageVersion.of(${majorVersion})
                }
            }
        """
    }

    AbstractIntegrationSpec withAutoDetection() {
        executer.withArgument("-Porg.gradle.java.installations.auto-detect=true")
        return this as AbstractIntegrationSpec
    }

    /**
     * Usage:
     * <pre>
     *     def jvm1 = Jvm.current()

// Swap atomically stores new into x and returns the previous value.
func (x *Bool) Swap(new bool) (old bool) { return SwapUint32(&x.v, b32(new)) != 0 }

// CompareAndSwap executes the compare-and-swap operation for the boolean value x.
func (x *Bool) CompareAndSwap(old, new bool) (swapped bool) {
	return CompareAndSwapUint32(&x.v, b32(old), b32(new))
}

// b32 returns a uint32 0 or 1 representing b.

        targetDir = containerDir.createDir("some-thing")
        subprojectDir = subprojectName() ? targetDir.file(subprojectName()) : targetDir
        executer.beforeExecute {
            executer.inDirectory(targetDir)
            executer.ignoreMissingSettingsFile()
        }
    }

    @Override
    void useTestDirectoryThatIsNotEmbeddedInAnotherBuild() {