def serializer = new FileCollectionFingerprintSerializer(stringInterner)

    def "reads and writes empty fingerprints"() {
        when:
        def out = serialize(FileCollectionFingerprint.EMPTY, serializer)

        then:
        out == FileCollectionFingerprint.EMPTY
    }

    def "reads and writes fingerprints"() {
        def hash = TestHashCodes.hashCodeFrom(1234)

// we can change it if it's deemed too error-prone.
type traceWriter struct {
	traceLocker
	*traceBuf
}

// write returns an a traceWriter that writes into the current M's stream.
func (tl traceLocker) writer() traceWriter {
	return traceWriter{traceLocker: tl, traceBuf: tl.mp.trace.buf[tl.gen%2]}
}

// unsafeTraceWriter produces a traceWriter that doesn't lock the trace.
//

        then:
        1 * writer.onOutput(3, 1, new DefaultTestOutputEvent(StdErr, "err-1"))
        1 * writer.onOutput(3, 2, new DefaultTestOutputEvent(StdOut, "out-2"))
        1 * writer.onOutput(3, 1, new DefaultTestOutputEvent(StdOut, "out-1"))
        0 * writer._
    }

    def "writes test outputs for class"() {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build linux && gc && 386

package unix

import "syscall"

// Underlying system call writes to newoffset via pointer.
// Implemented in assembly to avoid allocation.
func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno)

    /**
     * Writes some value to zero or more state files.
     */
    fun <T> useForStore(action: (ConfigurationCacheRepository.Layout) -> T): T

    /**
     * Creates a new [ValueStore] that can be used to load and store multiple values.
     */
    fun <T> createValueStore(
        stateType: StateType,
        writer: ValueStore.Writer<T>,
        reader: ValueStore.Reader<T>

import java.io.IOException;
import java.io.OutputStream;

/**
 * Writer to serialize a build cache entry.
 *
 * @since 3.3
 */
public interface BuildCacheEntryWriter {
    /**
     * Writes a build cache entry to the given stream.
     * <p>
     * The given output stream will be closed by this method.
     *
     * @param output output stream to write build cache entry to

public interface ValueStore<T> {
    /**
     * Writes the given value and returns an address for the written block.
     * The current thread performs the encoding. The implementation may perform some buffering and this may not necessarily be
     * flushed to the filesystem on completion of this method.
     */
    BlockAddress write(T value);

    /**
     * Reads the contents of the given block.

				// Copy key.
				if t.Key.Pointers() && writeBarrier.enabled {
					if goarch.PtrSize == 8 {
						// Write with a write barrier.
						*(*unsafe.Pointer)(dst.k) = *(*unsafe.Pointer)(k)
					} else {
						// There are three ways to squeeze at least one 32 bit pointer into 64 bits.
						// Give up and call typedmemmove.

        when:
        def writer = output.writer()
        writer.onOutput(1, output(StdOut, "[out-1]"))
        writer.onOutput(1, 1, output(StdOut, "[out-2]"))
        writer.onOutput(1, output(StdErr, "[out-3]"))
        writer.onOutput(1, output(StdErr, "[out-4]"))
        writer.onOutput(1, output(StdOut, "[out-5]"))
        writer.onOutput(1, 2, output(StdOut, "[out-6]"))
        writer.onOutput(2, output(StdOut, "[out-6]"))

import java.io.Writer


/**
 * Writes the configuration cache html report.
 *
 * The report is laid out in such a way as to allow extracting the pure JSON model
 * by looking for the `// begin-report-data` and `// end-report-data` markers.
 */
internal
class HtmlReportWriter(val writer: Writer) {

    private
    val jsonModelWriter = JsonModelWriter(writer)

    private