return doCreate(generator, clazz, defaultServices(), null, args)
    }

    protected <T> T create(Class<T> clazz, Describable displayName, Object... args) {
        return doCreate(generator, clazz, defaultServices(), displayName, args)
    }

    protected <T> T create(Class<T> clazz, ServiceLookup services, Object... args) {
        return doCreate(generator, clazz, services, null, args)
    }

    }

    @Override
    protected TestObject doCreate(String name) {
        def testObject = new TestObject(instantiator)
        testObject.name = name
        testObject
    }

    @Override
    protected <U extends TestObject> U doCreate(String name, Class<U> type) {
        throw new UnsupportedOperationException("doCreate")
    }

    @Override

        idFactory.idRecreated();
        return doCreate(name, type, project, uniqueId);
    }

    private static <T extends Task> TaskIdentity<T> doCreate(String name, Class<T> type, ProjectInternal project, long uniqueId) {
        return new TaskIdentity<>(
            type,
            name,
            project.projectPath(name),

        super(IvyConfiguration.class, instantiator, collectionCallbackActionDecorator);
    }

    @Override
    protected IvyConfiguration doCreate(String name) {
        return getInstantiator().newInstance(DefaultIvyConfiguration.class, name);
    }

        super(type, instantiator, Named.Namer.forType(type), callbackActionDecorator);
    }

    /**
     * Subclasses need only implement this method as the creation strategy.
     */
    protected abstract T doCreate(String name);

    @Override
    public T create(String name) {
        assertMutable("create(String)");
        return create(name, Actions.doNothing());
    }

    @Override

    public TestContainer(org.gradle.internal.reflect.Instantiator instantiator) {
        super(TestObject.class, instantiator, new DynamicPropertyNamer(), CollectionCallbackActionDecorator.NOOP);
    }

    protected TestObject doCreate(String name) {
        Instantiator instantiator = getInstantiator();
        TestObject testObject = new TestObject(instantiator);
        testObject.setName(name);
        return testObject;
    }

        super(type, instantiator, namer, callbackDecorator);
    }

    protected abstract <U extends T> U doCreate(String name, Class<U> type);

    @Override
    public <U extends T> U create(String name, Class<U> type) {
        assertMutable("create(String, Class)");
        return create(name, type, null);
    }

        this.taskDependencyFactory = taskDependencyFactory;
        this.instantiator = instantiator;
        this.objectFactory = objectFactory;
    }

    @Override
    protected SourceSet doCreate(String name) {
        DefaultSourceSet sourceSet = instantiator.newInstance(DefaultSourceSet.class, name, objectFactory);

    }

    @Override
    public void content(Action<? super RepositoryContentDescriptor> configureAction) {
        throw new UnsupportedOperationException();
    }

    @Override
    protected PrebuiltLibrary doCreate(String name) {
        return getInstantiator().newInstance(DefaultPrebuiltLibrary.class, name, objectFactory, domainObjectCollectionFactory);
    }

    @Override
    public PrebuiltLibrary resolveLibrary(String name) {

        super(type, instantiator, callbackDecorator);
        this.objectFactory = objectFactory;
        this.fileOperations = fileOperations;
    }

    @Override
    protected Distribution doCreate(String name) {
        return objectFactory.newInstance(DefaultDistribution.class, name, fileOperations.copySpec());
    }