// TODO(kevinb): Support a concurrently modified collection?
    Iterable<E> iterable = getDelegate();
    if (iterable instanceof List) {
      List<E> list = (List<E>) iterable;
      if (list.isEmpty()) {
        return Optional.absent();
      }
      return Optional.of(list.get(list.size() - 1));
    }
    Iterator<E> iterator = iterable.iterator();
    if (!iterator.hasNext()) {

    val calls = connection.calls
    val index = calls.indexOfFirst { it.get() == this@RealCall }
    check(index != -1)

    calls.removeAt(index)
    this.connection = null

    if (calls.isEmpty()) {
      connection.idleAtNs = System.nanoTime()
      if (connectionPool.connectionBecameIdle(connection)) {
        return connection.socket()
      }
    }

    return null
  }

                    Set<String> pluginsForThisPom = pluginsNeedingManagement.get(pomPath);
                    if (pluginsForThisPom != null && !pluginsForThisPom.isEmpty()) {
                        hasUpgrades |= addPluginManagementForEffectivePlugins(context, pomDocument, pluginsForThisPom);
                        context.detail("Added plugin management to " + pomPath + " (target parent for "

  }

  @Test
  public void edgeValue_directed_backwards() {
    graph = ValueGraphBuilder.directed().build();
    graph.putEdgeValue(1, 2, "A");
    assertThat(graph.edgeValue(EndpointPair.ordered(2, 1))).isEmpty();
  }

  @Test
  public void edgeValue_directed_mismatch() {
    graph = ValueGraphBuilder.directed().build();
    graph.putEdgeValue(1, 2, "A");
    IllegalArgumentException e =
        assertThrows(

    }

    private static Method getMostSpecific(List<Method> methods, Class<?>... classes) throws AmbiguousException {
        LinkedList<Method> applicables = getApplicables(methods, classes);

        if (applicables.isEmpty()) {
            return null;
        }

        if (applicables.size() == 1) {
            return applicables.getFirst();
        }

   */
  @Nullable V get(
      @CompatibleWith("R") @Nullable Object rowKey,
      @CompatibleWith("C") @Nullable Object columnKey);

  /** Returns {@code true} if the table contains no mappings. */
  boolean isEmpty();

  /** Returns the number of row key / column key / value mappings in the table. */
  int size();

  /**
   * Compares the specified object with this table for equality. Two tables are equal when their

  public void testToArrayEmpty() {
    Iterator<String> iterator = Collections.<String>emptyList().iterator();
    String[] array = Iterators.toArray(iterator, String.class);
    assertThat(array).isEmpty();
  }

  @GwtIncompatible // Iterators.toArray(Iterator, Class)
  public void testToArraySingleton() {
    Iterator<String> iterator = singletonList("a").iterator();

    }

    @Override
    public Collection<V2> get(@ParametricNullness K key) {
      return transform(key, fromMultimap.get(key));
    }

    @Override
    public boolean isEmpty() {
      return fromMultimap.isEmpty();
    }

    @Override
    Set<K> createKeySet() {
      return fromMultimap.keySet();
    }

    @Override
    Multiset<K> createKeys() {

   *     all other requests.
   */
  @Throws(IOException::class)
  fun takeHeaders(callerIsIdle: Boolean = false): Headers {
    withLock {
      while (headersQueue.isEmpty() && errorCode == null) {
        val doReadTimeout = callerIsIdle || doReadTimeout()
        if (doReadTimeout) {
          readTimeout.enter()
        }
        try {
          waitForIo()
        } finally {

    ImmutableList<String> result = builder.build();

    /*
     * Maybe it rejects all elements, or maybe it adds "a" before failing.
     * Either way is fine with us.
     */
    if (result.isEmpty()) {
      return;
    }
    assertTrue(ImmutableList.of("a").equals(result));
    assertEquals(1, result.size());
  }

  public void testBuilderAddCollectionHandlesNulls() {