given:
        executer.requireOwnGradleUserHomeDir()

        and:
        file("buildSrc/settings.gradle").createFile()

        and:
        executer.gradleUserHomeDir.file('init.d/a.gradle') << '''
            gradle.addListener(new BuildAdapter() {
                void projectsLoaded(Gradle gradle) {

        !output.contains("Configuration cache is an incubating feature.")
    }

    def "configuration cache for Help plugin task '#task' on empty project"() {
        given:
        settingsFile.createFile()
        configurationCacheRun(task, *options)
        def firstRunOutput = removeVfsLogOutput(result.normalizedOutput)

		},
	}

	type args struct {
		kubeadmConfig *kubeadmapi.InitConfiguration
		cert          *KubeadmCert
	}
	tests := []struct {
		name       string
		args       args
		wantErr    bool
		createfile bool
	}{
		{
			name: "kubeadmConfig is nil",
			args: args{
				kubeadmConfig: nil,
				cert:          validKubeadmCert,
			},
			wantErr: true,
		},
		{
			name: "cert is nil",

            file("$it/api/src/main/java/org/gradle/api/GradleException.java") << "package org.gradle.api; public class GradleException {}"
            file("$it/animals/src/main/java/test/gradle/test/Dogs.java").createFile().text = """
                package test.gradle.test;
                import org.gradle.api.*;

                class GermanShepherd extends Dog implements Animal {
                    public void plugin() {

        given:
        buildFile << declareAttributes() << multiProjectWithJarSizeTransform(incremental: true) << withClassesSizeTransform() << withFileLibDependency()

        file("lib/dir1.classes").file("child").createFile()

        when:
        succeeds ":util:resolve", ":app:resolve"

        then:
        output.count("files: [dir1.classes.dir, lib1.jar.txt]") == 2

        output.count("Transformed") == 2

        val project = contextFile.project

        val dummyFile = KtPsiFactory
            .contextual(contextFile, markGenerated = false, eventSystemEnabled = false)
            .createFile("dummy.kt", "fun usage() { test() }")

        assert(dummyFile.virtualFile == null)

        val dummyModule = ProjectStructureProvider.getModule(project, dummyFile, contextualModule = null)

                dependencySubstitution {
                    substitute(module("none:none:infinity")).using(project(":"))
                }
            }
        """
        file("unused/settings.gradle").createFile()

        when:
        configurationCacheRun 'help'

        then:
        hasOperationsForStoreAndLoad()
        hasCompositeWithUnusedBuildIdentified()

            }
        """
        bar.buildFile << """
            ${zipTaskConfiguration}
        """
        bar.projectDir.createDir('inputFiles').createFile('bar.txt')

        when:
        args '--parallel', '--max-workers=2'
        succeeds(generate.path, clean.path)

        then:

	// Create a file whose name contains unpaired surrogates.
	// Use syscall.CreateFile instead of os.Create to simulate a file that is created by
	// a non-Go program so the file name hasn't gone through syscall.UTF16FromString.
	dirw := utf16.Encode([]rune(dir))
	pathw := append(dirw, namew...)
	fd, err := syscall.CreateFile(&pathw[0], syscall.GENERIC_ALL, 0, nil, syscall.CREATE_NEW, 0, 0)
	if err != nil {
		t.Fatal(err)

				EnvoyStatusPort:     15021,
			})
			if err != nil {
				t.Fatal(err)
			}
			fn, err := New(Config{
				Node:             node,
				CompliancePolicy: c.compliancePolicy,
			}).CreateFile()
			if err != nil {
				t.Fatal(err)
			}

			read, err := os.ReadFile(fn)
			if err != nil {
				t.Error("Error reading generated file ", err)
				return
			}