**FastAPI** will make sure to read that data from the right place instead of JSON.

/// note | Technical Details

Data from forms is normally encoded using the "media type" `application/x-www-form-urlencoded` when it doesn't include files.

But when the form includes files, it is encoded as `multipart/form-data`. If you use `File`, **FastAPI** will know it has to get the files from the correct part of the body.

        assertArrayEquals(rawBytes, avTargetName.getRaw(), "Raw bytes should match the input");
    }

    /**
     * Test constructor with a target name string.
     * Verifies that the string is correctly encoded to UTF-16LE bytes and stored.
     */
    @Test
    void testConstructorWithString() {
        String targetName = "AnotherTargetName";
        AvTargetName avTargetName = new AvTargetName(targetName);

    }

    /**
     * Verify that writeParameterWordsWireFormat writes the file id and the
     * unsigned time correctly.  The last write time is zero which should be
     * encoded as four 0xFF bytes by {@code writeUTime}.
     */
    @ParameterizedTest(name = "fid={0}, lastWriteTime={1}")
    @MethodSource("validParams")
    @DisplayName("happy: writeParameterWordsWireFormat writes correct bytes")

     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse index() {
        return asIndexHtml();
    }

    /**
     * Downloads a log file by its encoded ID.
     *
     * @param id the Base64 encoded filename of the log file to download
     * @return ActionResponse containing the log file stream
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })

     * Returns a new instance configured with a default encode set for the ASCII range. The specific
     * rules vary per-component: for example, '?' may be identity-encoded in a fragment, but must be
     * percent-encoded in a path.
     *
     * See https://url.spec.whatwg.org/#percent-encoded-bytes
     */
    fun newInstance(): UrlComponentEncodingTester =
      UrlComponentEncodingTester()
        .allAscii(Encoding.IDENTITY)

  private val bytesIn = Buffer()
  private val hpackReader = Hpack.Reader(bytesIn, 4096)

  protected fun testDecoder(story: Story) {
    for (testCase in story.cases) {
      val encoded = testCase.wire ?: continue
      bytesIn.write(encoded)
      hpackReader.readHeaders()
      assertSetEquals(
        "seqno=$testCase.seqno",
        testCase.headersList,
        hpackReader.getAndResetHeaderList(),
      )
    }
  }

    }

    @ParameterizedTest(name = "decode({1}) -> {2}")
    @MethodSource("decodeProvider")
    void testDecode(String encoded, byte[] expected) {
        // Act
        byte[] actual = Base64.decode(encoded);
        // Assert
        assertArrayEquals(expected, actual, "Base64.decode should return original bytes");
    }

    @Test

	IV        []byte
	Nonce     []byte
	Bytes     []byte
}

// UnmarshalJSON parses the given text as JSON-encoded
// ciphertext.
//
// UnmarshalJSON provides backward-compatible unmarsahaling
// of existing ciphertext. In the past, ciphertexts were
// JSON-encoded. Now, ciphertexts are binary-encoded.
// Therefore, there is no MarshalJSON implementation.
func (c *ciphertext) UnmarshalJSON(text []byte) error {
	const (

            int maxReferralLevel = -1;

            buffer = new DfsReferralRequestBuffer(path, maxReferralLevel);

            assertNotNull(buffer);
            // Negative values will be cast to unsigned when encoded
            assertEquals(4 + 2 * path.length(), buffer.size());
        }
    }

    @Nested
    @DisplayName("Size Calculation Tests")
    class SizeTests {

        @ParameterizedTest

  fun toUriWithControlCharacters() {
    // Percent-encoded in the path.
    assertThat("http://host/a\u0000b".toHttpUrl().toUri())
      .isEqualTo(URI("http://host/a%00b"))
    assertThat("http://host/a\u0080b".toHttpUrl().toUri())
      .isEqualTo(URI("http://host/a%C2%80b"))
    assertThat("http://host/a\u009fb".toHttpUrl().toUri())
      .isEqualTo(URI("http://host/a%C2%9Fb"))
    // Percent-encoded in the query.