private static final Iterable<Integer> iterable = Arrays.<Integer>asList();
  private static final Iterable<Integer> iterable1 = Arrays.asList(1);
  private static final Iterable<Integer> iterable12 = Arrays.asList(1, 2);
  private static final Iterable<Integer> iterable123 = Arrays.asList(1, 2, 3);
  private static final Iterable<@Nullable Integer> iterableNull = Arrays.asList((Integer) null);

            .addValue("")
            .addValue(null)
            .add(SHORT_NAME, Arrays.asList("A"))
            .add(LONG_NAME, Arrays.asList("B"))
            .add(SHORT_NAME, Arrays.asList())
            .add(LONG_NAME, Arrays.asList())
            .addValue(Arrays.asList("C"))
            .addValue(Arrays.asList())
            .add(SHORT_NAME, Collections.singletonMap("k1", "v1"))

    ServiceManager manager = new ServiceManager(asList(a, b));
    String toString = manager.toString();
    assertThat(toString).contains("NoOpService");
    assertThat(toString).contains("FailStartService");
  }

  public void testTimeouts() throws Exception {
    Service a = new NoOpDelayedService(50);
    ServiceManager manager = new ServiceManager(asList(a));
    manager.startAsync();

    holder.string = "two";
    assertEquals(Arrays.asList(1), builder.build().get("one"));
  }

  public void testBuilderPutAllIterable() {
    ImmutableListMultimap.Builder<String, Integer> builder = ImmutableListMultimap.builder();
    builder.putAll("foo", Arrays.asList(1, 2, 3));
    builder.putAll("bar", Arrays.asList(4, 5));
    builder.putAll("foo", Arrays.asList(6, 7));
    Multimap<String, Integer> multimap = builder.build();

    // re-order
    getAll(cache, asList(0, 1, 2));
    CacheTesting.drainRecencyQueues(cache);
    assertThat(keySet).containsExactly(3, 4, 5, 6, 7, 8, 9, 0, 1, 2);

    // evict 3, 4, 5
    getAll(cache, asList(10));
    CacheTesting.drainRecencyQueues(cache);
    assertThat(keySet).containsExactly(6, 7, 8, 9, 0, 1, 2, 10);

    // re-order
    getAll(cache, asList(6, 7, 8));

    // need explicit type parameter to avoid javac warning!?
    List<Double> none = Arrays.<Double>asList();
    assertThat(Doubles.toArray(none)).isEqualTo(EMPTY);

    List<Double> one = Arrays.asList(1.0);
    assertThat(Doubles.toArray(one)).isEqualTo(ARRAY1);

    double[] array = {0.0, 1.0, Math.PI};

    List<Double> three = Arrays.asList(0.0, 1.0, Math.PI);
    assertThat(Doubles.toArray(three)).isEqualTo(array);

  public void testReplaceValuesWithNullValue() {
    List<V> values = asList(v0(), null, v3());
    multimap().replaceValues(k0(), values);
    assertGet(k0(), values);
  }

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE, ALLOWS_NULL_KEYS})
  public void testReplaceValuesWithNullKey() {
    List<V> values = asList(v0(), v2(), v3());
    multimap().replaceValues(null, values);
    assertGet(null, values);
  }

    assertEqualIgnoringOrder(asList(expected), asList(actual));
  }

  private void expectArrayContentsInOrder(List<E> expected, Object[] actual) {
    assertEquals("toArray() ordered contents: ", expected, asList(actual));
  }

  /**
   * Returns the {@link Method} instance for {@link #testToArray_isPlainObjectArray()} so that tests
   * of {@link Arrays#asList(Object[])} can suppress it with {@code

    protected List<String> create(String[] elements) {
      return ImmutableList.<String>builder().addAll(asList(elements)).build();
    }
  }

  public static class BuilderReversedListGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {
      List<String> list = asList(elements);
      Collections.reverse(list);
      return ImmutableList.copyOf(list).reverse();
    }
  }

    return new OpenJdk6ListTests().allTests();
  }

  @Override
  protected Collection<Method> suppressForArraysAsList() {
    return asList(getToArrayIsPlainObjectArrayMethod());
  }

  @Override
  protected Collection<Method> suppressForCheckedList() {
    return asList(
        CollectionAddTester.getAddNullSupportedMethod(),
        getAddSupportedNullPresentMethod(),