get() = startParameter.isConfigurationCacheRecreateCache

    /**
     * See [StartParameter.getProjectDir].
     */
    val projectDirectory: File?
        get() = startParameter.projectDir

    val currentDirectory: File
        get() = startParameter.currentDir

    val settingsDirectory: File
        get() = buildLayout.settingsDir

    @Suppress("DEPRECATION")

                id('java-library')
            }
            allprojects {
                println("project name = " + name)
                println("project path = " + path)
                println("project projectDir = " + projectDir)
                println("project rootDir = " + rootDir)
                println("project toString = " + it)
                it.name
                project.name
                project.path

        given:
        goodCode()

        and:
        buildFile << """
            dependencies {
                file("\$projectDir/lib/").mkdirs()
                implementation files((1..999).collect {
                    createJarFile("\$projectDir/lib/library\${it}.jar")
                })
            }

            def createJarFile(String libraryPath) {
                def fos

                dependencies {
                    compile project(':util')
                }
            }
        """ << withFileLibDependency("lib1.jar", projectDir)
        projectDir.createDirs("lib", "util", "app")
        projectDir.file("settings.gradle") << """
            rootProject.name = 'root'
            include 'lib'
            include 'util'
            include 'app'
        """
    }

include('p1')
include('p1:p11')
includeBuild('another')"""
        file("p1").mkdir()
        file('another/settings.gradle') << ""

        when:
        projectDir("p1")
        run "projects"

        then:
        outputDoesNotContain "another"
    }

    def "included builds are only rendered if there are some"() {
        when:
        run "projects"

        task.classpath.files == project.sourceSets.test.runtimeClasspath.files
        task.testClassesDirs.contains(project.sourceSets.test.java.destinationDirectory.get().asFile)
        task.workingDir == project.projectDir
    }

    def "applies mappings to tasks added by the build script"() {
        given:
        project.pluginManager.apply(JavaPlugin)

        when:

        '''
            task fooJar(type: Jar) {
                archiveBaseName = 'c-foo'
                destinationDirectory = projectDir
            }
            task barJar(type: Jar) {
                archiveBaseName = 'c-bar'
                destinationDirectory = projectDir
            }
            artifacts {
                foo fooJar
                bar barJar
            }
        '''
    }

    public abstract val symbol: KaTypeParameterSymbol
}

public typealias KtTypeParameterType = KaTypeParameterType

public abstract class KaCapturedType : KaType {
    public abstract val projection: KaTypeProjection
}

public typealias KtCapturedType = KaCapturedType

public abstract class KaDefinitelyNotNullType : KaType {
    public abstract val original: KaType

            "Resource": "arn:aws:s3:::*"
        },
        {
            "Effect": "Allow",
            "Action": "s3:*",
            "Resource": [
                "arn:aws:s3:::projectaorb",
                "arn:aws:s3:::projectaorb/*"
            ],
            "Condition": {
                "ForAnyValue:StringEquals": {
                    "jwt:groups": [
                        "projecta",

	if err != nil {
		klog.Errorf("Error writing payload to dir: %v", err)
		return err
	}

	setupSuccess = true
	return nil
}

// MakePayload function is exported so that it can be called from the projection volume driver
func MakePayload(mappings []v1.KeyToPath, secret *v1.Secret, defaultMode *int32, optional bool) (map[string]volumeutil.FileProjection, error) {
	if defaultMode == nil {