}

    def "cannot read from file after lock has been closed"() {
        given:
        def lock = createLock(Exclusive)
        lock.close()

        when:
        lock.readFile({} as Supplier)

        then:
        thrown(IllegalStateException)
    }

    def "cannot write to file after lock has been closed"() {
        given:
        def lock = createLock(Exclusive)

    def dependencyMetadataFactory = Mock(DependencyMetadataFactory)
    def excludeRuleConverter = Mock(ExcludeRuleConverter)
    def converter = new DefaultLocalConfigurationMetadataBuilder(dependencyMetadataFactory, excludeRuleConverter)

    def configuration = Mock(ConfigurationInternal)
    def dependencySet = Mock(DependencySet)
    def dependencyConstraintSet = Mock(DependencyConstraintSet)

            }
        }
        def extractor = new DefaultModelSchemaExtractor([strategy])
        def store = new DefaultModelSchemaStore(extractor)

        then:
        store.getSchema(CustomThing) instanceof ScalarValueSchema
    }

    def "custom strategy can register dependency on other type"() {
        def strategy = Mock(ModelSchemaExtractionStrategy)

        def publication = Mock(ProjectComponentPublication)
        publication.name >> name
        publication.displayName >> Describables.of("publication '" + name + "'")
        publication.getCoordinates(ModuleVersionIdentifier) >> DefaultModuleVersionIdentifier.newId(group, module, version)
        publication.component >> Providers.ofNullable(component)
        return publication

import org.junit.Rule
import spock.lang.Specification

class ToolSearchPathTest extends Specification {
    @Rule def TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    def os = Stub(OperatingSystem)
    def registry = new ToolSearchPath(os)

    def "finds executable in system path"() {
        def file = tmpDir.createFile("cc.bin")

        given:
        os.getExecutableName("cc") >> "cc.bin"

    }

    def canConstructInstanceOfInterfaceWithFileTreeGetter() {
        def projectDir = tmpDir.testDirectory
        def a = projectDir.file("dir/a").createFile()
        def b = projectDir.file("dir/sub/a").createFile()
        def bean = create(InterfaceFileTreeBean)

        expect:
        bean.prop.from("dir")
        bean.prop.files == [a, b] as Set
    }

        return new ManagedFactories.ProviderManagedFactory()
    }

    def "runs side effect when calling '#method' on changing provider"() {
        given:
        def sideEffect = Mock(ValueSupplier.SideEffect)
        def counter = new AtomicInteger(23)
        def parent = Providers.changing { counter.getAndIncrement() }
        def provider = parent.withSideEffect(sideEffect)

        when:

  ]
}
"""
    }

    def "writes file with component that has children published in other modules"() {
        def writer = new StringWriter()
        def rootComponent = Stub(TestComponent)
        def rootPublication = publication(rootComponent, id)

        def id1 = DefaultModuleVersionIdentifier.newId("group", "other-1", "1")
        def comp1 = Stub(TestComponent)
        def publication1 = publication(comp1, id1)

        def b = fileResolver.resolving(["b"]).asFileTree
        def composite = newCompositeFileTree([a, b])

        then:
        composite.files == [a1, b1].toSet()
    }

    def "can visit all files"() {
        given:
        def a1 = file("a/1.txt") << "a/1"
        def b1 = file("b/1.txt") << "b/1"
        def fileResolver = TestFiles.fileCollectionFactory(testDirectory)

    def execActionFactory = Mock(ExecActionFactory)
    def execAction = Mock(ExecAction)
    def execResult = Mock(ExecResult)
    def factory = new CompilerMetaDataProviderFactory(execActionFactory)

    def "caches result of actual #compiler metadata provider"() {
        def binary = new File("any")
        when: