Files.copy(i18nFile, temp);
    assertTrue(Files.equal(i18nFile, temp));

    Files.copy(asciiFile, temp);
    RandomAccessFile rf = new RandomAccessFile(temp, "rw");
    rf.writeByte(0);
    rf.close();
    assertEquals(asciiFile.length(), temp.length());
    assertFalse(Files.equal(asciiFile, temp));

    assertTrue(Files.asByteSource(asciiFile).contentEquals(Files.asByteSource(asciiFile)));

		if added > 0 || e != "" {
			if added > 0 {
				dst.WriteByte(SlashSeparatorChar)
			}
			dst.WriteString(e)
			added += len(e)
		}
	}

	if pathNeedsClean(dst.Bytes()) {
		s := path.Clean(dst.String())
		if trailingSlash {
			return s + SlashSeparator
		}
		return s
	}
	if trailingSlash {
		dst.WriteByte(SlashSeparatorChar)
	}
	return dst.String()
}

pkg strings, method (*Builder) Len() int
pkg strings, method (*Builder) Reset()
pkg strings, method (*Builder) String() string
pkg strings, method (*Builder) Write([]uint8) (int, error)
pkg strings, method (*Builder) WriteByte(uint8) error
pkg strings, method (*Builder) WriteRune(int32) (int, error)
pkg strings, method (*Builder) WriteString(string) (int, error)
pkg strings, type Builder struct
pkg syscall (freebsd-386), const SYS_UTIMENSAT = 547

    }
  }

  @Test
  fun singleByteReadIsSigned() {
    server.enqueue(
      MockResponse.Builder()
        .body(
          Buffer()
            .writeByte(-2)
            .writeByte(-1),
        )
        .build(),
    )
    val response = getResponse(newRequest("/"))
    val inputStream = response.body.byteStream()
    assertThat(inputStream.read()).isEqualTo(254)

	var s strings.Builder
	if x&xlFlagFreeVersion != 0 {
		s.WriteString("FreeVersion")
	}
	if x&xlFlagUsesDataDir != 0 {
		if s.Len() > 0 {
			s.WriteByte(',')
		}
		s.WriteString("UsesDD")
	}
	if x&xlFlagInlineData != 0 {
		if s.Len() > 0 {
			s.WriteByte(',')
		}
		s.WriteString("Inline")
	}
	return s.String()
}

    assertFailsWith<ConnectionShutdownException> {
      connection.newStream(headerEntries("b", "banana"), false)
    }
    val sink = stream.getSink().buffer()
    assertFailsWith<IOException> {
      sink.writeByte(0)
      sink.flush()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("stream finished")
    }
    assertFailsWith<IOException> {
      stream.getSource().read(Buffer(), 1)

HSPLokio/Buffer;->write(Lokio/ByteString;)Lokio/Buffer;
HSPLokio/Buffer;->write([B)Lokio/Buffer;
HSPLokio/Buffer;->write([BII)Lokio/Buffer;
HSPLokio/Buffer;->writeAll(Lokio/Source;)J
HSPLokio/Buffer;->writeByte(I)Lokio/Buffer;
HSPLokio/Buffer;->writeByte(I)Lokio/BufferedSink;
HSPLokio/Buffer;->writeInt(I)Lokio/Buffer;
HSPLokio/Buffer;->writeShort(I)Lokio/Buffer;
HSPLokio/Buffer;->writeUtf8(Ljava/lang/String;)Lokio/Buffer;

	}
}

type readFromWriter struct {
	buf           []byte
	writeBytes    int
	readFromBytes int
}

func (w *readFromWriter) Write(p []byte) (int, error) {
	w.buf = append(w.buf, p...)
	w.writeBytes += len(p)
	return len(p), nil
}

func (w *readFromWriter) ReadFrom(r io.Reader) (int64, error) {
	b, err := io.ReadAll(r)

        indexFile.deleteOnExit();
        FileUtil.writeBytes(indexFile.getAbsolutePath(), content.getBytes("UTF-8"));

        for (int i = 1; i <= 10; i++) {
            final File file = new File(dir, "file" + count + "-" + i + ".html");
            file.deleteOnExit();
            FileUtil.writeBytes(file.getAbsolutePath(), content.getBytes("UTF-8"));

	// Marshalls the item.
	eventData, err := json.Marshal(item)
	if err != nil {
		return err
	}
	return store.writeBytes(key, eventData)
}

// writeBytes - writes bytes to the directory.
func (store *QueueStore[I]) writeBytes(key Key, b []byte) (err error) {
	path := filepath.Join(store.directory, key.String())

	if key.Compress {