assertEquals(32, derived1.length, "Derived key should have correct length");
        assertEquals(32, derived2.length, "Derived key should have correct length");
        assertEquals(32, derived3.length, "Derived key should have correct length");

        assertFalse(Arrays.equals(derived1, derived2), "Different labels should produce different keys");

        assertEquals(2, pairs.size(), "Should have 2 pairs after replace");
        assertTrue(AvPairs.contains(pairs, AvPair.MsvAvFlags), "Should contain MsvAvFlags");
        assertTrue(AvPairs.contains(pairs, AvPair.MsvAvTimestamp), "Should still contain MsvAvTimestamp");

        AvPair result = AvPairs.get(pairs, AvPair.MsvAvFlags);
        assertEquals(newFlags, result, "Should have the new flags instance");
    }

    /**

Notice that the default value is still `None`, so the parameter is still optional.

But now, having `Query(max_length=50)` inside of `Annotated`, we are telling FastAPI that we want it to have **additional validation** for this value, we want it to have maximum 50 characters. 😎

/// tip

As said in the section [Alternatives](alternatives.md):

<blockquote markdown="1">

**FastAPI** wouldn't exist if not for the previous work of others.

There have been many tools created before that have helped inspire its creation.

I have been avoiding the creation of a new framework for several years. First I tried to solve all the features covered by **FastAPI** using many different frameworks, plug-ins, and tools.

        assertNotNull(paramAnnotations, "Parameter annotations should exist");
        assertEquals("Should have one parameter", 1, paramAnnotations.length);
        assertEquals("Parameter should have one annotation", 1, paramAnnotations[0].length);

        final UriType annotation = (UriType) paramAnnotations[0][0];

   */
  public static final MediaType VND_REAL_AUDIO = createConstant(AUDIO_TYPE, "vnd.rn-realaudio");

  /**
   * WAVE format, as defined by <a href="https://tools.ietf.org/html/rfc2361">RFC 2361</a>.
   *
   * @since 20.0
   */
  public static final MediaType VND_WAVE_AUDIO = createConstant(AUDIO_TYPE, "vnd.wave");

  /* video types */
  public static final MediaType MP4_VIDEO = createConstant(VIDEO_TYPE, "mp4");

            continue@eachQueue
          }

          // If we already have more than one task, that's enough work for now. Stop searching.
          readyTask != null -> {
            multipleReadyTasks = true
            break@eachQueue
          }

          // We have a task to execute when we complete the loop.
          else -> {
            readyTask = candidate
          }

* don't have a `Content-Type` header (e.g. using `fetch()` with a `Blob` body)
* and don't send any authentication credentials.

This type of attack is mainly relevant when:

* the application is running locally (e.g. on `localhost`) or in an internal network
* and the application doesn't have any authentication, it expects that any request from the same network can be trusted.

        assertTrue("Should query reading_0", queryString.contains("reading_0"));
        assertTrue("Should query reading_1", queryString.contains("reading_1"));
        // Should NOT have reading_2 (spaces collapsed)
        assertFalse("Should not have reading_2", queryString.contains("reading_2"));
    }

    @Test
    public void test_buildQuery_withNormalizer() {
        Normalizer normalizer = new Normalizer() {

        assertEquals(1, stats.getRdmaReads(), "Should have 1 read operation");
        assertEquals(1, stats.getRdmaWrites(), "Should have 1 write operation");
        assertEquals(1, stats.getRdmaSends(), "Should have 1 send operation");
        assertEquals(1, stats.getRdmaReceives(), "Should have 1 receive operation");
        assertEquals(5120, stats.getBytesTransferred(), "Should have transferred 5KB total");