String filename = "a\\test\\path.txt";
        int informationLevel = 0x0102;
        Trans2QueryPathInformation trans = new Trans2QueryPathInformation(filename, informationLevel);
        // Expected size: 2 (info level) + 4 (reserved) + filename length + 1 (null terminator)
        byte[] dst = new byte[2 + 4 + filename.length() + 1];

        // When
        int bytesWritten = trans.writeParametersWireFormat(dst, 0);

	})
}

func (c chainG[T]) Delete(ctx context.Context) (rowsAffected int, err error) {
	r := new(T)
	res := c.g.apply(ctx).Delete(r)
	return int(res.RowsAffected), res.Error
}

func (c chainG[T]) Update(ctx context.Context, name string, value any) (rowsAffected int, err error) {
	var r T
	res := c.g.apply(ctx).Model(r).Update(name, value)
	return int(res.RowsAffected), res.Error
}

     * @param out the output stream
     * @return the number of bytes copied
     */
    protected static int copyInternal(final InputStream in, final OutputStream out) {
        try {
            final byte[] buf = new byte[DEFAULT_BUF_SIZE];
            int len;
            int amount = 0;
            while ((len = in.read(buf)) != -1) {
                out.write(buf, 0, len);
                amount += len;

      E e) /*-{
    return ******@****.***::getDeclaringClass()();
  }-*/;

  static int reduceIterationsIfGwt(int iterations) {
    return iterations / 10;
  }

  static int reduceExponentIfGwt(int exponent) {
    return exponent / 2;
  }

  private Platform() {}

        assertEquals(1, pool.failCounts.get("10.0.0.1"));
        assertEquals(1, pool.failCounts.get("10.0.0.2"));
    }

    @ParameterizedTest
    @ValueSource(ints = { 0, -1 })
    @DisplayName("Should default to port 445 when port <= 0")
    void testDefaultPort(int invalidPort) throws Exception {
        // Given: Create a new pool for this test to ensure isolation
        SmbTransportPoolImpl testPool = new SmbTransportPoolImpl();

     */
    @Override
    public int encode(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        SMBUtil.writeInt8(this.offset, dst, dstIndex);
        dstIndex += 8;
        SMBUtil.writeInt8(this.length, dst, dstIndex);
        dstIndex += 8;

        SMBUtil.writeInt4(this.flags, dst, dstIndex);
        dstIndex += 4;
        dstIndex += 4; // Reserved
        return dstIndex - start;

     * @return the lease flags
     */
    public int getLeaseFlags() {
        return leaseFlags;
    }

    /**
     * Sets the lease flags for this request
     * @param leaseFlags the lease flags to set
     */
    public void setLeaseFlags(int leaseFlags) {
        this.leaseFlags = leaseFlags;
    }

    @Override
    public int size() {
        // Context header: 16 bytes

    /**
     * Default number of records to display per page.
     */
    public static final int DEFAULT_PAGE_SIZE = 20;

    /**
     * Default current page number for pagination.
     */
    public static final int DEFAULT_CURRENT_PAGE_NUMBER = 1;

    /**
     * The total number of records in the result set.
     */
    private int allRecordCount;

    /**
     * The total number of pages available for pagination.
     */

     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(byte[] buffer, int bufferIndex, int len) {
        int start = bufferIndex;
        int end = start + len;
        interfaces.clear();

        while (bufferIndex < end && (bufferIndex + 152) <= end) {
            // Read Next field to determine if there are more entries
            int next = SMBUtil.readInt4(buffer, bufferIndex);

     */
    int DCERPC_RESERVED_1 = 0x08;
    /**
     * Supports concurrent multiplexing flag
     */
    int DCERPC_CONC_MPX = 0x10; /* supports concurrent multiplexing */
    /**
     * Did not execute flag - indicates request was not executed
     */
    int DCERPC_DID_NOT_EXECUTE = 0x20;
    /**
     * Maybe flag - indicates 'maybe' call semantics requested
     */