def model2 = runBuildAction(new FetchCustomModelForEachProject())

        then:
        model2.size() == 2
        model2[0].message == "It works from project :"
        model2[1].message == "It works from project :a"

        and:
        fixture.assertStateLoaded()

        when:
        settingsFile << """
            println("some new stuff")
        """

        DefaultManifest manifest = new DefaultManifest(fileResolver).attributes(key1: 'value1')
        fileResolver.resolve('file') >> manifestFile

        when:
        manifest.writeTo('file')
        Manifest fileManifest = manifestFile.withReader { new Manifest(it) }
        Manifest expectedManifest = new Manifest()
        expectedManifest.addConfiguredAttribute(new Attribute('key1', 'value1'))

            .visualCppDir(new File(dir, "VC"))
            .visualCppVersion(VersionNumber.parse(version))
            .build()
    }

    VisualCppInstallCandidate visualCppMetadata(File dir) {
        return new VisualCppInstallCandidate() {
            @Override
            File getVisualCppDir() {
                return new File(dir, "VC/Tools/MSVC/1.2.3.4")
            }

            @Override

        same.url = new URI("http://localhost")
        same.artifactUrls(new URI("http://localhost/dir"))
        different.url = new URI("http://localhost")

        and:
        _ * resolver.resolveUri(_) >> { URI uri -> uri }

        expect:
        same.descriptor.id == repo.descriptor.id
        different.descriptor.id != repo.descriptor.id

        when:

    }

    static CalculatedValueContainerFactory calculatedValueContainerFactory() {
        return new CalculatedValueContainerFactory(new TestWorkerLeaseService(), services())
    }

    static StateTransitionControllerFactory stateTransitionControllerFactory() {
        return new StateTransitionControllerFactory(new TestWorkerLeaseService())
    }

        def name = new ExternalResourceName(URI.create("http://host"), "a/b/c")
        def same = new ExternalResourceName(URI.create("http://host"), "a/b/c")
        def samePath = new ExternalResourceName(URI.create("http://host/a/b"), "c")
        def differentRoot = new ExternalResourceName(URI.create("http://other"), "a/b/c")
        def differentPath = new ExternalResourceName(URI.create("http://host"), "x/y/z")

import static org.gradle.internal.work.AsyncWorkTracker.ProjectLockRetention.RETAIN_PROJECT_LOCKS

class DefaultAsyncWorkTrackerTest extends ConcurrentSpec {
    WorkerLeaseService workerLeaseService = new TestWorkerLeaseService()
    AsyncWorkTracker asyncWorkTracker = new DefaultAsyncWorkTracker(workerLeaseService)

    def "can wait for async work to complete"() {
        def operation = Mock(BuildOperationRef)

        when:
        async {

        tmpDir.createDir("externalDependencyContents").zipTo(externalDependency)
    }

    def "locates module using jar in distribution image"() {
        given:
        def registry = new DefaultModuleRegistry(classLoaderFor([]), ClassPath.EMPTY, new GradleInstallation(distDir))

        expect:
        def module = registry.getModule("gradle-some-module")
        module.implementationClasspath.asFiles == [jarFile]

                    // Exception's toString() throws an exception
                    throw new BrokenRuntimeException();
                }

                private static class BrokenRuntimeException extends RuntimeException {
                    @Override
                    public String toString() {
                        throw new UnsupportedOperationException();
                    }
                }
            }

            import org.gradle.api.*
            import org.gradle.api.tasks.*

            class MyTask extends DefaultTask {
                @Nested
                Tree tree = new Tree(
                        left: new Tree([:]),
                        right: new Tree([:])
                    )

                public static class Tree {
                    @Optional @Nested
                    Tree left