import java.util.Map;
import java.util.Map.Entry;
import java.util.SortedMap;

@GwtCompatible
public abstract class AbstractImmutableSortedMapMapInterfaceTest<K, V>
    extends SortedMapInterfaceTest<K, V> {
  public AbstractImmutableSortedMapMapInterfaceTest() {
    super(false, false, false, false, false);
  }

  @Override
  protected SortedMap<K, V> makeEmptyMap() {
    throw new UnsupportedOperationException();
  }

 */

package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.TableCollectionTest.RowMapTests;
import java.util.Map;
import java.util.SortedMap;

@GwtCompatible
@ElementTypesAreNonnullByDefault
public class UnmodifiableRowSortedTableRowMapTest extends RowMapTests {
  public UnmodifiableRowSortedTableRowMapTest() {
    super(false, false, false, false);
  }

import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
import java.util.NoSuchElementException;
import java.util.SortedMap;
import org.junit.Ignore;

/**
 * A generic JUnit test which tests operations on a SortedMap. Can't be invoked directly; please see
 * {@code SortedMapTestSuiteBuilder}.
 *
 * @author Jesse Wilson
 * @author Louis Wasserman
 */
@GwtCompatible

        expect:
        def map = mapper.createEmptyMap(sourceType)
        map.getClass() == mapType

        where:
        sourceType | mapType
        Map        | LinkedHashMap
        SortedMap  | TreeMap
    }

        TestSortedMapGenerator<K, V> delegate, Bound to, Bound from) {
      super(delegate, to, from);
    }

    @Override
    NavigableMap<K, V> createSubMap(SortedMap<K, V> sortedMap, K firstExclusive, K lastExclusive) {
      NavigableMap<K, V> map = (NavigableMap<K, V>) sortedMap;
      if (from == Bound.NO_BOUND && to == Bound.INCLUSIVE) {
        return map.headMap(lastInclusive, true);

import java.util.List;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

/**
 * Provides supporting data for performance notes in the documentation of {@link
 * Ordering#sortedCopy} and {@link Ordering#immutableSortedCopy}, as well as for automated code
 * suggestions.
 *
 */
public class SortedCopyBenchmark {
  @Param({"1", "10", "1000", "1000000"})
  int size; // logarithmic triangular

import org.gradle.api.Namer;
import org.gradle.api.Rule;
import org.gradle.api.UnknownDomainObjectException;
import org.gradle.api.specs.Spec;

import java.util.List;
import java.util.SortedMap;
import java.util.SortedSet;

/**
 * A {@Link NamedDomainObjectSet} which delegates all methods to a provided delegate.
 */

  private static <K, V> SortedMap<K, V> sortedNotNavigable(final SortedMap<K, V> map) {
    return new ForwardingSortedMap<K, V>() {
      @Override
      protected SortedMap<K, V> delegate() {
        return map;
      }
    };
  }

  public void testSortedMapTransformValues() {
    SortedMap<String, Integer> map = sortedNotNavigable(ImmutableSortedMap.of("a", 4, "b", 9));

      SortedMap<K, V> sortedMap, @CheckForNull Object mutex) {
    return new SynchronizedSortedMap<>(sortedMap, mutex);
  }

  static class SynchronizedSortedMap<K extends @Nullable Object, V extends @Nullable Object>
      extends SynchronizedMap<K, V> implements SortedMap<K, V> {

    SynchronizedSortedMap(SortedMap<K, V> delegate, @CheckForNull Object mutex) {

      SortedMap<K, V> sortedMap, @CheckForNull Object mutex) {
    return new SynchronizedSortedMap<>(sortedMap, mutex);
  }

  static class SynchronizedSortedMap<K extends @Nullable Object, V extends @Nullable Object>
      extends SynchronizedMap<K, V> implements SortedMap<K, V> {

    SynchronizedSortedMap(SortedMap<K, V> delegate, @CheckForNull Object mutex) {