buildCache { ${assertValueIsSameInDays(15)} }
            }
        """

        when:
        buildFile << """
            task foo(type: Copy) {
                from 'foo'
                into layout.buildDir.dir('foo')
            }
        """
        file('foo').text = 'bar'

        then:
        succeeds("foo")
        file('build/foo/foo').text == 'bar'

        when:

                    assert foo.asFile.get().name == "foo"
                    assert bar.asFile.get().name == "bar"
                }
            }
            tasks.register("mytask", MyTask) {
                def layout = project.layout
                conventionMapping.map("foo") { $directoryExpression }
                conventionMapping.map("bar") { $fileExpression }
            }
        """

        expect:
        succeeds 'mytask'

fun generatedBinFileFor(name: String) =
    layout.buildDirectory.file("generated-resources/$name/$name.bin")

fun generatedTxtFileFor(name: String) =
    layout.buildDirectory.file("generated-resources/$name/$name.txt")

fun generatedPropertiesFileFor(name: String) =
    layout.buildDirectory.file("generated-resources/$name/$name.properties")

fun generatedJsonFileFor(name: String) =

        delegate.components(configuration)

    @Deprecated("Use layout.buildDirectory instead", ReplaceWith("layout.buildDirectory.set(path)"))
    override fun setBuildDir(path: File) {
        @Suppress("DEPRECATION")
        delegate.buildDir = path
    }

    @Deprecated("Use layout.buildDirectory instead", ReplaceWith("layout.buildDirectory.set(file(path))"))
    override fun setBuildDir(path: Any) =

    private DaemonJvmCriteria requestedJvmCriteria;

    public DaemonParameters(BuildLayoutResult layout, FileCollectionFactory fileCollectionFactory) {
        this(layout, fileCollectionFactory, Collections.<String, String>emptyMap());
    }

    public DaemonParameters(BuildLayoutResult layout, FileCollectionFactory fileCollectionFactory, Map<String, String> extraSystemProperties) {

                def consume() {
                    outputFile.get().asFile.write('42')
                }
            }

            def computeDirName = tasks.register('producer', Producer) {
                dirName = layout.buildDirectory.file('dirName.txt')
            }

            tasks.register('answer', Consumer) {
                // TODO:configuration should this `dependsOn` be necessary here?
                dependsOn 'producer'

		name          string
		printManifest bool
		wantOut       string
		wantErr       bool
	}{
		{
			name:          "do not print manifest",
			printManifest: false,
			wantOut:       "[addons] Applied essential addon: kube-proxy\n",
			wantErr:       false,
		},
		{
			name:          "print manifest",
			printManifest: true,
			wantOut: dedent.Dedent(`---
apiVersion: v1
kind: ServiceAccount

import org.gradle.initialization.BuildRequestMetaData;
import org.gradle.initialization.GradleUserHomeDirProvider;
import org.gradle.initialization.layout.BuildLayout;
import org.gradle.initialization.layout.BuildLayoutConfiguration;
import org.gradle.initialization.layout.BuildLayoutFactory;
import org.gradle.initialization.layout.ProjectCacheDir;
import org.gradle.internal.build.BuildLayoutValidator;
import org.gradle.internal.buildevents.BuildStartedTime;

 * limitations under the License.
 */

package org.gradle.internal.declarativedsl.provider

import org.gradle.api.internal.GradleInternal
import org.gradle.initialization.layout.BuildLayoutConfiguration
import org.gradle.initialization.layout.BuildLayoutFactory
import org.gradle.internal.declarativedsl.evaluator.DeclarativeKotlinScriptEvaluator
import org.gradle.internal.declarativedsl.evaluator.GradleProcessInterpretationSchemaBuilder

                @Inject abstract ProjectLayout getLayout()

                @TaskAction
                void useIt() {
                    assert foo.files == layout.files("file1", "file2").files
                    assert foo.files.size() == 2
                }
            }
            tasks.register("mytask", MyTask) {
                conventionMapping.map("foo") { bar }