when:
        def id1 = factory.createId()
        def id2 = factory.createId()
        then:
        id1 != id2

        when:
        factory.idRecreated()
        factory.idRecreated()
        then:
        noExceptionThrown()

        when:
        factory.createId()
        then:
        def e = thrown(IllegalStateException)
        e.message == "Cannot create a new id after one has been loaded"
    }

    @Requires(IntegTestPreconditions.NotConfigCached)
    def "unable to create new configuration-cacheable ids after load"() {
        buildFile << """
            def factory = gradle.services.get(${ConfigurationCacheableIdFactory.name})

            task run {
                doLast {
                    def id = factory.createId()
                    println("Created new id: \$id")
                }
            }
        """

    ) {
        long transformStepNodeId = idFactory.createId();
        return new TransformStepNode.InitialTransformStepNode(transformStepNodeId, targetComponentVariant, sourceAttributes, initial, artifact, upstreamDependencies, buildOperationRunner, calculatedValueContainerFactory);
    }

    /**
     * Create an initial transform step node.
     * <p>

    public TaskIdentityFactory(ConfigurationCacheableIdFactory idFactory) {
        this.idFactory = idFactory;
    }

    /**
     * Create a task identity.
     */
    public <T extends Task> TaskIdentity<T> create(String name, Class<T> type, ProjectInternal project) {
        long id = idFactory.createId();
        return doCreate(name, type, project, id);
    }

    /**
     * Recreate a task identity.
     * <p>

        }
        deleteFromArray(arraySettingsIndexName, settingsId, createId(key, value));
    }

    protected String createArraySettingsIndexName(final String settingsIndexName) {
        return settingsIndexName + "_array";
    }

    protected String createId(final String key, final Object value) {

    }

    public static TaskIdentityFactory factory() {
        AtomicLong idCounter = new AtomicLong(0);
        ConfigurationCacheableIdFactory idFactory = new ConfigurationCacheableIdFactory() {
            @Override
            public long createId() {
                return idCounter.incrementAndGet();
            }

            @Override
            public void idRecreated() {

    private final AtomicLong sequence = new AtomicLong(0);

    /**
     * Creates a new unique id.
     * <p>
     * New ids can only be created if no ids have been loaded from the configuration cache.
     * When re-creating an object due to loading from the configuration cache,
     * {@link #idRecreated()} must be called before the object is re-created to make sure the consistency of the ids.
     *

        source.put(FieldNames.TIMESTAMP, DateTimeFormatter.ISO_INSTANT.format(ZonedDateTime.now()));

        arraySettings.addToArrayIndex(arraySettings.arraySettingsIndexName, arraySettings.settingsId,
                arraySettings.createId(ELEVATE_WORD_SETTINGD_KEY, elevateWord.getElevateWord()), source);
    }

    public void delete(final String elevateWord) {
        if (logger.isDebugEnabled()) {

        then:
        containerHas container, "created1", "created2", "created3"
        parent.collect({it.name}).containsAll(["created1", "created2", "created3"])

        and:
        container.getByName("created1").value == "original"
        container.getByName("created2").value == "changed"
        container.getByName("created3").value == "actioned"
    }

    def "can create and configure via DSL"() {

import org.gradle.api.tasks.TaskAction;
import org.gradle.workers.WorkerExecutor;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;

abstract public class CreateMD5 extends SourceTask { // <1>

    @OutputDirectory
    abstract public DirectoryProperty getDestinationDirectory(); // <2>

    @TaskAction
    public void createHashes() {