final Integer value;

    Foo(int value) {
      this.value = value;
    }

    @Override
    public int hashCode() {
      return value.hashCode();
    }

    @Override
    public boolean equals(@Nullable Object o) {
      return (o instanceof Foo) && ((Foo) o).value.equals(value);
    }

    @Override
    public int compareTo(Foo other) {
      return value.compareTo(other.value);
    }

   * {@link #tailMap}. If you override {@link #tailMap}, you may wish to override {@link
   * #containsKey} to forward to this implementation.
   *
   * @since 7.0
   */
  @Override
  protected boolean standardContainsKey(@CheckForNull Object key) {
    try {
      // any CCE or NPE will be caught
      @SuppressWarnings({"unchecked", "nullness"})

      return sourceFormat.to(targetFormat, s);
    }

    @Override
    protected String doBackward(String s) {
      return targetFormat.to(sourceFormat, s);
    }

    @Override
    public boolean equals(@CheckForNull Object object) {
      if (object instanceof StringConverter) {
        StringConverter that = (StringConverter) object;

  @Override
  public Hasher newHasher() {
    return new Murmur3_128Hasher(seed);
  }

  @Override
  public String toString() {
    return "Hashing.murmur3_128(" + seed + ")";
  }

  @Override
  public boolean equals(@CheckForNull Object object) {
    if (object instanceof Murmur3_128HashFunction) {
      Murmur3_128HashFunction other = (Murmur3_128HashFunction) object;
      return seed == other.seed;
    }
    return false;

            try (InputStream input = Files.newInputStream(metadataFile.toPath())) {
                metadata = new Metadata(new MetadataStaxReader().read(input, false));
            }
        }

        boolean changed;

        // If file could not be found or was not valid, start from scratch
        if (metadata == null) {
            metadata = this.metadata;

            changed = true;
        } else {

        result = prime * result + ((localFile == null) ? 0 : localFile.hashCode());
        result = prime * result + requestType;
        return result;
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if ((obj == null) || (getClass() != obj.getClass())) {
            return false;
        }

    private final Lookup lookup;

    private final LifecycleRegistry registry;

    private Map<String, Lifecycle> customLifecycles;

    private boolean lifecyclesPrinted;

    public DefaultLifecycles() {
        this.lookup = null;
        this.registry = null;
    }

    /**
     * @deprecated Use {@link #DefaultLifecycles(LifecycleRegistry,Lookup)} instead

import org.mortbay.log.Log;

/**
 * @author shinsuke
 *
 */
public class CrawlerWebServer {
    private int port = 8080;

    private File docRoot;

    private Server server;

    private boolean tempDocRoot = false;

    public CrawlerWebServer(final int port) {
        this(port, createDocRoot(3));
        tempDocRoot = true;
    }

    public CrawlerWebServer(final int port, final File docRoot) {

    Iterator<E> iterator;

    public ThrowsAtEndIterator(Iterable<E> iterable) {
      this.iterator = iterable.iterator();
    }

    @Override
    public boolean hasNext() {
      return true; // pretend that you have more...
    }

    @Override
    public E next() {
      // ...but throw an unchecked exception when you ask for it.
      if (!iterator.hasNext()) {

    }
  }

  public void testOverlapRejection() {
    for (Range<Integer> range1 : RANGES) {
      for (Range<Integer> range2 : RANGES) {
        boolean expectRejection =
            range1.isConnected(range2) && !range1.intersection(range2).isEmpty();
        ImmutableRangeMap.Builder<Integer, Integer> builder = ImmutableRangeMap.builder();