import org.gradle.platform.base.internal.BinaryNamingScheme;

public class TestNativeBinariesFactory {

    public static <T extends NativeBinarySpec, I extends AbstractNativeBinarySpec> T create(Class<T> publicType, Class<I> implType, String name, MutableModelNode componentNode,
                                                                                      BinaryNamingScheme namingScheme, NativeDependencyResolver resolver,

    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

 */
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

            }
        }
        return type;
    }

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

        n2.is(factory.named(Named, "b"))
    }

    def "can unpack and recreate Named instance"() {
        expect:
        def n1 = factory.named(Named, "a")
        n1 instanceof Managed
        n1.publicType() == Named
        n1.isImmutable()
        def state = n1.unpackState()
        state == "a"

        def n2 = factory.fromState(Named, state)
        n2.is(n1)
    }

        super(managed);
        this.managedFactoryRegistry = managedFactoryRegistry;
    }

    @Override
    public ValueSnapshot asSnapshot() {
        return new ImmutableManagedValueSnapshot(getValue().publicType().getName(), (String) getValue().unpackState());
    }

    @Override
    public void appendToHasher(Hasher hasher) {
        asSnapshot().appendToHasher(hasher);
    }

    @Nullable
    @Override