* Returns the last value corresponding to the specified field parsed as an HTTP date, or null if
   * either the field is absent or cannot be parsed as a date.
   */
  fun getDate(name: String): Date? = get(name)?.toHttpDateOrNull()

  /**
   * Returns the last value corresponding to the specified field parsed as an HTTP date, or null if
   * either the field is absent or cannot be parsed as a date.
   */

name: Enhancement Tracking Issue
description: Provide supporting details for a feature in development
labels: kind/feature
body:
  - type: textarea
    id: feature
    attributes:
      label: What would you like to be added?
      description: |
        Feature requests are unlikely to make progress as issues. Please consider engaging with SIGs on slack and mailing lists, instead.

    private final Adder adder;

    FailsToForwardReturnValue(Adder adder) {
      this.adder = adder;
    }

    @Override
    public int add(int a, int b) {
      return adder.add(a, b) + 1;
    }

    @Override
    public String toString() {
      return adder.toString();
    }
  }

  private static class FailsToPropagateException implements Adder {

    // Test addChain single
    public void test_addChain_single() {
        TestAuthenticationChain chain = new TestAuthenticationChain();
        authenticationManager.addChain(chain);

        // Verify chain was added by testing its effect
        User user = createTestUser("testuser");
        authenticationManager.insert(user);
        assertEquals(1, chain.updateCallCount);
    }

    // Test addChain multiple

    latch.countDown();

    exec.shutdown();
    exec.awaitTermination(100, MILLISECONDS);
  }

  /**
   * Tests that all listeners complete, even if they were added before or after the future was
   * finishing. Also acts as a concurrency test to make sure the locking is done correctly when a
   * future is finishing so that no listeners can be lost.
   */

  /**
   * Invoked when a {@code Future} computation fails or is canceled.
   *
   * <p>If the future's {@link Future#get() get} method throws an {@link ExecutionException}, then
   * the cause is passed to this method. Any other thrown object is passed unaltered.
   */
  void onFailure(Throwable t);

  }

  /**
   * A special purpose queue/executor that dispatches listener events serially on a configured
   * executor. Each event can be added and dispatched as separate phases.
   *
   * <p>This class is very similar to {@link SequentialExecutor} with the exception that events can
   * be added without necessarily executing immediately.
   */
  private static final class PerListenerQueue<L> implements Runnable {
    final L listener;

    private final ExecutionList executionList = new ExecutionList();

    // This allows us to only start up a thread waiting on the delegate future when the first
    // listener is added.
    private final AtomicBoolean hasListeners = new AtomicBoolean(false);

    // The delegate future.
    private final Future<V> delegate;

    ListenableFutureAdapter(Future<V> delegate) {

        chain.proceed(
          originalRequest
            .newBuilder()
            .addHeader("Request-Interceptor", "Android") // 1. Added first.
            .build(),
        )
      originalResponse
        .newBuilder()
        .addHeader("Response-Interceptor", "Donut") // 4. Added last.
        .build()
    }
    addInterceptor(network) { chain: Interceptor.Chain ->
      val originalRequest = chain.request()

    - [Node binaries](#node-binaries)
  - [Changelog since v1.16.14](#changelog-since-v11614)
  - [Changes by Kind](#changes-by-kind)
    - [Bug or Regression](#bug-or-regression)
  - [Dependencies](#dependencies)
    - [Added](#added)
    - [Changed](#changed)
    - [Removed](#removed)
- [v1.16.14](#v11614)
  - [Downloads for v1.16.14](#downloads-for-v11614)
    - [Source Code](#source-code-1)
    - [Client binaries](#client-binaries-1)