"Should throw exception for ACE count > 4096");
    }

    @Test
    @DisplayName("Test getType returns correct value")
    void testGetType() throws SMBProtocolDecodingException {
        // Prepare buffer with specific type value
        testBuffer[0] = 0x01; // revision
        testBuffer[1] = 0x00; // padding

        assertEquals((byte) 0x00, dst[1], "Second byte must be 0");
    }

    /**
     * Validates writeParametersWireFormat encodes values in the correct order and endianness.
     */
    @Test
    void testWriteParametersWireFormat() {
        // Given
        int sid = 0x1234;
        int resumeKey = 0x89ABCDEF; // LE expected: EF CD AB 89

If you added the return type annotation, tools and editors would complain with a (correct) error telling you that your function is returning a type (e.g. a dict) that is different from what you declared (e.g. a Pydantic model).

////

## Quotes { #quotes }

//// tab | Test

Yesterday, my friend wrote: "If you spell incorrectly correctly, you have spelled it incorrectly". To which I answered: "Correct, but 'incorrectly' is incorrectly not '"incorrectly"'".

/// note

The LLM will probably translate this wrong. Interesting is only if it keeps the fixed translation when retranslating.

            @Override
            protected SmbResource adapt(FileEntry e) {
                adaptCalled[0] = true;
                assertEquals(mockFileEntry1, e, "Should adapt the correct entry");
                return mockResource1;
            }
        };

        // When
        SmbResource result = iterator.next();

        // Then

        } finally {
            // Clean up
            tempFile.delete();
        }
    }

    public void test_createResponseBodyFile_tempFilePrefix() throws Exception {
        // Test that temp file has correct prefix
        ResponseData responseData = new ResponseData() {
            @Override
            public InputStream getResponseBody() {
                return new ByteArrayInputStream("Test".getBytes());
            }

    // value. But in the specific case where the bottom two bits of the original number are 01, we
    // want to replace that with 1 in the shifted value for correct rounding.
    return (double) ((value >>> 1) | (value & 1)) * 2.0;
  }

  /** Returns the value of this {@code UnsignedLong} as a {@link BigInteger}. */
  public BigInteger bigIntegerValue() {

		{
			authString:    "NoV2Prefix",
			expectedError: ErrSignatureVersionNotSupported,
		},
		// Test case - 3.
		// Test case with missing parts in the Auth string.
		// below is the correct format of V2 Authorization header.
		// Authorization = "AWS" + " " + AWSAccessKeyId + ":" + Signature
		{
			authString:    signV2Algorithm,
			expectedError: ErrMissingFields,
		},
		// Test case - 4.

Puedes añadir múltiples parámetros de cuerpo a tu *path operation function*, aunque un request solo puede tener un único cuerpo.

Pero **FastAPI** lo manejará, te dará los datos correctos en tu función, y validará y documentará el esquema correcto en la *path operation*.

También puedes declarar valores singulares para ser recibidos como parte del cuerpo.

        assertArrayEquals(newFileId, actualFileId);

        assertEquals(104, bytesWritten); // 40 bytes header + 64 bytes input buffer
    }

    @Test
    @DisplayName("Test setFileInfoClass sets correct info type")
    void testSetFileInfoClassSetsCorrectInfoType() {
        request = new Smb2QueryInfoRequest(mockConfig);

        // Initially set a different info type
        request.setInfoType((byte) 0x05);