* socket that could receive both IPv4 and IPv6 connections (by disabling the {@code IPV6_V6ONLY}
 * socket option on an IPv6 socket). Yes, it's confusing. Nevertheless, these "mapped" addresses
 * were never supposed to be seen on the wire. That assumption was dropped, some say mistakenly, in
 * later RFCs with the apparent aim of making IPv4-to-IPv6 transition simpler.
 *

    ImmutableList.Builder<Integer> webSafeColorsBuilder = ImmutableList.builder();
    for (Integer red : colorElem) {
      for (Integer green : colorElem) {
        for (Integer blue : colorElem) {
          webSafeColorsBuilder.add((red << 16) + (green << 8) + blue);
        }
      }
    }
    ImmutableList<Integer> webSafeColors = webSafeColorsBuilder.build();
    assertEquals(216, webSafeColors.size());

seemed to rise like a stalk out of a sea of green leaves that lay
far below her.

  `What CAN all that green stuff be?' said Alice.  `And where
HAVE my shoulders got to?  And oh, my poor hands, how is it I
can't see you?'  She was moving them about as she spoke, but no
result seemed to follow, except a little shaking among the
distant green leaves.

    if (seenExceptions == null) {
      seenExceptions = newHashSet();
      addInitialException(seenExceptions);
    }
    return seenExceptions;
  }

  abstract void addInitialException(Set<Throwable> seen);

  final int decrementRemainingAndGet() {
    return --remaining;
  }

  final void clearSeenExceptions() {
    seenExceptions = null;
  }

      for (Entry<E> entry : insertionOrder) {
        map.put(entry.getElement(), entry);
      }

      Set<E> seen = new HashSet<>();
      List<Entry<E>> order = new ArrayList<>();
      for (E e : gen.order(new ArrayList<E>(map.keySet()))) {
        if (seen.add(e)) {
          order.add(map.get(e));
        }
      }
      return order;
    }
  }

                });

    // To start, fill up the cache.
    // Each miss both increments the counter and causes the map to grow by one,
    // so until evictions begin, the size of the map is the greatest return
    // value seen so far
    while (cache.getUnchecked(nextRandomKey()) < maximumSize) {}

    requests.set(0);
    misses.set(0);
  }

  @Benchmark
  int time(int reps) {
    int dummy = 0;

            assertEquals(newHashSet(elements), multimap.get("foo"));
          }
        };

    tester.test();
  }

  private enum Color {
    BLUE,
    RED,
    YELLOW,
    GREEN
  }

  private abstract static class CountingSupplier<E> implements Supplier<E>, Serializable {
    int count;

    abstract E getImpl();

    @Override
    public E get() {
      count++;

  // the "short hash".
  //
  // The `keys`, `values`, and `entries` arrays always have the same size as each other. They can be
  // seen as fields of an imaginary `Entry` object like this:
  //
  // class Entry {
  //    int hash;
  //    Entry next;
  //    K key;
  //    V value;
  // }
  //

   *
   * <pre>{@code
   * Color red = new Color("red", 255, 0, 0);
   * ...
   * FluentIterable<Color> allColors = FluentIterable.from(ImmutableSet.of(red, green, blue));
   *
   * Map<String, Color> colorForName = allColors.uniqueIndex(toStringFunction());
   * assertThat(colorForName).containsEntry("red", red);
   * }</pre>
   *

   * Example usage:
   *
   * <pre>{@code
   * Color red = new Color("red", 255, 0, 0);
   * ...
   * ImmutableSet<Color> allColors = ImmutableSet.of(red, green, blue);
   *
   * ImmutableMap<String, Color> colorForName =
   *     uniqueIndex(allColors, c -> c.toString());
   * assertThat(colorForName).containsEntry("red", red);
   * }</pre>
   *