*/
public interface Managed {
    /**
     * Returns a snapshot of the current state of this object. This can be passed to the {@link ManagedFactory#fromState(Class, Object)} method to recreate this object from the snapshot.

    abstract T someValue()

    abstract T someOtherValue()

    abstract T someOtherValue2()

    abstract T someOtherValue3()

    abstract Class<T> type()

    abstract ManagedFactory managedFactory()

    boolean isNoValueProviderImmutable() {
        return false
    }

    String getDisplayName() {
        return "this provider"
    }

    def setup() {

import static org.gradle.internal.instantiation.generator.AsmBackedClassGeneratorTest.Param

class AsmBackedClassGeneratedManagedStateTest extends AbstractClassGeneratorSpec {
    ManagedFactory generatorFactory = TestUtil.instantiatorFactory().managedFactory
    final ManagedFactoryRegistry managedFactoryRegistry = new DefaultManagedFactoryRegistry().withFactories(generatorFactory)

    }

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

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

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

    def "has no value by default"() {
        expect:
        def property = property()

        def original = instantiator.newInstance(BeanInterface)
        original.prop1 = "a"

        given:
        _ * managedFactoryRegistry.lookup(_) >> instantiatorFactory().managedFactory

        expect:
        def isolated = isolatableFactory.isolate(original)
        isolated instanceof IsolatedManagedValue
        def copy = isolated.isolate()
        !copy.is(original)

import org.gradle.internal.UncheckedException;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;
import org.gradle.internal.state.Managed;
import org.gradle.internal.state.ManagedFactory;
import org.gradle.model.internal.asm.AsmClassGenerator;
import org.gradle.model.internal.asm.ClassGeneratorSuffixRegistry;
import org.gradle.model.internal.asm.ClassVisitorScope;

import org.gradle.internal.service.ServiceLookup;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;
import org.gradle.internal.state.ManagedFactory;

import java.lang.annotation.Annotation;
import java.util.Collection;

/**
 * Provides various mechanisms for instantiation of objects.
 *

import org.gradle.internal.snapshot.impl.ShortValueSnapshot;
import org.gradle.internal.snapshot.impl.StringValueSnapshot;
import org.gradle.internal.state.Managed;
import org.gradle.internal.state.ManagedFactory;
import org.gradle.internal.state.ManagedFactoryRegistry;

import java.lang.reflect.Array;
import java.util.Collection;
import java.util.List;

        property.set((Map) null)
    }

    @Override
    protected void nullConvention(Object property) {
        property.convention((Map) null)
    }

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

    def property = property()

    def "has empty map as value by default"() {
        expect:

        def state = property.unpackState()
        def copy = managedFactory().fromState(property.publicType(), state)
        !copy.is(property)
        !copy.present
        copy.getOrNull() == null

        property.set(someValue())
        copy.getOrNull() == null

        def state2 = property.unpackState()
        def copy2 = managedFactory().fromState(property.publicType(), state2)
        !copy2.is(property)