this.outputBufferOffset = outputBufferOffset;
    }

    /**
     * Gets the number of bytes actually read
     *
     * @return the dataLength
     */
    public int getDataLength() {
        return this.dataLength;
    }

    /**
     * Gets the number of bytes remaining to be read
     *
     * @return the dataRemaining
     */
    public int getDataRemaining() {

                    lo,
                    (int) c,
                    (int) result))
            .that(result)
            .isEqualTo(c);

        byte[] bytes = Chars.toByteArray(c);
        assertThat(bytes[0]).isEqualTo((byte) hi);
        assertThat(bytes[1]).isEqualTo((byte) lo);

        c++;
      }
    }
    assertThat(c).isEqualTo((char) 0); // sanity check
  }

   *       the same.
   *   <li>The special characters ".", "-", "*", and "_" remain the same.
   *   <li>The space character " " is converted into a plus sign "+".
   *   <li>All other characters are converted into one or more bytes using UTF-8 encoding and each
   *       byte is then represented by the 3-character string "%XY", where "XY" is the two-digit,
   *       uppercase, hexadecimal representation of the byte value.
   * </ul>
   *

		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = BackendType(zb0001)
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z BackendType) Msgsize() (s int) {
	s = msgp.IntSize
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *BucketInfo) MarshalMsg(b []byte) (o []byte, err error) {

        SMBProtocolDecodingException exception = assertThrows(SMBProtocolDecodingException.class, () -> {
            response.readBytesWireFormat(tooSmallBuffer, 0);
        });

        assertTrue(exception.getMessage().contains("Buffer too small for SMB2 negotiate response"));
        assertTrue(exception.getMessage().contains("minimum 65 bytes required"));
    }

    /**

 *
 * Unlike [okhttp3.ResponseBody], this interface is designed to be implemented by writers and not
 * called by readers.
 */
public interface MockResponseBody {
  /** The length of this response in bytes, or -1 if unknown. */
  public val contentLength: Long

  @Throws(IOException::class)
  public fun writeTo(sink: BufferedSink)

	// There is another buffer that will buffer events.
	consoleLogRPC = grid.NewStream[*grid.MSS, grid.NoPayload, *grid.Bytes](grid.HandlerConsoleLog, grid.NewMSS, nil, grid.NewBytes).WithOutCapacity(100)
	listenRPC     = grid.NewStream[*grid.URLValues, grid.NoPayload, *grid.Bytes](grid.HandlerListen, grid.NewURLValues, nil, grid.NewBytes).WithOutCapacity(100)
)

// GetLocksHandler - returns list of lock from the server.

    }

    /**
     * Test constructor with malformed data (too short).
     */
    @Test
    void testConstructorMalformedData() {
        // Prepare data (only 2 bytes, less than an int)
        byte[] data = new byte[] { 0x01, 0x02 };

        // Verify that PACDecodingException is thrown
        assertThrows(PACDecodingException.class, () -> {
            new PacSignature(data);

	// save args passed to inspect command
	var sb bytes.Buffer
	fmt.Fprintf(&sb, "Inspect path: %s%s%s\n", volume, slashSeparator, file)
	sb.WriteString("Server command line args:")
	for _, pool := range globalEndpoints {
		sb.WriteString(" ")
		sb.WriteString(pool.CmdLine)
	}
	sb.WriteString("\n")
	adminLogIf(ctx, embedFileInZip(inspectZipW, "inspect-input.txt", sb.Bytes(), 0o600))

         */
        public unicode_string() {
            // Default constructor
        }

        /** The length of the string in bytes */
        public short length;
        /** The maximum length of the string buffer in bytes */
        public short maximum_length;
        /** The Unicode character buffer */
        public short[] buffer;

        @Override