TestByteSink sink = new TestByteSink();

    assertFalse(sink.wasStreamOpened() || sink.wasStreamClosed());

    assertEquals(bytes.length, source.copyTo(sink));
    assertTrue(source.wasStreamOpened() && source.wasStreamClosed());
    assertTrue(sink.wasStreamOpened() && sink.wasStreamClosed());

    assertArrayEquals(bytes, sink.getBytes());
  }

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.jspecify.annotations.Nullable;

/**
 * Abstract {@link Hasher} that handles converting primitives to bytes using a scratch {@code
 * ByteBuffer} and streams all bytes to a sink to compute the hash.
 *
 * @author Colin Decker
 */
abstract class AbstractByteHasher extends AbstractHasher {
  private @Nullable ByteBuffer scratch;

   * and may affect the behavior of the returned sink and the streams it provides. See {@link
   * StandardOpenOption} for the standard options that may be provided. Providing no options is
   * equivalent to providing the {@link StandardOpenOption#CREATE CREATE}, {@link
   * StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING} and {@link StandardOpenOption#WRITE
   * WRITE} options.
   */

   * #add}, you may wish to override {@link #addAll} to forward to this implementation.
   *
   * @since 7.0
   */
  protected boolean standardAddAll(Collection<? extends E> collection) {
    return Iterators.addAll(this, collection.iterator());
  }

  /**
   * A sensible definition of {@link #remove} in terms of {@link #iterator}, using the iterator's

   * #add}, you may wish to override {@link #addAll} to forward to this implementation.
   *
   * @since 7.0
   */
  protected boolean standardAddAll(Collection<? extends E> collection) {
    return Iterators.addAll(this, collection.iterator());
  }

  /**
   * A sensible definition of {@link #remove} in terms of {@link #iterator}, using the iterator's

   * you override {@link #listIterator()}, you may wish to override {@link #iterator} to forward to
   * this implementation.
   *
   * @since 7.0
   */
  protected Iterator<E> standardIterator() {
    return listIterator();
  }

  /**
   * A sensible default implementation of {@link #listIterator()}, in terms of {@link

   *
   * <p>If the dataset contains {@link Double#NaN} then the result is {@link Double#NaN}. If it
   * contains both {@link Double#POSITIVE_INFINITY} and {@link Double#NEGATIVE_INFINITY} then the
   * result is {@link Double#NaN}. If it contains {@link Double#POSITIVE_INFINITY} and finite values
   * only or {@link Double#POSITIVE_INFINITY} only, the result is {@link Double#POSITIVE_INFINITY}.

 *
 * <ul>
 *   <li>{@link Ascii}
 *   <li>{@link CaseFormat}
 *   <li>{@link CharMatcher}
 *   <li>{@link Splitter}
 *   <li>{@link Strings}
 * </ul>
 *
 * <h3>Function types</h3>
 *
 * <ul>
 *   <li>{@link Converter}
 *   <li>{@link Equivalence}
 * </ul>
 *
 * <h3>Other</h3>
 *
 * <ul>
 *   <li>{@link Enums}
 *   <li>{@link MoreObjects}
 *   <li>{@link Preconditions}

     *            The {@link Reader} to read strings from. Must not be {@literal null}.
     * @return An {@link Iterable} that wraps a {@link LineIterator}.
     */
    public static Iterable<String> iterable(final Reader reader) {
        assertArgumentNotNull("reader", reader);
        return iterable(new BufferedReader(reader));
    }

    /**
     * Returns an {@link Iterable} that wraps a {@link LineIterator} for use in enhanced for-loops.

   JS sets data-external-link on links pointing outside the site
   Skip image links, .no-link-icon, and .announce-link */
a[data-external-link]:not(:has(img)):not(.no-link-icon):not(.announce-link) {
  /* For right to left languages */
  direction: ltr;
  display: inline-block;
}

a[data-external-link]:not(:has(img)):not(.no-link-icon):not(.announce-link)::after {
  content: "";
  display: inline-block;