}

    @Override
    protected Set<String> toMutable(Collection<String> values) {
        return new LinkedHashSet<String>(values)
    }

    @Override
    ManagedFactory managedFactory() {
        return new ManagedFactories.SetPropertyManagedFactory(TestUtil.propertyFactory())
    }

    def "discards duplicates values and retains iteration order of added elements"() {
        given:

    private final DefaultInstantiationScheme injectOnlyLenientScheme;
    private final DefaultInstantiationScheme decoratingScheme;
    private final DefaultInstantiationScheme decoratingLenientScheme;
    private final ManagedFactory managedFactory;

    public DefaultInstantiatorFactory(CrossBuildInMemoryCacheFactory cacheFactory, List<InjectAnnotationHandler> injectHandlers, PropertyRoleAnnotationHandler roleAnnotationHandler) {

        return baseDirectory.dir("other3").get()
    }

    @Override
    PropertyInternal<Directory> propertyWithNoValue() {
        return factory.newDirectoryProperty()
    }

    @Override
    ManagedFactory managedFactory() {
        new ManagedFactories.DirectoryPropertyManagedFactory(factory)
    }

    def "can view directory as a file tree"() {
        given:
        def dir1 = baseDir.createDir("dir1")

    }

    @Override
    String someOtherValue2() {
        return "other2"
    }

    @Override
    String someOtherValue3() {
        return "other3"
    }

    @Override
    ManagedFactory managedFactory() {
        return new ManagedFactories.ProviderManagedFactory()
    }

    def "toString() does not realize value"() {
        given:
        def providerWithBadValue = new DefaultProvider<String>({

import org.gradle.api.file.ConfigurableFileCollection;
import org.gradle.api.internal.file.FileCollectionFactory;
import org.gradle.internal.state.ManagedFactory;

import javax.annotation.Nullable;

public class ManagedFactories {
    public static class ConfigurableFileCollectionManagedFactory implements ManagedFactory {
        private static final Class<?> PUBLIC_TYPE = ConfigurableFileCollection.class;

    }

    @Override
    String someOtherValue2() {
        "{other2}"
    }

    @Override
    String someOtherValue3() {
        "{other3}"
    }

    @Override
    ManagedFactory managedFactory() {
        return new ManagedFactories.ProviderManagedFactory()
    }

    static class MappingProviderCircularFunctionEvaluationTest extends CircularFunctionEvaluationSpec<String> {
        @Override

        then:
        def e = thrown(IllegalArgumentException)
        e.message.matches("A managed factory with type [^\\s]+ \\(id: [^\\s]+\\) has already been registered.")
    }

    ManagedFactory factory(Class<?> type) {
        return Stub(ManagedFactory) {
            _ * getId() >> Objects.hashCode(type.name)
        }
    }

    static interface Foo { }

    static interface Bar extends Foo { }

 */

package org.gradle.internal.snapshot.impl;

import org.gradle.internal.hash.Hasher;
import org.gradle.internal.snapshot.ValueSnapshot;
import org.gradle.internal.state.Managed;
import org.gradle.internal.state.ManagedFactory;
import org.gradle.internal.state.ManagedFactoryRegistry;

import javax.annotation.Nullable;

public class IsolatedImmutableManagedValue extends AbstractIsolatableScalarValue<Managed> {

        val factoryId = readSmallInt()
        val state = readNonNull<Isolatable<Any>>()
        return IsolatedManagedValue(targetType, managedFactory.lookup(factoryId), state)
    }
}


class IsolatedImmutableManagedValueCodec(private val managedFactory: ManagedFactoryRegistry) : Codec<IsolatedImmutableManagedValue> {
    override suspend fun WriteContext.encode(value: IsolatedImmutableManagedValue) {

    }

    @Override
    Integer someOtherValue2() {
        return 146
    }

    @Override
    Integer someOtherValue3() {
        return 1024
    }

    @Override
    ManagedFactory managedFactory() {
        return new ManagedFactories.ProviderManagedFactory()
    }

    def "runs side effect when calling '#method' on changing provider"() {
        given: