private Task checkTask;

    public AbstractBuildableComponentSpec(ComponentSpecIdentifier identifier, Class<? extends BuildableComponentSpec> publicType) {
        super(identifier, publicType);
    }

    @Override
    @Nullable
    public Task getBuildTask() {
        return buildTask;
    }

    @Override
    public void setBuildTask(@Nullable Task buildTask) {

    def "generates subclass that is not decorated when class is abstract"() {
        expect:
        def bean = create(AbstractBean, "a")
        bean.a == "a"

        bean instanceof GeneratedSubclass
        bean.publicType() == AbstractBean

        bean instanceof ModelObject
        bean.modelIdentityDisplayName == null
        !bean.hasUsefulDisplayName()

        bean instanceof OwnerAware

    private <T> TypeMetadata createTypeMetadata(Class<T> type) {
        Class<?> publicType = GeneratedSubclasses.unpack(type);
        ReplayingTypeValidationContext validationContext = new ReplayingTypeValidationContext();
        TypeAnnotationMetadata annotationMetadata = typeAnnotationMetadataStore.getTypeAnnotationMetadata(publicType);
        annotationMetadata.visitValidationFailures(validationContext);

        }

        @Override
        public boolean isImmutable() {
            return true;
        }

        @Override
        public Class<?> publicType() {
            return Directory.class;
        }

        @Override
        public Object unpackState() {
            return getAsFile();
        }

        @Override

 */
public interface NativeComponentFactory {
    /**
     * Creates a new top-level component.
     */
    <P extends SoftwareComponent, I extends P> I newInstance(Class<P> publicType, Class<I> implementationType, String name);

    public DefaultNativeComponentFactory(ObjectFactory objectFactory) {
        this.objectFactory = objectFactory;
    }

    @Override
    public <P extends SoftwareComponent, I extends P> I newInstance(Class<P> publicType, Class<I> implementationType, String name) {
        return objectFactory.newInstance(implementationType, name);
    }

/**
 * Interface for types that are runtime generated subclasses of some other type.
 */
public interface GeneratedSubclass {
    /**
     * Returns the type from which this type was generated.
     */
    Class<?> publicType();

            return new ImmutableManagedValueSnapshot(managed.publicType().getName(), (String) managed.unpackState());
        }

        @Override
        public ValueSnapshot managedValue(Managed value, ValueSnapshot state) {
            return new ManagedValueSnapshot(value.publicType().getName(), state);
        }

        @Override

    }

    def canUnpackAndRecreateAbstractClassWithAbstractPropertyGetterAndSetter() {
        def bean = create(BeanWithAbstractProperty)

        expect:
        bean instanceof Managed
        bean.publicType() == BeanWithAbstractProperty
        !bean.isImmutable()
        def state = bean.unpackState()
        state.length == 1
        state[0] == null

            }
        }
        return type;
    }

    public static Class<?> unpackType(Object object) {
        if (object instanceof GeneratedSubclass) {
            return ((GeneratedSubclass) object).publicType();
        }
        return object.getClass();
    }