gradleUserHomeDir.getAbsolutePath(),
                (MultiChoiceAddress) serverAddress,
                workerId,
                displayName,
                processBuilder.getWorker(),
                processBuilder.getNativeServicesMode()
            );

            // Serialize the worker config, this is consumed by SystemApplicationClassLoaderWorker

    public WorkerProcessBuilder worker(Action<? super WorkerProcessContext> action) {
        this.action = action;
        return this;
    }

    @Override
    public Action<? super WorkerProcessContext> getWorker() {
        return action;
    }

    @Override
    public JavaExecHandleBuilder getJavaCommand() {
        return javaCommand;
    }

    @Override
    public LogLevel getLogLevel() {

        WorkItemExecution execution = new WorkItemExecution(spec.getDisplayName(), () -> {
            try {
                BuildOperationAwareWorker worker = workerFactory.getWorker(workerRequirement);
                return worker.execute(spec, currentBuildOperation);
            } catch (Throwable t) {
                throw new WorkExecutionException(spec.getDisplayName(), t);
            }

// Wait for the given workers to exit & clean up.
func waitForWorkerExit(t *testing.T, m *manager, workerPaths []probeKey) error {
	for _, w := range workerPaths {
		condition := func() (bool, error) {
			_, exists := m.getWorker(w.podUID, w.containerName, w.probeType)
			return !exists, nil
		}
		if exited, _ := condition(); exited {
			continue // Already exited, no need to poll.
		}
		t.Logf("Polling %v", w)

            return 1;
        }

        if (o1 instanceof CreationOrderedNode) {
            if (o2 instanceof CreationOrderedNode) {
                return ((CreationOrderedNode) o1).getOrder() - ((CreationOrderedNode) o2).getOrder();
            }
            return -1;
        }
        if (o2 instanceof CreationOrderedNode) {
            return 1;
        }

        if (o1 instanceof LocalTaskNode) {

func (opts Config) Clone() (int, time.Duration, string) {
	configMutex.RLock()
	defer configMutex.RUnlock()
	return opts.IOCount, opts.Sleep, opts.Bitrot
}

// GetWorkers returns the number of workers, -1 is none configured
func (opts Config) GetWorkers() int {
	configMutex.RLock()
	defer configMutex.RUnlock()
	return opts.DriveWorkers
}

// Update updates opts with nopts
func (opts *Config) Update(nopts Config) {

        .thenComparing(VerificationEntry::getVersion)
        .thenComparing(VerificationEntry::getFile)
        .thenComparing(VerificationEntry::getArtifactKind)
        .thenComparing(VerificationEntry::getOrder);

    protected final ModuleComponentArtifactIdentifier id;
    protected final ArtifactVerificationOperation.ArtifactKind artifactKind;
    protected final File file;

abstract public class CreationOrderedNode extends Node {

    private static final AtomicInteger ORDER_COUNTER = new AtomicInteger();

    private final int order = ORDER_COUNTER.incrementAndGet();

    public final int getOrder() {
        return order;
    }

        OptionElement optionElement = Mock(OptionElement)
        optionElement.getOptionName() >> name
        optionElement.getOptionType() >> String.class
        optionElement.getAvailableValues() >> []
        optionElement.getOrder() >> order
        optionElement
    }

    public class SomeClass {
    }

    }

    public String getChecksum() {
        return checksum;
    }

    public void setChecksum(String checksum) {
        this.checksum = checksum;
    }

    @Override
    int getOrder() {
        return checksumKind.ordinal();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }