}
    }

    File getFile() {
        return file;
    }

    long getSize() {
        return file.length();
    }

    public boolean isInUse() {
        return offset != -1;
    }

    private static class SimpleBinaryData implements BinaryStore.BinaryData {
        private final long offset;
        private final File inputFile;

        private Decoder decoder;

 * limitations under the License.
 */

package org.gradle.internal.time;

public interface CountdownTimer extends Timer {

    boolean hasExpired();

    long getRemainingMillis();

    long getTimeoutMillis();

            array[i] = decoder.readInt();
        }
    }

    public static long[] readLengthPrefixedLongs(Decoder decoder) throws IOException {
        int length = decoder.readInt();
        long[] array = new long[length];
        readLongs(decoder, array);
        return array;
    }

    public static void readLongs(Decoder decoder, long[] array) throws IOException {
        for (int i = 0; i < array.length; i++) {

     */
    public DataOutputStream start(long offset) throws IOException {
        file.seek(offset);
        bufferedOutputStream.clear();
        countingOutputStream = new CountingOutputStream(bufferedOutputStream);
        return new DataOutputStream(countingOutputStream);
    }

    /**
     * Returns the number of byte written since {@link #start(long)} was called.
     */
    public long getBytesWritten() {

	// "When using an API to create a directory, the specified
	// path cannot be so long that you cannot append an 8.3 file
	// name (that is, the directory name cannot exceed MAX_PATH
	// minus 12)." Since MAX_PATH is 260, 260 - 12 = 248.
	//
	// The MSDN docs appear to say that a normal path that is 248 bytes long
	// will work; empirically the path must be less then 248 bytes long.
	pathLength := len(path)
	if !filepathlite.IsAbs(path) {

public class WorkerConfig {
    private final LogLevel logLevel;
    private final boolean publishJvmMemoryInfo;
    private final String gradleUserHomeDirPath;
    private final MultiChoiceAddress serverAddress;
    private final long workerId;
    private final String displayName;
    private final Action<? super WorkerProcessContext> workerAction;
    private final NativeServicesMode nativeServicesMode;

    public WorkerConfig(

        private final String loggingHeader;
        private final long startTime;
        private final boolean hasLoggingHeader;
        private String status = "";
        private State state = State.None;
        private long completeTime;

        private Operation(String category, String loggingHeader, long startTime, OperationIdentifier buildOperationIdentifier) {
            this.category = category;

    void encodeChunked(EncodeAction<Encoder> writeAction) throws Exception;

    /**
     * Writes a signed 64 bit long value. The implementation may encode the value as a variable number of bytes, not necessarily as 8 bytes.
     */
    void writeLong(long value) throws IOException;

    /**

        message.style(STYLE).append(" (").append(format.format(contentLength));

        long duration = System.currentTimeMillis() - resource.getTransferStartTime();
        if (duration > 0L) {
            double bytesPerSecond = contentLength / (duration / 1000.0);
            message.append(" at ");
            format.format(message, (long) bytesPerSecond);
            message.append("/s");
        }

# Issue #66456

[!cgo] skip
[GOOS:windows] skip
[GOOS:plan9] skip

# Generate a file with a very long #cgo LDFLAGS line.
# This used to cause "go build" to fail with "argument list too long".
go generate

# Build with the generated file.
go build

-- go.mod --
module cgolongcmd

go 1.22
-- generate.go --
//go:build ignore

package main

import (
	"fmt"
	"log"
	"os"
	"bytes"
)