return QueueTestSuiteBuilder.using(
            new TestStringQueueGenerator() {
              @Override
              public Queue<String> create(String[] elements) {
                Queue<String> queue = new LinkedList<>(MinimalCollection.of(elements));
                return Collections.checkedQueue(queue, String.class);
              }
            })
        .named("checkedQueue/LinkedList")
        .withFeatures(

  private static final ImmutableNetwork<String, String> IMMUTABLE_NETWORK_A =
      NetworkBuilder.directed().<String, String>immutable().addNode("A").build();
  private static final ImmutableNetwork<String, String> IMMUTABLE_NETWORK_B =
      NetworkBuilder.directed().<String, String>immutable().addNode("B").build();

  public PackageSanityTests() {
    MutableNetwork<String, String> mutableNetworkA = NetworkBuilder.directed().build();

  @GwtIncompatible
  public void testAsAsyncCallable() throws Exception {
    final String expected = "MyCallableString";
    Callable<String> callable =
        new Callable<String>() {
          @Override
          public String call() throws Exception {
            return expected;
          }
        };

    AsyncCallable<String> asyncCallable =

                  @Override
                  protected Set<String> create(String[] elements) {
                    NavigableSet<String> set = new SafeTreeSet<>(Ordering.natural().nullsFirst());
                    Collections.addAll(set, elements);
                    return set;
                  }

                  @Override
                  public List<String> order(List<String> insertionOrder) {

                  @Override
                  protected Set<String> create(String[] elements) {
                    NavigableSet<String> set = new SafeTreeSet<>(Ordering.natural().nullsFirst());
                    Collections.addAll(set, elements);
                    return set;
                  }

                  @Override
                  public List<String> order(List<String> insertionOrder) {

        MultimapBuilder.hashKeys().arrayListValues().<String, Integer>build();
    SortedSetMultimap<String, Integer> b =
        rawtypeToWildcard(MultimapBuilder.linkedHashKeys().treeSetValues())
            .<String, Integer>build();
    SetMultimap<String, Integer> c =
        MultimapBuilder.treeKeys(String.CASE_INSENSITIVE_ORDER)
            .hashSetValues()
            .<String, Integer>build();
  }

                  @Override
                  protected SetMultimap<String, String> create(Entry<String, String>[] entries) {
                    TestMultimap<String, String> inner = new TestMultimap<>();
                    SetMultimap<String, String> outer =
                        Synchronized.setMultimap(inner, inner.mutex);
                    for (Entry<String, String> entry : entries) {

  private static final Integer N2 = 2;
  private static final Integer N3 = 3;

  private static final String E11 = "1-1";
  private static final String E12 = "1-2";
  private static final String E12_A = "1-2a";
  private static final String E13 = "1-3";

  private final EdgeType edgeType;
  private final MutableNetwork<Integer, String> network;

  // add parameters: directed/undirected
  @Parameters

public class MapsTransformValuesTest extends AbstractMapsTransformValuesTest {
  @Override
  protected Map<String, String> makeEmptyMap() {
    return Maps.transformValues(Maps.<String, String>newHashMap(), Functions.<String>identity());
  }

  @Override
  protected Map<String, String> makePopulatedMap() {
    Map<String, Integer> underlying = Maps.newHashMap();
    underlying.put("a", 1);
    underlying.put("b", 2);

                  @Override
                  protected Set<String> create(String[] elements) {
                    return new StandardImplForwardingNavigableSet<>(
                        new SafeTreeSet<String>(Arrays.asList(elements)));
                  }

                  @Override
                  public List<String> order(List<String> insertionOrder) {