internal const val OPCODE_FLAG_CONTROL = 8

  /**
   * Byte 1 flag for whether the payload data is masked.
   *
   * If this flag is set, the next four
   * bytes represent the mask key. These bytes appear after any additional bytes specified by [B1_MASK_LENGTH].
   */
  internal const val B1_FLAG_MASK = 128

  /**
   * Byte 1 mask for the payload length.
   *
   * If this value is [PAYLOAD_SHORT], the next two

                "Raw bytes for empty string should be empty");

        byte[] emptyBytes = new byte[0];
        AvTargetName avTargetNameFromBytes = new AvTargetName(emptyBytes);
        assertEquals(emptyString, avTargetNameFromBytes.getTargetName(),
                "Empty string should be handled correctly from raw bytes constructor");

   * [Byte Order Mark (BOM)](https://en.wikipedia.org/wiki/Byte_order_mark), it is consumed and
   * used to determine the charset of the response bytes.
   *
   * Otherwise if the response has a `Content-Type` header that specifies a charset, that is used
   * to determine the charset of the response bytes.
   *
   * Otherwise the response bytes are decoded as UTF-8.
   */
  fun charStream(): Reader =

app = FastAPI()

# =====================================================================================
# Without aliases


@app.post("/optional-list-bytes")
async def read_optional_list_bytes(p: Annotated[list[bytes] | None, File()] = None):
    return {"file_size": [len(file) for file in p] if p else None}


@app.post("/optional-list-uploadfile")
async def read_optional_list_uploadfile(

  public Hasher putByte(byte b) {
    update(b);
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putBytes(byte[] bytes) {
    checkNotNull(bytes);
    update(bytes);
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putBytes(byte[] bytes, int off, int len) {
    checkPositionIndexes(off, off + len, bytes.length);
    update(bytes, off, len);
    return this;

        byte[] dst1 = new byte[256];
        int bytesWritten1 = netShareEnum.writeParametersWireFormat(dst1, 0);

        // Test with offset 100
        byte[] dst2 = new byte[256];
        int bytesWritten2 = netShareEnum.writeParametersWireFormat(dst2, 100);

        // Same number of bytes should be written
        assertEquals(bytesWritten1, bytesWritten2);

        // Data should be the same, just at different offsets

	v := BucketReplicationResyncStatus{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecodeBucketReplicationResyncStatus(b *testing.B) {
	v := BucketReplicationResyncStatus{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

        byte[] tokenArray = new byte[] { 1, 2, 3 };
        byte[] mic = new byte[] { 9, 9, 9 };
        NegTokenTarg original = new NegTokenTarg(NegTokenTarg.ACCEPT_COMPLETED, mech, tokenArray, mic);

        // Act – serialise and parse back
        byte[] bytes = original.toByteArray();
        NegTokenTarg roundTrip = new NegTokenTarg(bytes);

  private static class AppendableByteSource extends ByteSource {
    private byte[] bytes;

    AppendableByteSource(byte[] initialBytes) {
      this.bytes = initialBytes.clone();
    }

    @Override
    public InputStream openStream() {
      return new In();
    }

    void append(byte[] b) {
      byte[] newBytes = Arrays.copyOf(bytes, bytes.length + b.length);

package cmd

import (
	"bytes"
	"testing"

	"github.com/tinylib/msgp/msgp"
)

func TestMarshalUnmarshalPoolDecommissionInfo(t *testing.T) {
	v := PoolDecommissionInfo{}
	bts, err := v.MarshalMsg(nil)
	if err != nil {
		t.Fatal(err)
	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)