return new EntryComparator<K, V>(keyComparator);
  }

  /**
   * Asserts that all pairs of {@code T} values within {@code valuesInExpectedOrder} are ordered
   * consistently between their order within {@code valuesInExpectedOrder} and the order implied by
   * the given {@code comparator}.
   *
   * @see #testComparator(Comparator, List)
   */

      for (Entry<?, ?> entry : enumMap.entrySet()) {
        checkNotNull(entry.getKey());
        checkNotNull(entry.getValue());
      }
      @SuppressWarnings({"unchecked", "rawtypes"})
      // immutable collections are safe for covariant casts
      // and getting the generics right for EnumMap is difficult to impossible
      ImmutableMap<K, V> result = ImmutableEnumMap.asImmutable(new EnumMap(enumMap));
      return result;
    }

    assertThat(responseB.body.string()).isEqualTo("b")
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)
  }

  /** Confirm suppressed exceptions that occur while connecting are returned. */
  @Test fun connectExceptionsAreReturnedAsSuppressed() {
    val proxySelector = RecordingProxySelector()
    proxySelector.proxies.add(Proxy(Proxy.Type.HTTP, TestUtil.UNREACHABLE_ADDRESS_IPV4))

        // Subsequent get should still work
        assertEquals(4, impl.getBuffer().length);
    }

    // Capacity behavior: when full, additional releases are dropped; only cached buffers are returned
    @Test
    @DisplayName("Cache capacity respected: extra releases dropped; retrieval order by first free slot")
    void cacheCapacityAndRetrievalOrder() {

Vor einiger Zeit fragte <a href="https://github.com/fastapi/fastapi/issues/3#issuecomment-454956920" class="external-link" target="_blank">ein **FastAPI**-Benutzer</a>:

> Was ist die Geschichte dieses Projekts? Es scheint, als wäre es in ein paar Wochen aus dem Nichts zu etwas Großartigem geworden [...]

Hier ist ein wenig über diese Geschichte.

## Alternativen

    validations:
      required: true
  - type: textarea
    id: code-to-reproduce
    attributes:
      label: Standalone code to reproduce the issue
      description: Provide a reproducible test case that is the bare minimum necessary to generate the problem. Please share a link to Colab, Jupyter, or any notebook.
      placeholder: Tell us what you see!
      value:
      render: shell
    validations:
      required: true

 * and initializing on first use.
 *
 * We use this because eager classpath checks cause confusion and excessive logging in Android,
 * and we can't rely on classnames after proguard, so are probably best served by falling through
 * to a situation of trying our least likely noisiest options.
 */
class DeferredSocketAdapter(
  private val socketAdapterFactory: Factory,
) : SocketAdapter {

    assertSame(b1, b2);
  }

  public void testFirstNonNull_throwsNullPointerException() {
    assertThrows(NullPointerException.class, () -> MoreObjects.firstNonNull(null, null));
  }

  // ToStringHelper's tests are in ToStringHelperTest

  @J2ktIncompatible
  @GwtIncompatible("NullPointerTester")
  public void testNulls() throws Exception {
    NullPointerTester tester = new NullPointerTester();

    }

    public void overriddenAndAnnotatedInSubclass(Object o) {
      overriddenAndAnnotatedInSubclassEvents.add(o);
    }
  }

  static class SubClass extends SuperClass {
    @Override
    // We are testing how we treat an override with the same behavior and annotations.
    @SuppressWarnings("RedundantOverride")
    public void overriddenInSubclassNowhereAnnotated(Object o) {
      super.overriddenInSubclassNowhereAnnotated(o);

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal.smb2.rdma;

/**
 * RDMA credit management for flow control.
 *
 * Credits are used to control the flow of messages between
 * RDMA peers to prevent buffer overflow.
 */
public class RdmaCredits {

    private int initialCredits;
    private int creditsGranted;

    /**