Writer writer = sourceFile.openWriter();
        try {
            writer.write("class " + className + " {");
            writer.write("    String getValue() { return \\"");
            writer.write("Hello World");
            writer.write("\\"; }");
            writer.write("}");
        } finally {
            writer.close();
        }
    } catch (IOException e) {

            return decoder.readSmallLong()
        }
        write(_, _) >> { Encoder encoder, Long value ->
            encoder.writeSmallLong(value)
        }
    }
    def intSerializer = Stub(Serializer) {
        read(_) >> { Decoder decoder ->
            return decoder.readSmallInt()
        }
        write(_, _) >> { Encoder encoder, Integer value ->
            encoder.writeSmallInt(value)
        }

func (c *DeadlineConn) Read(b []byte) (n int, err error) {
	c.setReadDeadline()
	n, err = c.Conn.Read(b)
	return n, err
}

// Write - writes data to the connection.
func (c *DeadlineConn) Write(b []byte) (n int, err error) {
	c.setWriteDeadline()
	n, err = c.Conn.Write(b)
	return n, err
}

// WithReadDeadline sets a new read side net.Conn deadline.

protection bits added automatically to provide the regular safety for these objects up to 50% of the number of drives.
This will allow normal write operations to take place on systems that exceed the write tolerance.

            output << "abcd"
            throw new RuntimeException("Simulated write error")
        }

        then:
        def ex = thrown RuntimeException
        ex.message == "Simulated write error"
        cacheDir.listFiles() as List == []
        0 * fileAccessTracker.markAccessed(_)
    }

        for (Map.Entry<File, SourceFileState> entry : value.getFileStates().entrySet()) {
            SourceFileState sourceFileState = entry.getValue();
            fileSerializer.write(encoder, entry.getKey());
            hashSerializer.write(encoder, sourceFileState.getHash());
            encoder.writeBoolean(sourceFileState.isHasUnresolved());
            encoder.writeSmallInt(sourceFileState.getEdges().size());

	if h.n == len(h.buf) {
		h.flush()
	}
	h.buf[h.n] = b
	h.n++
	return nil
}

// Write adds b to the sequence of bytes hashed by h.
// It always writes all of b and never fails; the count and error result are for implementing [io.Writer].
func (h *Hash) Write(b []byte) (int, error) {
	size := len(b)
	// Deal with bytes left over in h.buf.
	// h.n <= bufSize is always true.

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)

    @Override
    public void write(Encoder encoder, HierarchicalClassLoaderStructure classLoaderStructure) throws Exception {
        if (classLoaderStructure.getParent() == null) {
            encoder.writeByte(ROOT);
        } else {
            encoder.writeByte(HAS_PARENT);
            write(encoder, classLoaderStructure.getParent());
        }

func pread(fd int, p []byte, offset int64) (n int, err error) {
	return extpread(fd, p, 0, offset)
}

//sys	extpwrite(fd int, p []byte, flags int, offset int64) (n int, err error)

func pwrite(fd int, p []byte, offset int64) (n int, err error) {
	return extpwrite(fd, p, 0, offset)
}

func Accept4(fd, flags int) (nfd int, sa Sockaddr, err error) {
	var rsa RawSockaddrAny