*
   * @param values a series of values, which will be converted to {@code double} values (this may
   *     cause loss of precision)
   */
  public void addAll(Iterator<? extends Number> values) {
    while (values.hasNext()) {
      add(values.next().doubleValue());
    }
  }

  /**
   * Adds the given values to the dataset.
   *
   * @param values a series of values
   */
  public void addAll(double... values) {

import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.function.UnaryOperator;
import java.util.stream.Collectors;

                    boolean notified = false;
                    final Iterator<Entry<Long, Response>> iterator = this.response_map.entrySet().iterator();
                    while (iterator.hasNext()) {
                        final Response resp = iterator.next().getValue();
                        resp.exception(ex);
                        iterator.remove();
                        notified = true;

    tester.testAllPublicInstanceMethods(BloomFilter.create(Funnels.unencodedCharsFunnel(), 100));
    tester.testAllPublicStaticMethods(BloomFilter.class);
  }

  /** Tests that we never get an optimal hashes number of zero. */
  public void testOptimalHashes() {
    for (int n = 1; n < 1000; n++) {
      for (double p = 0.1; p > 1e-10; p /= 10) {
        assertThat(BloomFilter.optimalNumOfHashFunctions(p)).isGreaterThan(0);

      assertThat(q.poll()).isNull();
      assertThat(q.poll(0, MILLISECONDS)).isNull();
      assertEquals("[]", q.toString());
      assertThat(q.toArray()).isEmpty();
      assertFalse(q.iterator().hasNext());
      try {
        q.element();
        fail("Should throw exception");
      } catch (NoSuchElementException success) {
      }
      try {
        q.iterator().next();

   * into 29 bits):
   *
   * <ul>
   *   <li>If the IPv6 address contains an embedded IPv4 address, the function hashes that.
   *   <li>Otherwise, it hashes the upper 64 bits of the IPv6 address.
   * </ul>
   *
   * <p>A "coerced" IPv4 address is equivalent to itself.
   *

      return ByteStreams.readBytes(in, processor);
    } catch (Throwable e) {
      throw closer.rethrow(e);
    } finally {
      closer.close();
    }
  }

  /**
   * Hashes the contents of this byte source using the given hash function.
   *
   * @throws IOException if an I/O error occurs while reading from this source
   */
  public HashCode hash(HashFunction hashFunction) throws IOException {

     * input).
     */
    int ordinal();
  }

  /** The bit set of the BloomFilter (not necessarily power of 2!) */
  private final LockFreeBitArray bits;

  /** Number of hashes per element */
  private final int numHashFunctions;

  /** The funnel to translate Ts to bytes */
  private final Funnel<? super T> funnel;

     */
    @CanIgnoreReturnValue
    @Override
    public Builder<E> addAll(Iterator<? extends E> elements) {
      while (elements.hasNext()) {
        add(elements.next());
      }
      return this;
    }

    private void dedupAndCoalesceAndDeleteEmpty() {
      dedupAndCoalesce(false);

                throw new SmbException(url.toString(), last);
            }
            throw (SmbException) last;
        }

        final Iterator iter = map.keySet().iterator();
        while (iter.hasNext()) {
            e = (FileEntry) iter.next();
            final String name = e.getName();
            if (fnf != null && !fnf.accept(this, name)) {
                continue;
            }