class FactoriesTest extends Specification {
    def "factory runs given runnable and returns null"() {
        Runnable r = Mock()
        Factory<String> factory = Factories.toFactory(r)

        when:
        def result = factory.create()

        then:
        result == null

        and:
        1 * r.run()
        0 * r._
    }

    def "factory gets cached"() {
        given:

        factory.path(subDir) == factory.path("file://${relpath(childFile)}/../..")
        factory.path("file://${relpath(subDir)}") != factory.path("file://${relpath(childFile)}")

        // Using absolute paths
        factory.path(subDir) == factory.path("file://${subDir.absolutePath}")

        // Using replacement variables

    def "returns a factory for a given type"() {
        def fooFactory = factory(Foo)
        def buzzFactory = factory(Buzz)
        registry.withFactories(buzzFactory, fooFactory)

        expect:
        registry.lookup(fooFactory.id) == fooFactory
    }

    def "returns null for unknown type"() {
        def fooFactory = factory(Foo)
        def barFactory = factory(Bar)
        def buzzFactory = factory(Buzz)

        n2.toString() == "b"

        n1.is(factory.named(CustomNamed, "a"))
        n2.is(factory.named(CustomNamed, "b"))

        !n1.is(factory.named(Named, "a"))
        !n2.is(factory.named(Named, "b"))

        n1 instanceof Managed
    }

    def "can unpack and recreate instance of subtype of Named"() {
        expect:
        def n1 = factory.named(CustomNamed, "a")
        n1 instanceof Managed

        cleanup:
        factory.close()
    }

    void "can visit all caches created by factory"() {
        def visited = [] as Set

        when:
        factory.open(tmpDir.testDirectory.file('foo'), "foo", [prop: 'value'], mode(Shared), null, null)
        factory.open(tmpDir.testDirectory.file('bar'), "bar", [prop: 'value'], mode(Shared), null, null)

        expect:
        factory.windows == factory.windows
        factory.linux == factory.linux
        factory.macOS == factory.macOS
        factory.windows.x86 == factory.windows.x86
        factory.linux.x86_64 == factory.linux.x86_64
        factory.windows.architecture("arm") == factory.windows.architecture("arm")
        factory.os("fushia").architecture("arm") == factory.os("fushia").architecture("arm")
    }

        def same = factory.createResolvedDependency(selector('requested'), fromModule, selectedModule, variant, false)

        def differentRequested = factory.createResolvedDependency(selector('xxx'), fromModule, selectedModule, variant, false)
        def differentFrom = factory.createResolvedDependency(selector('requested'), newModule('xxx'), selectedModule, variant, false)

        this.method = method;
        this.factory = factory;
    }

    @Override
    public R invoke(Object... args) {
        I instance = Modifier.isStatic(method.getModifiers()) ? null : factory.create();
        return method.invoke(instance, args);
    }

                return item;
            }
        };
    }

    public static <T> Factory<T> softReferenceCache(Factory<T> factory) {
        return new CachingSoftReferenceFactory<T>(factory);
    }

    private static class CachingSoftReferenceFactory<T> implements Factory<T> {
        private final Factory<T> factory;
        private final AtomicReference<SoftReference<T>> cachedReference = new AtomicReference<SoftReference<T>>();

    def "does not query factory until necessary"() {
        given:
        def factory = Mock(Factory)

        when:
        def candidates = new LazyLocallyAvailableResourceCandidates(factory, TestUtil.checksumService)

        then:
        0 * factory.create()

        when:
        def isNone = candidates.isNone()

        then: