companion object {
        /**
         * Writes [Map] of data as [Properties] to a file, but without including the timestamp comment.
         *
         * See [PropertiesUtils.store].
         */
        fun store(data: Map<String, Any>, file: File, comment: String? = null) {
            store(propertiesFrom(data), file, comment)
        }

        /**

    def "reads and writes transformation results"() {
        expect:
        assertCanWriteAndReadResult(
            inputArtifact.file("inside"),
            inputArtifact,
            outputDir.file("first"),
            outputDir.file("second"),
            outputDir
        )
    }

    def "reads and writes output only transformation results"() {
        expect:

  ParallelIdsMap GetParallelIdsMap(Operation* op);

  // Converts from read/write state that relates ops with the same parallel id
  // to a set of last accesses for use with other parallel ids. Reads/writes
  // between parallel ids are conservatively approximated as writes.
  absl::flat_hash_set<Operation*> GetLastWrites(ResourceId resource_id);

  // Sets the read/write state for ops within the same parallel id.

        }

        /**
         * Writes a JAR entry.
         * @param path the path of the entry
         * @param bytes the body of the entry
         */
        void entry(String path, byte[] bytes) {
            checkManifestWritten()
            jarOut.putNextEntry(newEntryWithFixedTime(path))
            jarOut.write(bytes)
        }

        /**
         * Writes a JAR entry.

	return faketime / 1e9, int32(faketime % 1e9), faketime
}

// write is like the Unix write system call.
// We have to avoid write barriers to avoid potential deadlock
// on write calls.
//
//go:nowritebarrierrec
func write(fd uintptr, p unsafe.Pointer, n int32) int32 {
	if !(fd == 1 || fd == 2) {
		// Do an ordinary write.
		return write1(fd, p, n)
	}

	// Write with the playback header.

};

// Helper struct holding a resource value and its associated type.
struct ResourceValueAndSubtype {
  Value resource;
  Type subtype;
};

// Finds resource handle and type for result if result writes to a resource.
ResourceValueAndSubtype GetResourceWriteResult(
    tf_device::ClusterFuncOp cluster_func, Value result) {
  ResourceValueAndSubtype resource;
  if (!result.hasOneUse()) return resource;

type LineBuffer interface {
	// Write takes a list of arguments, each a string or []string, joins all the
	// individual strings with spaces, terminates with newline, and writes them to the
	// buffer. Any other argument type will panic.
	Write(args ...interface{})

	// WriteBytes writes bytes to the buffer, and terminates with newline.
	WriteBytes(bytes []byte)

package org.gradle.internal.logging.text;

import org.gradle.api.logging.StandardOutputListener;

import java.io.Closeable;
import java.io.IOException;

/**
 * A {@link StyledTextOutput} implementation which writes text to some char stream. Ignores any
 * styling information.
 */
public class StreamingStyledTextOutput extends AbstractStyledTextOutput implements Closeable {
    private final StandardOutputListener listener;

	p.mu.Lock()
	defer p.mu.Unlock()
	delete(p.m, value)
}

// WriteTo writes a pprof-formatted snapshot of the profile to w.
// If a write to w returns an error, WriteTo returns that error.
// Otherwise, WriteTo returns nil.
//
// The debug parameter enables additional output.
// Passing debug=0 writes the gzip-compressed protocol buffer described
// in https://github.com/google/pprof/tree/main/proto#overview.

    @Rule TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    def "writes default descriptor"() {
        def file = tmpDir.file("out.xml")

        when:
        descriptor.writeTo(file)

        then:
        def root = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new ByteArrayInputStream(file.bytes)).documentElement