sid = readInt2(buffer, bufferIndex);
            bufferIndex += 2;
        }
        numEntries = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        isEndOfSearch = ((buffer[bufferIndex] & 0x01) == 0x01) == true;
        bufferIndex += 2;
        eaErrorOffset = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        lastNameOffset = readInt2(buffer, bufferIndex);
        bufferIndex += 2;

      deflatedBytes.readAndWriteUnsafe().use { cursor ->
        cursor.resizeBuffer(newSize)
      }
    } else {
      // Same as adding EMPTY_DEFLATE_BLOCK and then removing 4 bytes.
      deflatedBytes.writeByte(0x00)
    }

    buffer.write(deflatedBytes, deflatedBytes.size)
  }

  @Throws(IOException::class)
  override fun close() = deflaterSink.close()

        // Assert
        assertNotNull(trans);
        assertEquals(0, trans.maxParameterCount);
        assertEquals(0xFFFF, trans.maxDataCount);
        assertEquals(0x00, trans.maxSetupCount);
        assertEquals(2, trans.setupCount);
        assertEquals("\\PIPE\\", trans.name);
    }

    @Test
    @DisplayName("Test writeSetupWireFormat writes correct data")

    assertThat(Buffer().writeUtf8("Слава Україні!").isProbablyUtf8(16L)).isTrue()
    assertThat(Buffer().writeByte(0x80).isProbablyUtf8(16L)).isTrue()
    assertThat(Buffer().writeByte(0x00).isProbablyUtf8(16L)).isFalse()
    assertThat(Buffer().writeByte(0xc0).isProbablyUtf8(16L)).isFalse()
  }

  @Test fun doesNotConsumeBuffer() {
    val buffer = Buffer()
    buffer.writeUtf8("hello ".repeat(1024))

        return 0;
    }

    @Override
    protected int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        dst[dstIndex] = (byte) 0x04;
        dstIndex++;
        dstIndex += writeString(this.path, dst, dstIndex);

        return dstIndex - start;
    }

    @Override

            System.arraycopy(stringBytes, 0, bufferWithTermination, 0, stringBytes.length);
            bufferWithTermination[stringBytes.length] = 0x00;
            bufferWithTermination[stringBytes.length + 1] = 0x00;

            // When
            int terminationPos = Strings.findUNITermination(bufferWithTermination, 0, bufferWithTermination.length);

            // Then

	p.append(prog, "", true)
}

// asmData assembles a DATA pseudo-op.
// DATA masks<>+0x00(SB)/4, $0x00000000
func (p *Parser) asmData(operands [][]lex.Token) {
	if len(operands) != 2 {
		p.errorf("expect two operands for DATA")
		return
	}

	// Operand 0 has the general form foo<>+0x04(SB)/4.
	op := operands[0]
	n := len(op)
	if n < 3 || op[n-2].ScanToken != '/' || op[n-1].ScanToken != scanner.Int {

     */
    private static byte[] newBuffer(int length) {
        // initialise with distinct pattern to detect unused trailing bytes
        byte[] buf = new byte[length];
        Arrays.fill(buf, (byte) 0xFF);
        return buf;
    }

    @Test
    @DisplayName("constructor initialises command and parameters correctly")
    void testConstructorInitialisesFields() throws Exception {
        int level = 42;

        dstIndex += 2;

        return dstIndex - start;
    }

    @Override
    int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        dst[dstIndex] = (byte) 0x01; /* BufferFormat */
        dstIndex++;
        writeInt2(count, dst, dstIndex); /* DataLength? */
        dstIndex += 2;
        System.arraycopy(b, off, dst, dstIndex, count);
        dstIndex += count;

        // 2 bytes for fileAttributes, 4 bytes for lastWriteTime, 4 bytes for fileSize
        byte[] buffer = new byte[20];
        // File Attributes: 0x0010 (Directory)
        buffer[0] = 0x10;
        buffer[1] = 0x00;
        // Last Write Time (UTime): A sample timestamp in milliseconds
        long sampleTimeMillis = 1672531200000L; // Represents a specific date in milliseconds