public void testViewSerialization() {
    Map<String, Integer> map = ImmutableSortedMap.of("one", 1, "two", 2, "three", 3);
    SerializableTester.reserializeAndAssert(map.entrySet());
    SerializableTester.reserializeAndAssert(map.keySet());
    assertEquals(
        new ArrayList<>(map.values()),
        new ArrayList<>(SerializableTester.reserialize(map.values())));
  }

  @GwtIncompatible // SerializableTester

            }
            return result;
          }
        });
  }

  @Override
  ImmutableSet<K> createKeySet() {
    return ImmutableSet.unsafeDelegate(delegate.keySet());
  }

  @Override
  ImmutableCollection<V> createValues() {
    return ImmutableCollection.unsafeDelegate(delegate.values());
  }

  @Override
  public int size() {
    return delegate.size();

Fragment Size Girth Radius Diameter Layer Layers Layer Number of classes Classes of layer : Classes and Packages Click on or to go to the cycle to which the class/package belongs. Class/Package Size Used by Uses internal Uses external Layer Source(s) # Member of cycle Classes using : uses: true uses: Packages using : uses: true uses: Classes of cycle : Best fragmenter(s) of cycle : Center classes of cycle : Packages of cycle : Best fragmenter(s) of cycle : Center packages of cycle : cursor:pointer; ja...

        }
        return t;
    }

    private List<String> findPossibleMatches(String fullyQualifiedClassName) {
        List<String> candidates = new ArrayList<String>();
        for (String className : classes.keySet()) {
            if (getLevenshteinDistance(fullyQualifiedClassName, className) < 8) {
                candidates.add(className);
            }
        }
        return candidates;
    }

    @Override

      Set<K> keySet = new HashSet<>();
      List<Entry<K, V>> builder = new ArrayList<>();
      for (Object o : elements) {
        Entry<?, ?> entry = (Entry<?, ?>) o;
        // These come from Entry<K, Collection<V>>> objects somewhere.
        @SuppressWarnings("unchecked")
        K key = (K) entry.getKey();
        keySet.add(key);

            for (String extension : checksums.keySet()) {
                ChecksumObserver observer = checksums.get(extension);
                sums.put(extension, observer.getActualChecksum());
            }

            // We do this in here so we can checksum the artifact metadata too, otherwise it could be metadata itself
            for (String extension : checksums.keySet()) {

import org.gradle.api.tasks.TaskAction


/**
 * This [Task][org.gradle.api.Task] reorders the changes in an accepted API changes files
 * so that they are alphabetically sorted (by type, then member).
 */
@CacheableTask
abstract class SortAcceptedApiChangesTask : AbstractAcceptedApiChangesMaintenanceTask() {

    @TaskAction
    fun execute() {

    this.delegate = delegate;
    checkArgument(!delegate.isEmpty());
  }

  @Override
  UnmodifiableIterator<K> keyIterator() {
    return Iterators.unmodifiableIterator(delegate.keySet().iterator());
  }

  @Override
  public int size() {
    return delegate.size();
  }

  @Override
  public boolean containsKey(@Nullable Object key) {
    return delegate.containsKey(key);
  }

  private List<E> values;
  private E a;
  private E b;
  private E c;

  @Override
  public void setUp() throws Exception {
    super.setUp();
    navigableSet = (NavigableSet<E>) getSet();
    values =
        copyToList(
            getSubjectGenerator()
                .getSampleElements(getSubjectGenerator().getCollectionSize().getNumElements()));
    sort(values, navigableSet.comparator());

  // views

  /**
   * Returns an immutable set of the distinct keys in this multimap, in the same order as they
   * appear in this multimap.
   */
  @Override
  public ImmutableSet<K> keySet() {
    return map.keySet();
  }

  @Override
  Set<K> createKeySet() {
    throw new AssertionError("unreachable");
  }

  /**