}

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

        public void write(int[] bytes, int offset, int length) throws IOException {
            for (int i = 0; i < bytes.length; i++) {
                delegate.write(bytes[i]);
                if (bytes[i] == '\n') {

	buf := make([]byte, 512)

	for b.Loop() {
		rb.Write(data)
		rb.Read(buf)
	}
}

func BenchmarkRingBuffer_AsyncRead(b *testing.B) {
	// Pretty useless benchmark, but it's here for completeness.
	rb := New(1024)
	data := []byte(strings.Repeat("a", 512))
	buf := make([]byte, 512)

	go func() {
		for {
			rb.Read(buf)
		}
	}()

	for b.Loop() {
		rb.Write(data)
	}
}

    int FILE_READ_ATTRIBUTES = 0x00000080; // 8
    /** File write attributes access right */
    int FILE_WRITE_ATTRIBUTES = 0x00000100; // 9
    /** Delete access right */
    int DELETE = 0x00010000; // 16
    /** Read control access right */
    int READ_CONTROL = 0x00020000; // 17
    /** Write DAC access right */
    int WRITE_DAC = 0x00040000; // 18
    /** Write owner access right */
    int WRITE_OWNER = 0x00080000; // 19

func (z *listPathOptions) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 19
	// write "ID"
	err = en.Append(0xde, 0x0, 0x13, 0xa2, 0x49, 0x44)
	if err != nil {
		return
	}
	err = en.WriteString(z.ID)
	if err != nil {
		err = msgp.WrapError(err, "ID")
		return
	}
	// write "Bucket"
	err = en.Append(0xa6, 0x42, 0x75, 0x63, 0x6b, 0x65, 0x74)
	if err != nil {
		return
	}

name: Auto update performance test durations JSON

on:
  schedule:
    - cron: '53 3 * * 1'
  workflow_dispatch:

permissions:
  contents: write
  id-token: write
  pull-requests: write

jobs:
  update-perf-test-buckets:
    runs-on: ubuntu-latest

    if: github.repository == 'gradle/gradle'

    steps:
      - name: Checkout repository
        uses: actions/checkout@v6
      - name: configure aws credentials

	}
	for i := 0; i < chunks; i++ {
		_, err := f.Write(chunk)
		if err != nil {
			t.Fatal("write chunk:", err)
		}
	}
	if frag := int(size % chunkSize); frag > 0 {
		_, err := f.Write(chunk[:frag])
		if err != nil {
			t.Fatal("write chunk:", err)
		}
	}
	end := []byte("END\n")
	_, err = f.Write(end)
	if err != nil {
		t.Fatal("write end:", err)
	}
	if err := w.Close(); err != nil {

        setHeaderStart(response, 64);

        // Write structure header (9 bytes)
        SMBUtil.writeInt2(9, buffer, offset); // Structure size
        SMBUtil.writeInt2(80 - 64, buffer, offset + 2); // Buffer offset (relative to header)
        SMBUtil.writeInt4(50, buffer, offset + 4); // Total length of notification data

        // Write notification data at buffer offset 80
        int notifyOffset = 80;

 */
class PacSignatureTest {

    /**
     * Helper method to write integer in little-endian format.
     */
    private void writeLittleEndianInt(ByteArrayOutputStream baos, int value) {
        ByteBuffer buffer = ByteBuffer.allocate(4);
        buffer.order(ByteOrder.LITTLE_ENDIAN);
        buffer.putInt(value);
        baos.write(buffer.array(), 0, 4);
    }

    /**

     *
     * @param val the integer value to convert to hexadecimal characters
     * @param dst the destination character array to write the hex digits into
     * @param dstIndex the starting index in the destination array
     * @param size the number of hex digits to write (will be left-padded with zeros)
     */
    public static void toHexChars(int val, final char dst[], final int dstIndex, int size) {

func (z *CheckPartsHandlerParams) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "id"
	err = en.Append(0x84, 0xa2, 0x69, 0x64)
	if err != nil {
		return
	}
	err = en.WriteString(z.DiskID)
	if err != nil {
		err = msgp.WrapError(err, "DiskID")
		return
	}
	// write "v"
	err = en.Append(0xa1, 0x76)
	if err != nil {
		return
	}
	err = en.WriteString(z.Volume)