public class BiMapInverseTester<K, V> extends AbstractBiMapTester<K, V> {

  public void testInverseSame() {
    assertSame(getMap(), getMap().inverse().inverse());
  }

  @CollectionFeature.Require(SERIALIZABLE)
  public void testInverseSerialization() {
    BiMapPair<K, V> pair = new BiMapPair<>(getMap());
    BiMapPair<K, V> copy = SerializableTester.reserialize(pair);
    assertEquals(pair.forward, copy.forward);

  @CollectionSize.Require(ZERO)
  public void testIsEmpty_yes() {
    assertTrue("isEmpty() should return true", getMap().isEmpty());
  }

  @CollectionSize.Require(absent = ZERO)
  public void testIsEmpty_no() {
    assertFalse("isEmpty() should return false", getMap().isEmpty());
  }

    }

    /**
     * Tests that the getter for the underlying pipe resource returns the correct instance.
     */
    @Test
    public void testGetPipe() {
        assertEquals(mockPipeResource, smbPipeHandle.getPipe(), "getPipe() should return the underlying pipe resource.");
    }

    /**
     * Tests that the getter for the input stream returns the correct stream.

    }

    @Test
    @DisplayName("Test subCommand getter and setter")
    void testSubCommandGetterSetter() {
        byte subcommand = (byte) 0x05;
        response.setSubCommand(subcommand);
        assertEquals(subcommand, response.getSubCommand());
    }

    @Test
    @DisplayName("Test status getter and setter")
    void testStatusGetterSetter() {

        String response = checkGetMethod(searchBody, "").asString();

        logger.info("Stats response: {}", response);

        // Verify response structure
        final Map<String, Object> res = JsonPath.from(response).getMap("response");
        assertNotNull(res, "Response should not be null");

        // Verify status code
        Integer status = JsonPath.from(response).get("response.status");

    for (Entry<K, V> entry : getSampleEntries()) {
      expectedHashCode += hash(entry);
    }
    assertEquals(
        "A Map's hashCode() should be the sum of those of its entries.",
        expectedHashCode,
        getMap().hashCode());
  }

  @CollectionSize.Require(absent = CollectionSize.ZERO)
  @MapFeature.Require(ALLOWS_NULL_KEYS)
  public void testHashCode_containingNullKey() {
    Entry<K, V> entryWithNull = entry(null, v3());

        }

        MetadataGraphNode node = new MetadataGraphNode(md);
        addNode(node);
        return node;
    }

    /**
     * getter
     */
    public MetadataGraphNode getEntry() {
        return entry;
    }

    /**
     * getter
     */
    public Collection<MetadataGraphNode> getNodes() {
        return nodes;
    }

    }

    @Override
    public final Method getReadMethod() {
        return readMethod;
    }

    /**
     * Sets the getter method.
     *
     * @param readMethod
     *            The getter method.
     */
    protected final void setReadMethod(final Method readMethod) {
        this.readMethod = readMethod;
        if (readMethod != null) {

        assertNull(t.getMechanismToken(), "mechanismToken should default to null");
        assertNull(t.getMechanismListMIC(), "mechanismListMIC should default to null");
    }

    @Test
    @DisplayName("Setter and getter for mechanismToken work")
    void setGetMechanismToken() {
        TestSpnegoToken t = new TestSpnegoToken();
        byte[] data = new byte[] { 1, 2, 3 };
        t.setMechanismToken(data);

Primeiro, escreva toda a sua aplicação **FastAPI** normalmente:

{* ../../docs_src/extending_openapi/tutorial001_py310.py hl[1,4,7:9] *}

### Gerar o esquema OpenAPI { #generate-the-openapi-schema }

Em seguida, use a mesma função utilitária para gerar o esquema OpenAPI, dentro de uma função `custom_openapi()`:

{* ../../docs_src/extending_openapi/tutorial001_py310.py hl[2,15:21] *}