*/
  @GwtIncompatible // Array.newInstance(Class, int)
  public static <T extends @Nullable Object> T[] toArray(
      Iterator<? extends T> iterator, Class<@NonNull T> type) {
    List<T> list = Lists.newArrayList(iterator);
    return Iterables.<T>toArray(list, type);
  }

  /**
   * Adds all elements in {@code iterator} to {@code collection}. The iterator will be left

    DefineT(num_opers, opers, ToOutput(inputs), ToOutput(outputs), output_names,
            expect_failure);
  }

  // Caller must delete[] the returned value
  static const char** ToArray(const std::vector<string>& strs) {
    const char** ptr = nullptr;
    if (!strs.empty()) {
      ptr = new const char*[strs.size()];
      for (size_t i = 0; i < strs.size(); ++i) {
        ptr[i] = strs[i].c_str();

      return forward.descendingIterator();
    }

    @Override
    public @Nullable Object[] toArray() {
      return standardToArray();
    }

    @Override
    @SuppressWarnings("nullness") // b/192354773 in our checker affects toArray declarations
    public <T extends @Nullable Object> T[] toArray(T[] array) {
      return standardToArray(array);
    }

    @Override

    assertThrows(UnsupportedOperationException.class, () -> entry.setValue("four"));
    @SuppressWarnings("unchecked")
    Entry<Integer, String> entry2 = (Entry<Integer, String>) entries.toArray()[0];
    assertThrows(UnsupportedOperationException.class, () -> entry2.setValue("four"));
  }

  public void testImmutableEntry() {
    Entry<String, Integer> e = immutableEntry("foo", 1);

          // So just refuse to generate.
          return null;
        }
        args.add(argValue);
      }
      return invokeGeneratorMethod(generate, args.toArray());
    }
    return defaultGenerate(rawType);
  }

  private <T> @Nullable T defaultGenerate(Class<T> rawType) {
    if (rawType.isInterface()) {
      // always create a new proxy

      Iterable<? extends Entry<? extends K, ? extends V>> entries) {
    @SuppressWarnings("unchecked") // we'll only be using getKey and getValue, which are covariant
    Entry<K, V>[] entryArray = (Entry<K, V>[]) Iterables.toArray(entries, EMPTY_ENTRY_ARRAY);
    switch (entryArray.length) {
      case 0:
        return of();
      case 1:
        Entry<K, V> entry = entryArray[0];
        return of(entry.getKey(), entry.getValue());

    assertThrows(UnsupportedOperationException.class, () -> entry.setValue("four"));
    @SuppressWarnings("unchecked")
    Entry<Integer, String> entry2 = (Entry<Integer, String>) entries.toArray()[0];
    assertThrows(UnsupportedOperationException.class, () -> entry2.setValue("four"));
  }

  public void testImmutableEntry() {
    Entry<String, Integer> e = immutableEntry("foo", 1);

                      @Override
                      public String apply(String input) {
                        throw new IndexOutOfBoundsException();
                      }
                    })
                .toArray());
  }

  private static void assertTransformListIterator(List<String> list) {
    ListIterator<String> iterator = list.listIterator(1);
    assertEquals(1, iterator.nextIndex());

          if (combined.size() > 1) { // Object is implicit and only useful if it's the only bound.
            combined.remove(Object.class);
          }
          return super.captureAsTypeVariable(combined.toArray(new Type[0]));
        }
      };
    }

    private WildcardCapturer notForTypeVariable() {
      return new WildcardCapturer(id);
    }

      assertThat(q.peek()).isNull();
      assertThat(q.poll()).isNull();
      assertThat(q.poll(0, MILLISECONDS)).isNull();
      assertEquals("[]", q.toString());
      assertThat(q.toArray()).isEmpty();
      assertFalse(q.iterator().hasNext());
      try {
        q.element();
        fail("Should throw exception");
      } catch (NoSuchElementException success) {
      }
      try {