void testMultipleReadsUpdateOffset() {
        byte[] buffer1 = new byte[] { 0x10, 0x00, 0x00, 0x00 }; // 16
        byte[] buffer2 = new byte[] { 0x20, 0x00, 0x00, 0x00 }; // 32

        response.readParameterWordsWireFormat(buffer1, 0);
        assertEquals(16L, response.getOffset(), "First read should set offset to 16");

        response.readParameterWordsWireFormat(buffer2, 0);

	c.Assert(err, nil)
	c.Assert(response.StatusCode, http.StatusOK)

	var buffer bytes.Buffer
	// data to be written into buffer.
	data := "1234567890"
	// seed the random number generator once.
	rand.Seed(3)
	// generate a random number between 13 and 200.
	randInt := getRandomRange(13, 200, -1)
	// write into buffer till length of the buffer is greater than the generated random number.
	for i := 0; i <= randInt; i += 10 {

        byte[] buffer = new byte[8];

        // Path consumed (2 bytes)
        SMBUtil.writeInt2(0, buffer, 0);

        // Number of referrals (2 bytes) - 0
        SMBUtil.writeInt2(0, buffer, 2);

        // Flags (2 bytes)
        SMBUtil.writeInt2(0, buffer, 4);

        // Padding (2 bytes)
        buffer[6] = 0;
        buffer[7] = 0;

        return buffer;
    }

        // For GCM, last 4 bytes should contain incrementing counter
        ByteBuffer buffer1 = ByteBuffer.wrap(nonce1, 12, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN);
        ByteBuffer buffer2 = ByteBuffer.wrap(nonce2, 12, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN);
        int counter1 = buffer1.getInt();
        int counter2 = buffer2.getInt();

        assertEquals(counter1 + 1, counter2, "Counter should increment between nonces");

        @Test
        @DisplayName("Should not modify buffer during write")
        void testWriteDoesNotModifyBuffer() {
            byte[] buffer = new byte[64];
            Arrays.fill(buffer, (byte) 0xAA);
            byte[] originalBuffer = buffer.clone();

            notification.writeBytesWireFormat(buffer, 0);

            assertArrayEquals(originalBuffer, buffer);
        }
    }

    @Nested

        SMBUtil.writeInt2(8, buffer, 58); // Security buffer length

        // Add some dummy security data at offset 64 from start
        buffer[64] = (byte) 0x4E; // NTLMSSP signature start
        buffer[65] = (byte) 0x54;
        buffer[66] = (byte) 0x4C;
        buffer[67] = (byte) 0x4D;
        buffer[68] = (byte) 0x53;
        buffer[69] = (byte) 0x53;

// The slice aliases the buffer content at least until the next buffer modification,
// so immediate changes to the slice will affect the result of future reads.
func (b *Buffer) Bytes() []byte { return b.buf[b.off:] }

// AvailableBuffer returns an empty buffer with b.Available() capacity.
// This buffer is intended to be appended to and

                final int _bufferl = length / 2;
                final int _buffers = maximum_length / 2;
                _dst.enc_ndr_long(_buffers);
                _dst.enc_ndr_long(0);
                _dst.enc_ndr_long(_bufferl);
                final int _bufferi = _dst.index;
                _dst.advance(2 * _bufferl);

                _dst = _dst.derive(_bufferi);
                for (int _i = 0; _i < _bufferl; _i++) {

                        throw new NdrException(NdrException.INVALID_CONFORMANCE);
                    }
                    this.buffer = new short[_buffers];
                }
                _src = _src.derive(_bufferi);
                for (int _i = 0; _i < _bufferl; _i++) {
                    this.buffer[_i] = (short) _src.dec_ndr_short();
                }
            }
        }
    }

internal fun idnToAscii(host: String): String? {
  val bufferA = Buffer().writeUtf8(host)
  val bufferB = Buffer()

  // 1. Map, from bufferA to bufferB.
  while (!bufferA.exhausted()) {
    val codePoint = bufferA.readUtf8CodePoint()
    if (!IDNA_MAPPING_TABLE.map(codePoint, bufferB)) return null
  }

  // 2. Normalize, from bufferB to bufferA.
  val normalized = normalizeNfc(bufferB.readUtf8())
  bufferA.writeUtf8(normalized)