// Write is never called with an empty buffer.
type testNonEmptyWriter struct{ io.Writer }

func (w testNonEmptyWriter) Write(b []byte) (int, error) {
	if len(b) == 0 {
		return 0, errors.New("unexpected empty Write call")
	}
	return w.Writer.Write(b)
}

func TestFileWriter(t *testing.T) {
	type (
		testWrite struct { // Write(str) == (wantCnt, wantErr)
			str     string

 * @author Jayaprabhakar Kadarkarai
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
public interface ByteArrayDataOutput extends DataOutput {
  @Override
  void write(int b);

  @Override
  void write(byte[] b);

  @Override
  void write(byte[] b, int off, int len);

  @Override
  void writeBoolean(boolean v);

  @Override
  void writeByte(int v);

  @Override
  void writeShort(int v);

	buf := new(bytes.Buffer)
	binary.Write(buf, binary.BigEndian, uint32(totalLength))
	binary.Write(buf, binary.BigEndian, uint32(headerLength))
	prelude := buf.Bytes()
	binary.Write(buf, binary.BigEndian, crc32.ChecksumIEEE(prelude))
	buf.Write(header)
	if payload != nil {
		buf.Write(payload)
	}
	message := buf.Bytes()
	binary.Write(buf, binary.BigEndian, crc32.ChecksumIEEE(message))

	return buf.Bytes()

        // Write all entries
        for (int i = 0; i < numShares; i++) {
            // Write share name (14 bytes)
            byte[] nameBytes = shareNames[i].getBytes(StandardCharsets.US_ASCII);
            System.arraycopy(nameBytes, 0, buffer, bufferIndex, Math.min(nameBytes.length, 13));
            bufferIndex += 14;

            // Write type (2 bytes)

		for _, f := range files {
			if err := w.WriteHeader(f.header); err != nil {
				t.Fatalf("unable to write previously parsed header: %s", err)
			}
			if _, err := w.Write(f.content); err != nil {
				t.Fatalf("unable to write previously parsed content: %s", err)
			}
		}
		if err := w.Close(); err != nil {
			t.Fatalf("Unable to write archive: %s", err)
		}

		// TODO: We may want to check if the archive roundtrips. This would require

            // Act: submit a write
            w.write(payload, 3, out);
        }

        // Assert: verify the underlying stream was called
        verify(out, timeout(1000)).write(payload, 0, 3);

        // Stop the thread by sending n = -1
        synchronized (w) {
            w.write(new byte[0], -1, out);
        }

        w.join(2000);

  }

  @Test fun `decode raw sequence`() {
    val buffer =
      Buffer()
        .write("300A".decodeHex())
        .write("1505".decodeHex())
        .write("Smith".encodeUtf8())
        .write("01".decodeHex())
        .write("01".decodeHex())
        .write("FF".decodeHex())

    val derReader = DerReader(buffer)

    derReader.read("test") { header ->

        pipe.close();
    }

    @Override
    public void write(final int b) throws IOException {
        tmp[0] = (byte) b;
        write(tmp, 0, 1);
    }

    @Override
    public void write(final byte[] b) throws IOException {
        write(b, 0, b.length);
    }

    @Override
    public void write(final byte[] b, final int off, int len) throws IOException {
        if (len < 0) {

    }

    @Test
    @DisplayName("Should write empty bytes to wire format")
    void testWriteBytesWireFormat() {
        // Given
        byte[] buffer = new byte[256];
        int offset = 10;

        // When
        int bytesWritten = response.writeBytesWireFormat(buffer, offset);

        // Then
        assertEquals(0, bytesWritten);
    }

    @DisplayName("Should write zero bytes at various offsets")

<p>
Note that if there are no read-write or write-write data races on memory location <i>x</i>,
then any read <i>r</i> on <i>x</i> has only one possible <i>W</i>(<i>r</i>):
the single <i>w</i> that immediately precedes it in the happens before order.
</p>

<p>
More generally, it can be shown that any Go program that is data-race-free,
meaning it has no program executions with read-write or write-write data races,