*/

package org.gradle.internal.buildtree;

import org.gradle.api.NonNullApi;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Executes internal side effects of a build action while ensuring
 * they will be re-executed in case the build action result is loaded from cache.
 *
 * @see BuildTreeModelSideEffect
 */
@NonNullApi

}

def BreakUpIslandsPass : Pass<"tf-executor-break-up-islands", "mlir::func::FuncOp"> {
  let summary = "Transform from TF control dialect to TF executor dialect.";
  let constructor = "CreateBreakUpIslandsPass()";
  let dependentDialects = ["mlir::tf_executor::TensorFlowExecutorDialect"];
}

def SplitIntoIslandPerOpPass : Pass<"tf-executor-split-into-island-per-op", "mlir::func::FuncOp"> {

import org.gradle.integtests.fixtures.BuildOperationsFixture

class ConfigurationCacheTaskRealizationBuildOperationIntegrationTest extends AbstractConfigurationCacheIntegrationTest {
    def buildOperations = new BuildOperationsFixture(executer, testDirectoryProvider)

    def "load after store emits two realization operations with the same id"() {
        buildFile << """
            tasks.register("foo")
        """

        when:

        getOwner() >> projectState
    }
    def gradle = Mock(GradleInternal) {
        getStartParameter() >> startParameter
        getRootProject() >> project
    }

    def "executes buildSrc configuration action after projects are loaded"() {
        def action = Mock(Action)
        def listener = new BuildSrcBuildListenerFactory(action, new DefaultScriptClassPathResolver(

            tasks.register('problematic') { doLast { println project.name } }
        '''

        when:
        if (withCC) {
            configurationCacheFails ':problematic'
        } else {

    implements FileAccessTimeJournalFixture {

    @Ignore('https://github.com/gradle/gradle-private/issues/3121')
    def "cleanup deletes old entries"() {
        given:
        executer.requireIsolatedDaemons()
        writeJournalInceptionTimestamp(daysAgo(8))
        gcFile.createFile().lastModified = daysAgo(8)

        and:
        def outdated = createCacheEntryDir("outdated")

        configurationCacheRun "myTask"

        then:
        outputContains("foo")
        configurationCache.assertStateLoaded()

        when:
        def commandLineArgs = commandLine.split("\\s+")
        executer.withArguments(commandLineArgs)
        configurationCacheRun "myTask"

        then:
        outputContains("bar")

import org.gradle.integtests.fixtures.TargetVersions
import org.gradle.integtests.fixtures.configurationcache.ConfigurationCacheBuildOperationsFixture
import org.gradle.integtests.fixtures.executer.GradleExecuter
import org.gradle.util.GradleVersion

import static org.gradle.initialization.StartParameterBuildOptions.ConfigurationCacheOption.LONG_OPTION


@TargetVersions("6.5-rc-1+")

        def initScriptFile = testDirectory.file(file)
        initScriptFile << """
            ${snippets.imports}
            ${snippets.body}
        """
        executer.usingInitScript(initScriptFile)

        when:
        configurationCacheFails(":help")

        then:
        failure.assertOutputContains("Hello")
        problems.assertFailureHasProblems(failure) {

	// Creates an InitConfiguration pointing to the pkidir folder
	cfg := &kubeadmapi.InitConfiguration{
		ClusterConfiguration: kubeadmapi.ClusterConfiguration{
			CertificatesDir: tmpdir,
		},
	}

	// Executes getKubeConfigSpecs
	if _, err := getKubeConfigSpecs(cfg); err == nil {
		t.Error("getKubeConfigSpecs didnt failed when expected")
	}
}

func TestGetKubeConfigSpecs(t *testing.T) {