public short percent;
        /** Used space in bytes */
        public long used;
        /** Filesystem path */
        public String path;
        /** Free space in bytes */
        public long free;
        /** Total space in bytes */
        public long total;
        /** Usable space in bytes */
        public long usable;
    }

    /**

public interface Hasher extends PrimitiveSink {
  @CanIgnoreReturnValue
  @Override
  Hasher putByte(byte b);

  @CanIgnoreReturnValue
  @Override
  Hasher putBytes(byte[] bytes);

  @CanIgnoreReturnValue
  @Override
  Hasher putBytes(byte[] bytes, int off, int len);

  @CanIgnoreReturnValue
  @Override
  Hasher putBytes(ByteBuffer bytes);

  @CanIgnoreReturnValue
  @Override
  Hasher putShort(short s);

            byte[] testContext =
                    new byte[] { (byte) 0x11, (byte) 0x22, (byte) 0x33, (byte) 0x44, (byte) 0x55, (byte) 0x66, (byte) 0x77, (byte) 0x88 };
            message.setContext(testContext);

            // When
            byte[] bytes = message.toByteArray();

            // Then
            assertNotNull(bytes);
            // Verify challenge

     * The header format is:
     * - Byte 0: Message type (0x00 for SESSION_MESSAGE)
     * - Byte 1: High bit of 17-bit length field
     * - Bytes 2-3: Lower 16 bits of length field
     */
    private static byte[] messageHeader(int length) {
        byte[] h = new byte[4];
        h[0] = (byte) SessionServicePacket.SESSION_MESSAGE;
        h[1] = (byte) ((length >> 16) & 0x01);
        h[2] = (byte) ((length >> 8) & 0xFF);

        yield line


@app.get("/story/stream-bytes", response_class=StreamingResponse)
async def stream_story_bytes() -> AsyncIterable[bytes]:
    for line in message.splitlines():
        yield line.encode("utf-8")


@app.get("/story/stream-no-async-bytes", response_class=StreamingResponse)
def stream_story_no_async_bytes() -> Iterable[bytes]:
    for line in message.splitlines():
        yield line.encode("utf-8")

        byte[] buffer = new byte[50];
        int bufferIndex = 0;

        // SMB3 capabilities
        int testCapabilities = 0x0000002F; // DFS, LEASING, LARGE_MTU, MULTI_CHANNEL, PERSISTENT_HANDLES, DIRECTORY_LEASING

        // Random but realistic GUID
        byte[] testGuid = { (byte) 0x01, (byte) 0x23, (byte) 0x45, (byte) 0x67, (byte) 0x89, (byte) 0xAB, (byte) 0xCD, (byte) 0xEF,

        byte[] negativeBytes = new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF }; // Represents -1
        AvFlags negativeAvFlags = new AvFlags(negativeBytes);
        assertNotNull(negativeAvFlags, "AvFlags object should not be null for negative bytes");
        assertEquals(-1, negativeAvFlags.getFlags(), "Flags should be -1 for all FF bytes");
    }

    /**
     * Test constructor with integer flags.
     */
    @Test

    void testReadWithDifferentReservedValues(int byte2, int byte3) throws SMBProtocolDecodingException {
        // Given
        byte[] buffer = new byte[256];

        // Write structure size (4)
        SMBUtil.writeInt2(4, buffer, 0);
        // Write reserved field (any value is acceptable)
        buffer[2] = (byte) byte2;
        buffer[3] = (byte) byte3;

        // When

package grid

import (
	"bytes"
	"testing"

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

func TestMarshalUnmarshalconnectReq(t *testing.T) {
	v := connectReq{}
	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)
	}

    headers: Annotated[Headers, Doc("The headers of the request.")]
    content_type: Annotated[
        str | None, Doc("The content type of the request, from the headers.")
    ]

    async def write(
        self,
        data: Annotated[
            bytes,
            Doc(
                """
                The bytes to write to the file.
                """