/** Creates a new instance with the specified edge directionality. */
  private NetworkBuilder(boolean directed) {
    super(directed);
  }

  /** Returns a {@link NetworkBuilder} for building directed networks. */
  public static NetworkBuilder<Object, Object> directed() {
    return new NetworkBuilder<>(true);
  }

  /** Returns a {@link NetworkBuilder} for building undirected networks. */

/// check | Testen

Sprich, mit der gleichen Python-Typdeklaration gibt Ihnen **FastAPI** Datenvalidierung.

Beachten Sie, dass die Fehlermeldung auch direkt die Stelle anzeigt, wo die Validierung nicht erfolgreich war.

Das ist unglaublich hilfreich, wenn Sie Code entwickeln und debuggen, welcher mit Ihrer API interagiert.

///

## Dokumentation { #documentation }

     * that edge to {@code value} (overwriting the existing value, if any).
     *
     * <p>If the graph is directed, the resultant edge will be directed; otherwise, it will be
     * undirected.
     *
     * <p>If this graph is directed, {@code endpoints} must be ordered.
     *
     * <p>Values do not have to be unique. However, values must be non-null.
     *

        final ByteArrayOutputStream bos = new ByteArrayOutputStream();

        for (final String dialect : this.dialects) {
            bos.write(0x02);
            try {
                bos.write(Strings.getASCIIBytes(dialect));
            } catch (final IOException e) {
                throw new RuntimeCIFSException(e);
            }
            bos.write(0x0);
        }

    public Smb2SigningDigest getDigest() {
        return this.digest;
    }

    /**
     *
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlock#setDigest(jcifs.internal.SMBSigningDigest)
     */
    @Override
    public void setDigest(final SMBSigningDigest digest) {
        this.digest = (Smb2SigningDigest) digest;
        if (this.next != null) {

   * @throws IllegalArgumentException if the endpoints are unordered and the network is directed
   * @since 27.1
   */
  Set<E> edgesConnecting(EndpointPair<N> endpoints);

  /**
   * Returns the single edge that directly connects {@code nodeU} to {@code nodeV}, if one is
   * present, or {@code null} if no such edge exists.
   *

  }

  private static SuccessorsFunction<Character> createDirectedGraph(String... edges) {
    return createGraph(/* directed= */ true, edges);
  }

  private static SuccessorsFunction<Character> createUndirectedGraph(String... edges) {
    return createGraph(/* directed= */ false, edges);
  }

  /**
   * Creates a graph from a list of node pairs (encoded as strings, e.g. "ab" means that this graph

import java.util.logging.Level;
import org.jspecify.annotations.Nullable;

/**
 * The {@code CycleDetectingLockFactory} creates {@link ReentrantLock} instances and {@link
 * ReentrantReadWriteLock} instances that detect potential deadlock by checking for cycles in lock
 * acquisition order.
 *
 * <p>Potential deadlocks detected when calling the {@code lock()}, {@code lockInterruptibly()}, or

                dialect == Smb2Constants.SMB2_DIALECT_0311 ? preauthIntegrity : SIGNCONTEXT_300);
    }

    /**
     * Derives the SMB3 application key from the session key using the appropriate KDF for the dialect.
     *
     * @param dialect the SMB dialect version
     * @param sessionKey the base session key

        SmbComNegotiateResponse smb1 = new SmbComNegotiateResponse(ctx);
        setField(transport, "negotiated", smb1);
        assertFalse(transport.isSMB2());
    }

    @Test
    @DisplayName("Digest setter/getter roundtrip")
    void digestRoundtrip() {
        SMBSigningDigest dg = mock(SMBSigningDigest.class);
        transport.setDigest(dg);
        assertSame(dg, transport.getDigest());
    }