private static void closeAll(BaseStream<?, ?>[] toClose) {
    // If one of the streams throws an exception, continue closing the others, then throw the
    // exception later. If more than one stream throws an exception, the later ones are added to the
    // first as suppressed exceptions. We don't catch Error on the grounds that it should be allowed
    // to propagate immediately.
    Exception exception = null;

            final SmbTransportInternal trans = dc.unwrap(SmbTransportInternal.class);
            // the tconHostName is from the DC referral, that referral must be resolved
            // before following deeper ones. Otherwise e.g. samba will return a broken
            // referral.
            synchronized (trans) {
                try {
                    // ensure connected
                    trans.ensureConnected();

 *  Fix: Don't crash if a TLS tunnel's response body is truncated.
 *  Fix: Don't track unusable routes beyond their usefulness. We had a bug where we could track
    certain bad routes indefinitely; now we only track the ones that could be necessary.
 *  Fix: Defer proxy selection until a proxy is required. This saves calls to `ProxySelector` on
    calls that use a pooled connection.


## Version 4.3.1

_2020-01-07_

data.placement\n  );\n\n  data.offsets.popper.position = this.options.positionFixed\n    ? 'fixed'\n    : 'absolute';\n\n  // run the modifiers\n  data = runModifiers(this.modifiers, data);\n\n  // the first `update` will call `onCreate` callback\n  // the other ones will call `onUpdate` callback\n  if (!this.state.isCreated) {\n    this.state.isCreated = true;\n    this.options.onCreate(data);\n  } else {\n    this.options.onUpdate(data);\n  }\n}\n","/**\n * Helper used to know if the given modifier is enabled.\n...

      iterables.add(Ordering.<Integer>natural().sortedCopy(list));
    }

    verifyMergeSorted(iterables, allIntegers);
  }

  // Like the pyramid, but creates more unique values, along with repeated ones.
  public void testMergeSorted_skipping_pyramid() {
    List<Iterable<Integer>> iterables = new LinkedList<>();
    List<Integer> allIntegers = new ArrayList<>();

    for (int i = 0; i < 20; i++) {

      iterables.add(Ordering.<Integer>natural().sortedCopy(list));
    }

    verifyMergeSorted(iterables, allIntegers);
  }

  // Like the pyramid, but creates more unique values, along with repeated ones.
  public void testMergeSorted_skipping_pyramid() {
    List<Iterable<Integer>> iterables = new LinkedList<>();
    List<Integer> allIntegers = new ArrayList<>();

    for (int i = 0; i < 20; i++) {

    assertThat(hpackReader!!.getAndResetHeaderList()).isEqualTo(
      headerEntries("custom-key", "custom-header"),
    )
  }

  /** Oldest entries are evicted to support newer ones.  */
  @Test
  fun writerEviction() {
    val headerBlock =
      headerEntries(
        "custom-foo",
        "custom-header",
        "custom-bar",
        "custom-header",
        "custom-baz",

      }
    }
  }

  /**
   * Returns an object that can be used to wait until this objects' deferred closeables have all had
   * {@link Runnable}s that close them submitted to each one's closing {@link Executor}.
   */
  @VisibleForTesting
  CountDownLatch whenClosedCountDown() {
    return closeables.whenClosedCountDown();
  }

  /** The state of a {@link CloseableList}. */

boots every Christmas.'

  And she went on planning to herself how she would manage it.
`They must go by the carrier,' she thought; `and how funny it'll
seem, sending presents to one's own feet!  And how odd the
directions will look!

            ALICE'S RIGHT FOOT, ESQ.
                HEARTHRUG,
                    NEAR THE FENDER,
                        (WITH ALICE'S LOVE).

    `runningCalls()` and `queuedCalls()` methods. You can write code that
    selects calls by tag, host, or whatever, and invokes `Call.cancel()` on the
    ones that are no longer necessary.

 *  **OkHttp no longer uses the global `java.net.Authenticator` by default.**
    We've changed our `Authenticator` interface to authenticate web and proxy