try {
      hp2 = hp.withDefaultPort(defaultPort);
      assertFalse(badDefaultPort);
    } catch (IllegalArgumentException e) {
      assertTrue(badDefaultPort);
    }

    // Check the pre-withDefaultPort() instance.
    if (expectHasExplicitPort) {
      assertTrue(hp.hasPort());
      assertEquals(expectPort, hp.getPort());
    } else {
      assertFalse(hp.hasPort());
      try {

   *
   * <p>Note: This means that a test like the following will fail if {@code collection} is a {@code
   * Set}:
   *
   * <pre>
   * collection.add(existingElement);
   * expectAdded(existingElement);</pre>
   *
   * <p>In this case, {@code collection} was not modified as a result of the {@code add()} call, and

 * <p>
 * By statically importing this class, you can easily initialize {@literal Map} instances as follows:
 * </p>
 *
 * <pre>
 * import static org.codelibs.core.collection.Maps.*;
 *
 * Map&lt;String, Integer&gt; map = map("a", 1).$("b", 2).$("c", 3).$();
 * </pre>
 *
 * @author koichik
 * @param <K> the key type of the {@literal Map}
 * @param <V> the value type of the {@literal Map}
 */

    try {
      return Thread.class.getConstructor(
          ThreadGroup.class, Runnable.class, String.class, long.class, boolean.class);
    } catch (Throwable t) {
      // Probably pre Java 9. We'll fall back to Thread.inheritableThreadLocals.
      return null;
    }
  }

.termynal-comment {
  color: #4a968f;
  font-style: italic;
  display: block;
}

.termy {
  /* For right to left languages */
  direction: ltr;
}

.termy [data-termynal] {
  white-space: pre-wrap;
}

.termy .linenos {
  display: none;
}

a.external-link {
  /* For right to left languages */
  direction: ltr;
  display: inline-block;
}

a.external-link::after {
  /* \00A0 is a non-breaking space

   * are the "next" pointer (pointing to the next entry in the bucket chain), which will always be
   * less than or equal to the hashtable mask.
   *
   * <pre>
   * hash  = aaaaaaaa
   * mask  = 00000fff
   * next  = 00000bbb
   * entry = aaaaabbb
   * </pre>
   *
   * <p>The pointers in [size(), entries.length) are all "null" (UNSET).
   */
  private transient int @Nullable [] entries;

  /**

   *
   * <p>Suppose {@code x} is a queue known to contain only strings. The following code can be used
   * to dump the queue into a newly allocated array of {@code String}:
   *
   * <pre>
   *     String[] y = x.toArray(new String[0]);</pre>
   *
   * <p>Note that {@code toArray(new Object[0])} is identical in function to {@code toArray()}.
   *

 * the node's name, value, attributes, and child nodes.
 *
 * <p>Example usage:</p>
 * <pre>
 * XmlNode node = XmlNode.newBuilder()
 *     .name("configuration")
 *     .attribute("version", "1.0")
 *     .child(XmlNode.newInstance("property", "value"))
 *     .build();
 * </pre>
 *
 * @since 4.0.0
 */
@Experimental
@ThreadSafe
@Immutable
public interface XmlNode {

  }

  /** Returns the children of the specified node. Must not contain null. */
  public abstract Iterable<T> children(T root);

  /**
   * Returns an unmodifiable iterable over the nodes in a tree structure, using pre-order traversal.
   * That is, each node's subtrees are traversed after the node itself is returned.
   *
   * <p>No guarantees are made about the behavior of the traversal when nodes change while iteration

## Développement

Au moment où j'ai commencé à créer **FastAPI** lui-même, la plupart des pièces étaient déjà en place, la conception était définie, les exigences et les outils étaient prêts, et la connaissance des normes et des spécifications était claire et fraîche.

## Futur

À ce stade, il est déjà clair que **FastAPI** et ses idées sont utiles pour de nombreuses personnes.