}

    def "one thread can access state at a time"() {
        given:
        def build = build("p1")
        def project = project("p1")

        createRootProject()
        def state = registry.stateFor(projectId("p1"))
        createProject(state, project)

        when:
        async {
            workerThread {
                assert !state.hasMutableState()

        classpath.lib('baz-1.0.jar').assertIsDeployedTo('/WEB-INF/lib')
    }

    @Test
    @ToBeFixedForConfigurationCache
    void "included build"() {
        // given:
        createRootProject()
        createIncludedBuild()

        // when:
        def result = executer.withTasks("eclipse").run()

        // then:
        result.error == ""
    }

            val projectRegistry = service<ProjectStateRegistry>()
            projectRegistry.registerProjects(state, projectDescriptorRegistry)
            createRootProject()
        }

        private
        fun createRootProject() {
            val rootProject = createProject(rootProjectDescriptor())
            gradle.rootProject = rootProject
            gradle.defaultProject = rootProject
        }

@UsesNativeServices
class DefaultCppTestSuiteTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    def project = TestUtil.createRootProject(tmpDir.testDirectory)
    def testSuite = project.objects.newInstance(DefaultCppTestSuite, "test")

    def "has display name"() {
        expect:
        testSuite.displayName.displayName == "C++ test suite 'test'"

@UsesNativeServices
class DefaultCppApplicationTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    def project = TestUtil.createRootProject(tmpDir.testDirectory)
    def application = project.objects.newInstance(DefaultCppApplication, "main")

    def "has display name"() {
        expect:

@UsesNativeServices
class WrapperPluginSpec extends Specification {
    @Rule
    public final TestNameTestDirectoryProvider testDir = new TestNameTestDirectoryProvider(getClass())
    def project = TestUtil.createRootProject(testDir.testDirectory)

    def "adds 'wrapper' task"() {
        when:
        project.pluginManager.apply WrapperPlugin

        then:
        project.tasks.wrapper instanceof Wrapper

        return builder(temporaryFolder.testDirectory)
    }

    ProjectInternal rootProject() {
        createRootProject(rootDir, userHomeDir)
    }

    static ProjectInternal createRootProject(File rootDir, File userHomeDir = null) {
        def builder = ProjectBuilder
            .builder()
            .withProjectDir(rootDir)
            .withName("test-project")

@UsesNativeServices
class DefaultSwiftBinaryTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    def project = TestUtil.createRootProject(tmpDir.testDirectory)
    def implementation = Stub(ConfigurationInternal)
    def compile = Stub(Configuration)
    def link = Stub(Configuration)
    def runtime = Stub(Configuration)

@UsesNativeServices
class DefaultCppBinaryTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    def project = TestUtil.createRootProject(tmpDir.testDirectory)
    def implementation = Stub(ConfigurationInternal)
    def headerDirs = Stub(FileCollection)
    def compile = Stub(Configuration)
    def link = Stub(Configuration)

@UsesNativeServices
class DefaultNativeBinaryTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    def project = TestUtil.createRootProject(tmpDir.testDirectory)
    Configuration implementation = Stub(ConfigurationInternal)

    def "has implementation dependencies"() {
        given: