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")
    }

        expect:
        def attributes = factory.of(FOO, "foo")
        factory.of(FOO, "foo").is(attributes)
        factory.of(FOO, "other") != attributes
        factory.of(BAR, "foo") != attributes
    }

    def "can concatenate immutable attributes sets"() {
        when:
        def set1 = factory.of(FOO, "foo")
        def set2 = factory.of(BAR, "bar")
        def union = factory.concat(set1, set2)

        then:

     * @param type the type of objects created by the factory
     * @param factory the factory to register
     * @param <U> the type of objects created by the factory
     *
     * @throws IllegalArgumentException if the specified type is not a subtype of the container element type
     */
    @Override
    <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory);

    /**

        }
    }

    def "attaches current running operation as parent when operation is started"() {
        given:
        def completed = factory.newOperation("category").setDescription("ignore-me")
        def child = factory.newOperation("category").setDescription("child")
        def parent = factory.newOperation("category").setDescription("parent")
        def parentId

        completed.started()
        completed.completed()

    @Override
    public <T> T whileDisallowingProjectLockChanges(Factory<T> action) {
        return registries.get().getProjectLockRegistry().whileDisallowingLockChanges(action);
    }

    @Override
    public <T> T allowUncontrolledAccessToAnyProject(Factory<T> factory) {
        return registries.get().getProjectLockRegistry().allowUncontrolledAccessToAnyResource(factory);
    }

    @Override

        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>>();

	"istio.io/istio/pkg/kube"
)

type Factory struct {
	kube.PartialFactory
	full util.Factory
}

func (f Factory) NewBuilder() *resource.Builder {
	return f.full.NewBuilder()
}

func (f Factory) ClientForMapping(mapping *meta.RESTMapping) (resource.RESTClient, error) {
	return f.full.ClientForMapping(mapping)
}

    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: