byte[] dst = new byte[config[0]];
            int dstIndex = config[1];

            int result = response.writeBytesWireFormat(dst, dstIndex);

            assertEquals(0, result, String.format("Should return 0 for buffer size %d at index %d", config[0], config[1]));
        }
    }

By default MockWebServer uses a queue to specify a series of responses. Use a
Dispatcher (`import okhttp3.mockwebserver.Dispatcher`) to handle requests using another policy. One natural policy is to
dispatch on the request path.
You can, for example, filter the request instead of using `server.enqueue()`.

### Java
```java
final Dispatcher dispatcher = new Dispatcher() {

    @Override

        return isEmpty() || incidentEdges == null || incidentEdges.isEmpty();
    }
    // ------------------------------------------------------------------------
    @Override
    public String toString() {
        if (isEmpty()) {
            return "empty";
        }
        StringBuilder sb = new StringBuilder(512);
        for (MetadataGraphVertex v : vertices) {

    void testToStringWithAces() throws SMBProtocolDecodingException {
        prepareSecurityDescriptorBufferWithDACL(testBuffer, 0, 2);

        securityDescriptor.decode(testBuffer, 0, testBuffer.length);

        String result = securityDescriptor.toString();
        assertNotNull(result);
        assertTrue(result.startsWith("SecurityDescriptor:"));
        assertFalse(result.contains("NULL"));
    }

    @Test

@J2ktIncompatible
public final class EnumHashBiMap<K extends Enum<K>, V extends @Nullable Object>
    extends AbstractBiMap<K, V> {
  transient Class<K> keyTypeOrObjectUnderJ2cl;

  /**
   * Returns a new, empty {@code EnumHashBiMap} using the specified key type.
   *
   * @param keyType the key type
   */
  public static <K extends Enum<K>, V extends @Nullable Object> EnumHashBiMap<K, V> create(
      Class<K> keyType) {

If you declare it as is, because it is a singular value, **FastAPI** will assume that it is a query parameter.

But you can instruct **FastAPI** to treat it as another body key using `Body`:

{* ../../docs_src/body_multiple_params/tutorial003_an_py310.py hl[23] *}


In this case, **FastAPI** will expect a body like:

```JSON
{
    "item": {
        "name": "Foo",

    assertThat(source.request().url.encodedPath).isEqualTo("/")
    listener.assertFailure(code = 401, message = "{\"error\":{\"message\":\"No auth credentials found\",\"code\":401}}")
  }

  private fun newEventSource(accept: String? = null): EventSource {
    val builder =
      Request
        .Builder()
        .url(server.url("/"))
    if (accept != null) {
      builder.header("Accept", accept)
    }

 *   public <T> Iterable<? extends T> listIsSubtypeOfIterable(List<T> list) {
 *     return isSubtype(list);
 *   }
 *
 *   @TestSubtype
 *   public List<String> intListIsNotSubtypeOfStringList(List<Integer> intList) {
 *     return notSubtype(intList);
 *   }
 * }
 *
 * public void testMySubtypes() throws Exception {
 *   new MySubtypeTests().testAllDeclarations();
 * }

   * useful to call from vanilla JavaScript because it returns an instance of Class, which can't be
   * converted to a standard JavaScript type. (Contrast to something like String or boolean.) Since
   * we're not calling it from JavaScript, we suppress the warning.
   */
  @JsMethod
  @SuppressWarnings("unusable-by-js")

    /**
     * Returns the method.
     *
     * @return the method
     */
    Method getMethod();

    /**
     * Returns the method name.
     *
     * @return the method name
     */
    String getMethodName();

    /**
     * Returns an array of the method's parameter types.
     *
     * @return an array of the method's parameter types
     */
    Class<?>[] getParameterTypes();

    /**