firstException.addSuppressed(throwable)
          }
        }

        val nextPlan = connectResult.nextPlan
        if (nextPlan != null) {
          // Try this plan's successor before deferred plans because it won the race!
          routePlanner.deferredPlans.addFirst(nextPlan)
        }
      }
    } finally {
      cancelInFlightConnects()
    }

    throw firstException!!
  }

  /**

       * other callers have added to it.
       *
       * This read is guaranteed to get us the right value because we only set this once (here).
       *
       * requireNonNull is safe because either our compareAndSet succeeded or it failed because
       * another thread did it for us.
       */
      seenExceptionsLocal = requireNonNull(seenExceptionsField);
    }

# The table name '$$ALL$$' means all tables are target.
# The table names and column names are treated as case insensitive.
#
# You don't need specify here about table classifications.
# Because table classifications are auto-deployed by relation information.
#
# Specification:
# map: {
#     [table-name or $$ALL$$] = map:{
#         ; [column-name (with hint)]=[classification-name]
#     }
# }
#

    return wrapList(key, (List<V>) collection, null);
  }

  // Following Javadoc copied from ListMultimap.

  /**
   * {@inheritDoc}
   *
   * <p>Because the values for a given key may have duplicates and follow the insertion ordering,
   * this method returns a {@link List}, instead of the {@link Collection} specified in the {@link
   * Multimap} interface.
   */
  @Override

exemptAssignees: false

# Label to use when marking as stale
staleLabel: stale

# Comment to post when marking as stale. Set to `false` to disable
markComment: >-
  This issue has been automatically marked as stale because it has not had
  recent activity. It will be closed after 15 days if no further activity
  occurs. Thank you for your contributions.
# Comment to post when removing the stale label.
# unmarkComment: >
#   Your comment here.

  @Override
  int indexOf(@Nullable Object target) {
    if (!contains(target)) {
      return -1;
    }
    // The cast is safe because of the contains check—at least for any reasonable Comparable class.
    @SuppressWarnings("unchecked")
    // requireNonNull is safe because of the contains check.
    C c = (C) requireNonNull(target);
    return (int) domain.distance(first(), c);
  }

  @Override

ItemsService.createItemItemsPost({name: "Plumbus", price: 5})
```

...that's because the client generator uses the OpenAPI internal **operation ID** for each *path operation*.

OpenAPI requires that each operation ID is unique across all the *path operations*, so FastAPI uses the **function name**, the **path**, and the **HTTP method/operation** to generate that operation ID, because that way it can make sure that the operation IDs are unique.

 * family. <b>Avoid</b> creating a mock or stub {@code Future}. Mock and stub implementations are
 * fragile because they assume that only certain methods will be called and because they often
 * implement subtleties of the API improperly.
 *
 * <p><b>Custom implementation</b>: Avoid implementing {@code ListenableFuture} from scratch. If you

    }

  private val dispatcherB = ClosableDispatcher()

  @StartStop val serverB =
    MockWebServer().apply {
      dispatcher = dispatcherB
    }

  /** This one won't start because it isn't annotated. */
  private val dispatcherC = ClosableDispatcher()
  val serverC =
    MockWebServer().apply {
      dispatcher = dispatcherC
    }

  @Test
  fun happyPath() {
    testInstances += this

The way to describe this in OpenAPI, is to mark that field as **required**, because it will always be there.

Because of that, the JSON Schema for a model can be different depending on if it's used for **input or output**:

* for **input** the `description` will **not be required**