}
      if (obj instanceof Wrapper) {
        Wrapper<?> that = (Wrapper<?>) obj; // note: not necessarily a Wrapper<T>

        if (this.equivalence.equals(that.equivalence)) {
          /*
           * We'll accept that as sufficient "proof" that either equivalence should be able to
           * handle either reference, so it's safe to circumvent compile-time type checking.
           */
          @SuppressWarnings("unchecked")

  }

  @Test
  fun incrementalIndexingWithStaticTableIndexedName() {
    hpackWriter!!.writeHeaders(headerEntries("accept-encoding", "gzip"))
    assertBytes(0x50, 4, 'g'.code, 'z'.code, 'i'.code, 'p'.code)
    assertThat(hpackWriter!!.headerCount).isEqualTo(1)
    hpackWriter!!.writeHeaders(headerEntries("accept-encoding", "gzip"))
    assertBytes(0xbe)
    assertThat(hpackWriter!!.headerCount).isEqualTo(1)
  }

  @Test

                .stream(out -> {
                    try (final Writer writer = new BufferedWriter(new OutputStreamWriter(out.stream(), Constants.CHARSET_UTF_8))) {
                        writeCall.accept(writer);
                        writer.flush();
                    } catch (final Exception e) {
                        logger.warn("Failed to write {} to response.", id, e);
                    }
                });

  // without the reference to unlimited queues.
  /**
   * Returns the number of additional elements that this queue can ideally (in the absence of memory
   * or resource constraints) accept without blocking. This is always equal to the initial capacity
   * of this queue less the current {@code size} of this queue.
   *

    }

    @Override
    public void forEach(BiConsumer<? super K, ? super V> action) {
      checkNotNull(action);
      // avoids allocation of entries
      backingSet().forEach(k -> action.accept(k, function.apply(k)));
    }
  }

  static <K extends @Nullable Object, V extends @Nullable Object>
      Iterator<Entry<K, V>> asMapEntryIterator(Set<K> set, Function<? super K, V> function) {

     *     `sslSocketFactory(SSLSocketFactory, X509TrustManager)`, which avoids such reflection.
     */
    @Deprecated(
      message = "Use the sslSocketFactory overload that accepts a X509TrustManager.",
      level = DeprecationLevel.ERROR,
    )
    fun sslSocketFactory(sslSocketFactory: SSLSocketFactory) =
      apply {
        if (sslSocketFactory != this.sslSocketFactoryOrNull) {

  }

  @J2ktIncompatible
  @GwtIncompatible // NullPointerTester
  public void testNullPointers() {
    /*
     * Don't bother testing: Preconditions defines a bunch of methods that accept a template (or
     * even entire message) that simultaneously:
     *
     * - _shouldn't_ be null, so we don't annotate it with @Nullable
     *

  }

  @J2ktIncompatible
  @GwtIncompatible // NullPointerTester
  public void testNullPointers() {
    /*
     * Don't bother testing: Preconditions defines a bunch of methods that accept a template (or
     * even entire message) that simultaneously:
     *
     * - _shouldn't_ be null, so we don't annotate it with @Nullable
     *

if any, in a manner that reasonably allows subsequent Recipients to identify
the originator of the Contribution.

   4. COMMERCIAL DISTRIBUTION

Commercial distributors of software may accept certain responsibilities with
respect to end users, business partners and the like. While this license is
intended to facilitate the commercial use of the Program, the Contributor

            capturedCmdList = new ArrayList<>(cmdList);

            ProcessBuilder pb = new ProcessBuilder(cmdList);
            capturedEnvironment = new HashMap<>(pb.environment());
            pbConsumer.accept(pb);
            capturedDirectory = pb.directory();
            capturedEnvironment = new HashMap<>(pb.environment());

            return new TestJobProcess(exitValue, processOutput);
        }