*
   * <p>This method is not type-safe, as it may be called on elements that are not mutually
   * comparable.
   *
   * <p>This method is safe to use even when {@code elements} is a synchronized or concurrent
   * collection that is currently being modified by another thread.
   *
   * @throws ClassCastException if the elements are not mutually comparable

  /** The number of bytes of the POST body to keep in memory to the given limit. */
  public var bodyLimit: Long = Long.MAX_VALUE

  public var serverSocketFactory: ServerSocketFactory?
    @Synchronized get() = serverSocketFactory_

    @Synchronized set(value) {
      check(socketAddress_ == null) { "serverSocketFactory must not be set after start()" }
      serverSocketFactory_ = value
    }

  /**

    protected abstract FileEntry[] getResults();

    /**
     * Closes the enumeration and releases resources.
     *
     * @throws CIFSException if an error occurs during closing
     */
    protected synchronized void doClose() throws CIFSException {
        // otherwise already closed
        if (!this.closed) {
            this.closed = true;
            try {
                doCloseInternal();
            } finally {

# Asynchrone Tests { #async-tests }

Sie haben bereits gesehen, wie Sie Ihre **FastAPI**-Anwendungen mit dem bereitgestellten `TestClient` testen. Bisher haben Sie nur gesehen, wie man synchrone Tests schreibt, ohne `async`-Funktionen zu verwenden.

    }
  }

  private static final class TimeoutFutureException extends TimeoutException {
    private TimeoutFutureException(String message) {
      super(message);
    }

    @Override
    public synchronized Throwable fillInStackTrace() {
      setStackTrace(new StackTraceElement[0]);
      return this; // no stack trace, wouldn't be useful anyway
    }
  }

  @Override

    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbTreeHandle#close()
     */
    @Override
    public synchronized void close() {
        release();
    }

    /**
     * @return tree handle with increased usage count
     */
    public SmbTreeHandleImpl acquire() {

            if (pattern.matcher(input).matches()) {
                return Constants.FALSE;
            }
        }

        return Constants.TRUE;

    }

    protected synchronized void initDocPathPattern() {
        final SystemHelper systemHelper = ComponentUtil.getSystemHelper();

        if (includedDocPathPatterns == null) {
            if (StringUtil.isNotBlank(getIncludedDocPaths())) {

        // Test thread safety of fillInStackTrace method
        UserRoleLoginException exception = new UserRoleLoginException(RootAction.class);

        // Create multiple threads to test synchronized method
        Thread thread1 = new Thread(() -> {
            Throwable result = exception.fillInStackTrace();
            assertNull(result);
        });

        Thread thread2 = new Thread(() -> {

      while (true) {
        var tryAgain = false
        var readBytesDelivered = -1L
        var errorExceptionToDeliver: IOException? = null

        // 1. Decide what to do in a synchronized block.

        withLock {
          val doReadTimeout = doReadTimeout()
          if (doReadTimeout) {
            readTimeout.enter()
          }
          try {

        .suppressing(suppressForEnumSet())
        .createTestSuite();
  }

  /**
   * Tests regular NavigableSet behavior of synchronizedNavigableSet(treeSet); does not test the
   * fact that it's synchronized.
   */
  public Test testsForSynchronizedNavigableSet() {
    return NavigableSetTestSuiteBuilder.using(
            new TestStringSortedSetGenerator() {
              @Override