BiPredicate<ImmutableSetMultimap<?, ?>, ImmutableSetMultimap<?, ?>> equivalence =
        Equivalence.equals()
            .onResultOf(
                (ImmutableSetMultimap<?, ?> mm) ->
                    ImmutableListMultimap.copyOf(mm).asMap().entrySet().asList())
            .and(Equivalence.equals());
    CollectorTester.of(collector, equivalence)
        .expectCollects(ImmutableSetMultimap.of())

    return getConnectingEdge() == null ? 0 : 1;
  }

  @Override
  public boolean contains(@Nullable Object edge) {
    E connectingEdge = getConnectingEdge();
    return connectingEdge != null && connectingEdge.equals(edge);
  }

  private @Nullable E getConnectingEdge() {
    return nodeToOutEdge.get(targetNode);
  }

  }

  private final class EntrySet extends Entries implements Set<Entry<K, V>> {
    @Override
    public int hashCode() {
      return Sets.hashCodeImpl(this);
    }

    @Override
    public boolean equals(@Nullable Object o) {
      return Sets.equalsImpl(this, o);
    }
  }

     * if they are both <code>UniAddress</code>' and refer to the same IP address.
     */
    @Override
    public boolean equals(final Object obj) {
        return obj instanceof UniAddress && addr.equals(((UniAddress) obj).addr);
    }
    /*
    public boolean equals( Object obj ) {
        return obj instanceof UniAddress && addr.hashCode() == obj.hashCode();
    }
    */

    /**

    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj instanceof VersionRange other) {
            return Objects.equals(recommendedVersion, other.recommendedVersion)
                    && Objects.equals(restrictions, other.restrictions);
        } else {
            return false;
        }

   * array as the lesser. For example, {@code [] < ['a'] < ['a', 'b'] < ['b']}.
   *
   * <p>The returned comparator is inconsistent with {@link Object#equals(Object)} (since arrays
   * support only identity equality), but it is consistent with {@link Arrays#equals(char[],
   * char[])}.
   *
   * @since 2.0
   */
  public static Comparator<char[]> lexicographicalComparator() {

  }

  private final class EntrySet extends Entries implements Set<Entry<K, V>> {
    @Override
    public int hashCode() {
      return Sets.hashCodeImpl(this);
    }

    @Override
    public boolean equals(@Nullable Object o) {
      return Sets.equalsImpl(this, o);
    }
  }

    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null || getClass() != obj.getClass())
            return false;
        NetworkInterfaceInfo that = (NetworkInterfaceInfo) obj;
        return interfaceIndex == that.interfaceIndex && address != null ? address.equals(that.address) : that.address == null;
    }

    @Override

    Map<String, Integer> unfiltered = createUnfiltered();
    unfiltered.put("cat", 3);
    unfiltered.put("dog", 2);
    unfiltered.put("horse", 5);
    Predicate<Entry<?, ?>> predicate = e -> e.getKey().equals("cat") || e.getValue().equals(2);
    Map<String, Integer> filtered = Maps.filterEntries(unfiltered, predicate);
    assertEquals(ImmutableMap.of("cat", 3, "dog", 2), filtered);
  }

   * example, {@code [] < [1] < [1, 2] < [2]}.
   *
   * <p>The returned comparator is inconsistent with {@link Object#equals(Object)} (since arrays
   * support only identity equality), but it is consistent with {@link Arrays#equals(int[], int[])}.
   *
   * @since 2.0
   */
  public static Comparator<int[]> lexicographicalComparator() {
    return LexicographicalComparator.INSTANCE;
  }