long lastCleanupCheck = initializeHome()

        when:
        def newTrashFile = temporaryFolder.file("0" * hashStringLength).createFile()
        def oldTrashFile = temporaryFolder.file("1" * hashStringLength).createFile()
        createBuildCacheEntry("0" * hashStringLength, newTrashFile, System.currentTimeMillis())

            modelsCreated(":")
        }
        outputContains("creating model for root project 'root'")

        when:
        executer.withArguments(ENABLE_CLI)
        def model2 = fetchModel()

        then:
        model2.message == "It works from project :"

        and:
        fixture.assertStateLoaded()
        outputDoesNotContain("creating model")

        when:
        buildFile << """

        """
        buildFile << """
            apply plugin: 'cpp-application'
        """
        def headerDir = file('src/main/headers')
        def src1 = file('src/main/cpp/app.cpp').createFile()
        def src2 = file('src/main/cpp/app-impl.cpp').createFile()

        when:
        def project = withConnection { connection -> connection.getModel(CppProject.class) }

        then:
        project.projectIdentifier.projectPath == ':'

        parameter.allInitScripts.empty

        when:
        def userMainInit = gradleUserHomeDir.createFile("init.gradle")
        then:
        parameter.allInitScripts == [userMainInit]

        when:
        def userInit1 = gradleUserHomeDir.createFile("init.d/1.gradle")
        def userInit2 = gradleUserHomeDir.createFile("init.d/2.gradle")

        then:

        given:
        def uppercaseDir = file('DIR')
        def lowercaseDir = file('dir').create {
            file('file.txt').createFile()
            nestedDir {
                file('nestedDirFile1.txt').createFile()
                file('nestedDirFile2.txt').createFile()
            }
        }
        buildFile << '''
            task syncIt(type: Sync) {

            }
        '''
        ArtifactBuilder builder = artifactBuilder()
        File jarFile = file("repo/test-1.3-BUILD-SNAPSHOT.jar")

        when:
        builder.sourceFile("org/gradle/test/BuildClass.java").createFile().text = '''
            package org.gradle.test;
            public class BuildClass {
                public String message() { return "hello world"; }
            }
        '''
        builder.buildJar(jarFile)

====


== Creating tasks

Creating tasks can be done using the script top-level function named `task(...)`:

.Using the top-level `tasks(...)` function
====
include::sample[dir="snippets/kotlinDsl/creating-tasks-project/kotlin",files="build.gradle.kts[]"]
include::sample[dir="snippets/kotlinDsl/creating-tasks-project/groovy",files="build.gradle[]"]
====

	spdyLocation, err := url.Parse(spdyServer.URL)
	if err != nil {
		t.Fatalf("Unable to parse spdy server URL: %s", spdyServer.URL)
	}
	spdyTransport, err := fakeTransport()
	if err != nil {
		t.Fatalf("Unexpected error creating transport: %v", err)
	}
	streams := Options{Stdin: true, Stdout: true}
	streamTranslator := NewStreamTranslatorHandler(spdyLocation, spdyTransport, 0, streams)

}

func (f *fixture) run_(ctx context.Context, deploymentName string, startInformers bool, expectError bool) {
	c, informers, err := f.newController(ctx)
	if err != nil {
		f.t.Fatalf("error creating Deployment controller: %v", err)
	}
	if startInformers {
		stopCh := make(chan struct{})
		defer close(stopCh)
		informers.Start(stopCh)
	}

	err = c.syncDeployment(ctx, deploymentName)

		// is more readable.
		workDir = path.Join(s.settings.RunDir(), id, "_test_context")
	}
	if err := os.MkdirAll(workDir, os.ModePerm); err != nil {
		goTest.Fatalf("Error creating work dir %q: %v", workDir, err)
	}

	scopes.Framework.Debugf("Creating new testContext: %q", id)

	if parentScope == nil {
		parentScope = s.globalScope
	}

	scopeID := fmt.Sprintf("[%s]", id)
	ctx := &testContext{
		id:         id,