return new UniqueId(string);
        } else {
            throw new IllegalArgumentException("Invalid unique ID: " + string);
        }
    }

    public static UniqueId generate() {
        return from(UUID.randomUUID());
    }

    public static Factory<UniqueId> factory() {
        return FACTORY;
    }

    private UniqueId(String value) {
        this.value = value;
    }

        return buildTreeScopedCacheBuilderFactory;
    }

    private UniqueId get(ScopeParams params) {
        ObjectHolder<UniqueId> store = store(params);

        return store.maybeUpdate(new ObjectHolder.UpdateAction<UniqueId>() {
            @Override
            public UniqueId update(UniqueId oldValue) {
                if (oldValue == null) {
                    return generator.create();

        String crossVersionTest = System.getProperty("org.gradle.integtest.crossVersion");
        if (crossVersionTest == null) {
            return new EngineDescriptor(uniqueId, "skip");
        }

        List<TestVariant> testVariants = buildTestVariants(uniqueId, discoveryRequest);
        return discoverTests(uniqueId, testVariants);
    }

    @Override

    def "generates unique values"() {
        expect:
        def n = 100
        (1..n).collect { UniqueId.generate() }.unique().size() == n
    }

    def "can roundtrip to / from string"() {
        when:
        def id = UniqueId.generate()
        def s = id.asString()

        then:
        UniqueId.from(s) == id
        UniqueId.from(s).asString() == s
    }

        // Assert that unique build invocation ID was used
        this.idsOfBuildTrees.collect { it.values().first().buildInvocation }.unique(false).size() == this.idsOfBuildTrees.size()

    }

    @EqualsAndHashCode
    static class ScopeIds {
        final UniqueId buildInvocation
        final UniqueId workspace
        final UniqueId user

        ScopeIds(UniqueId buildInvocation, UniqueId workspace, UniqueId user) {

class TransformWorkspaceIdentity implements UnitOfWork.Identity {
    private final ValueSnapshot secondaryInputsSnapshot;
    private final String uniqueId;

    private TransformWorkspaceIdentity(ValueSnapshot secondaryInputsSnapshot, HashCode uniqueId) {
        this.uniqueId = uniqueId.toString();
        this.secondaryInputsSnapshot = secondaryInputsSnapshot;
    }

    public ValueSnapshot getSecondaryInputsSnapshot() {

 */

package org.gradle.internal.scopeids;

import org.gradle.internal.id.UniqueId;
import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.Serializer;

class UniqueIdSerializer implements Serializer<UniqueId> {

    public static final Serializer<UniqueId> INSTANCE = new UniqueIdSerializer();

    private UniqueIdSerializer() {
    }

        }
        TaskIdentity<?> that = (TaskIdentity<?>) o;
        return this.uniqueId == that.uniqueId;
    }

    @Override
    public int hashCode() {
        return (int) (uniqueId ^ uniqueId >>> 32);
    }

    @Override
    public String toString() {
        return "TaskIdentity{path=" + identityPath + ", type=" + type + ", uniqueId=" + uniqueId + '}';
    }

    public String getTaskPath() {

    public <T extends Task> TaskIdentity<T> recreate(String name, Class<T> type, ProjectInternal project, long uniqueId) {
        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,

 * limitations under the License.
 */

package org.gradle.internal.scopeids.id;

import org.gradle.internal.id.UniqueId;

public class ScopeId {

    private final UniqueId id;

    ScopeId(UniqueId id) {
        this.id = id;
    }

    public UniqueId getId() {
        return id;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {