public class DefaultBuildOperationIdFactory implements BuildOperationIdFactory {
    public static final long ROOT_BUILD_OPERATION_ID_VALUE = 1L;

    private final AtomicLong nextId = new AtomicLong(ROOT_BUILD_OPERATION_ID_VALUE);

    @Override
    public long nextId() {
        return nextId.getAndIncrement();
    }

package org.gradle.internal.id;

import java.util.concurrent.atomic.AtomicLong;

public class LongIdGenerator implements IdGenerator<Long> {
    private final AtomicLong nextId = new AtomicLong(1);

    @Override
    public Long generateId() {
        return nextId.getAndIncrement();
    }

@ServiceScope(Scope.BuildTree.class)
public class ComponentIdGenerator {
    private final AtomicLong nextId = new AtomicLong();

    public long nextComponentId() {
        return nextId.getAndIncrement();
    }

    public long nextVariantId() {
        return nextId.getAndIncrement();
    }

    public long nextGraphNodeId() {
        return nextId.getAndIncrement();
    }

        ) {
            int id = nextId++;
            return new ArtifactsForNode(id, new VariantResolvingArtifactSet(variantResolver, component, variant, dependency, graphVariantSelector, consumerSchema));
        }

        return artifactsByNodeId.computeIfAbsent(toNode.getNodeId(), (LongFunction<ArtifactsForNode>) value -> {
            int id = nextId++;

}

// check may be nil
func (check *Checker) newTypeParam(obj *TypeName, constraint Type) *TypeParam {
	// Always increment lastID, even if it is not used.
	id := nextID()
	if check != nil {
		check.nextID++
		id = check.nextID
	}
	typ := &TypeParam{check: check, id: id, obj: obj, index: -1, bound: constraint}
	if obj.typ == nil {
		obj.typ = typ
	}

  }

  @JvmStatic
  fun threadFactory(name: String): ThreadFactory {
    return object : ThreadFactory {
      private var nextId = 1

      override fun newThread(runnable: Runnable): Thread {
        return Thread(runnable, "$name-${nextId++}")
      }
    }
  }
}

fun getEnv(name: String) = System.getenv(name)

val SYSTEM_FILE_SYSTEM = FileSystem.SYSTEM

}

// check may be nil
func (check *Checker) newTypeParam(obj *TypeName, constraint Type) *TypeParam {
	// Always increment lastID, even if it is not used.
	id := nextID()
	if check != nil {
		check.nextID++
		id = check.nextID
	}
	typ := &TypeParam{check: check, id: id, obj: obj, index: -1, bound: constraint}
	if obj.typ == nil {
		obj.typ = typ
	}

        }
        1 * clock.currentTime >> 500
        0 * buildOperationIdFactory.nextId()
    }

    def "test output is exposed as progress"() {
        setup:
        _ * clock.currentTime >> 0
        long operationId = 1
        _ * buildOperationIdFactory.nextId() >> { operationId++ }
        TestOutputEvent testOutputEvent = new SimpleTestOutputEvent()

}

// getID returns a unique ID for the type t.
func (ctxt *Context) getID(t Type) int {
	ctxt.mu.Lock()
	defer ctxt.mu.Unlock()
	id, ok := ctxt.originIDs[t]
	if !ok {
		id = ctxt.nextID
		ctxt.originIDs[t] = id
		ctxt.nextID++
	}
	return id

}

// getID returns a unique ID for the type t.
func (ctxt *Context) getID(t Type) int {
	ctxt.mu.Lock()
	defer ctxt.mu.Unlock()
	id, ok := ctxt.originIDs[t]
	if !ok {
		id = ctxt.nextID
		ctxt.originIDs[t] = id
		ctxt.nextID++
	}
	return id