when:
        def a = source("class A { garbage }")
        runAndFail language.compileTaskName

        then:
        outputs.noneRecompiled()
        outputs.hasFiles(file("A.class"), file("B.class"))

        when:
        a.text = "class A {}"
        run language.compileTaskName

        then:
        outputs.noneRecompiled()
    }

        libObjects.noneRecompiled()
        appObjects.recompiledFile(appSourceFile)
        // Test assumes that the app has multiple source files and only one of them has changed. Verify that assumption
        appObjects.hasFiles(appSourceFile, appOtherSourceFile)

        and:
        install.assertInstalled()
        install.exec().out == "hello planet"

        when:
        run installApp

        then:

        if (user.hasRoles(getActionRoles(AdminSchedulerAction.ROLE))) {
            return AdminSchedulerAction.class;
        }
        if (user.hasRoles(getActionRoles(AdminDesignAction.ROLE))) {
            return AdminDesignAction.class;
        }
        if (user.hasRoles(getActionRoles(AdminDictAction.ROLE))) {
            return AdminDictAction.class;
        }
        if (user.hasRoles(getActionRoles(AdminAccesstokenAction.ROLE))) {

        then:
        cachedClasspath.asFiles == [cachedFile]
        cachedFile.assertIsFile()

        and:
        1 * fileAccessTimeJournal.setLastAccessTime(cachedFile.parentFile, _)
        0 * fileAccessTimeJournal._

        when:
        def cachedClasspath2 = transformer.transform(classpath, BuildLogic)

        then:
        cachedClasspath2.asFiles == [cachedFile]

        and:

        expect:
        def module = registry.getModule("gradle-some-module")
        module.implementationClasspath.asFiles == [classesDir, resourcesDir, staticResourcesDir]
        module.runtimeClasspath.asFiles == [externalRuntimeDep]

        def dep = registry.getExternalModule("dep")
        dep.implementationClasspath.asFiles == [externalRuntimeDep]
    }

        then:
        cp.asFiles == outputClassPath.asFiles
        cp.findTransformedEntryFor(file(original)) == (transformed != null ? file(transformed) : null)

        where:

        def result = dist.getToolingImplementationClasspath(progressLoggerFactory, buildProgressListener, customUserHome, cancellationToken)

        expect:
        result.asFiles.name as Set == ['gradle-core-0.9.jar', 'gradle-launcher-0.9.jar'] as Set
        (result.asFiles.path as Set).every { it.contains('customUserHome')}
    }

    def usesZipDistributionInstalledIntoSpecifiedUserHomeDirAsImplementationClasspath() {

private
fun buildOutputModel(scriptFile: File, classPath: ClassPath, sourcePath: ClassPath, implicitImports: List<String>, exceptions: List<Exception>) =
    StandardKotlinDslScriptModel(
        classPath.asFiles,
        sourcePath.asFiles,
        implicitImports,
        editorReports = emptyList(), // TODO:isolated support editor reports
        exceptions = getExceptionsForFile(scriptFile, exceptions)
    )


private

                InputNormalizer.RUNTIME_CLASSPATH,
                DirectorySensitivity.IGNORE_DIRECTORIES,
                LineEndingSensitivity.DEFAULT,
            ) { fileCollectionFactory.fixed(classPath.asFiles) }
        )
    }

    override fun visitOutputs(workspace: File, visitor: UnitOfWork.OutputVisitor) {
        val sourcesOutputDir = getSourcesOutputDir(workspace)

        val exceptions = classPathModeExceptionCollector.exceptions
        return StandardKotlinBuildScriptModel(
            (scriptClassPath + accessorsClassPath.bin).asFiles,
            (gradleSource() + classpathSources + accessorsClassPath.src).asFiles,
            project.scriptImplicitImports + additionalImports,
            buildEditorReportsFor(exceptions),
            getExceptionsForFile(exceptions, this.scriptFile),