putAll(map);
        }
    }

    public String toString() {
        StringBuilder buffer = new StringBuilder("ManagedVersionMap (" + size() + " entries)\n");
        Iterator<String> iter = keySet().iterator();
        while (iter.hasNext()) {
            String key = iter.next();
            buffer.append(key).append('=').append(get(key));
            if (iter.hasNext()) {
                buffer.append('\n');

    return delegate.higher(checkValid(e));
  }

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

  @Override
  public Iterator<E> iterator() {
    return delegate.iterator();
  }

  @Override
  public E last() {
    return delegate.last();
  }

  @Override
  public @Nullable E lower(E e) {
    return delegate.lower(checkValid(e));
  }

        final Map<TypeVariable<?>, Type> map = GenericsUtil.getTypeVariableMap(Hoge.class);
        assertThat(map.size(), is(4));
        final Iterator<Entry<TypeVariable<?>, Type>> it = map.entrySet().iterator();
        Entry<TypeVariable<?>, Type> entry = it.next();
        assertThat(entry.getKey().getName(), is("T1"));
        assertThat(entry.getValue(), is(sameClass(Integer.class)));

  /**
   * Find all the tester annotations declared on a tester class or method.
   *
   * @param classOrMethod a class or method whose tester annotations to find
   * @return an iterable sequence of tester annotations on the class
   */
  public static Iterable<Annotation> getTesterAnnotations(AnnotatedElement classOrMethod) {
    synchronized (annotationCache) {
      List<Annotation> annotations = annotationCache.get(classOrMethod);

 * implementation for the {@link #put} and {@link #getIfPresent} methods. {@link #getAllPresent} is
 * implemented in terms of {@link #getIfPresent}; {@link #putAll} is implemented in terms of {@link
 * #put}, {@link #invalidateAll(Iterable)} is implemented in terms of {@link #invalidate}. The
 * method {@link #cleanUp} is a no-op. All other methods throw an {@link
 * UnsupportedOperationException}.
 *
 * @author Charles Fry
 * @since 10.0
 */

            List<String> methods = getHeaderFields0().get(authHeader);
            if ( methods == null )
                return null;
            Iterator<String> iterator = methods.iterator();
            while ( iterator.hasNext() ) {
                String currentAuthMethod = iterator.next();
                if ( currentAuthMethod.startsWith("NTLM") ) {
                    if ( currentAuthMethod.length() == 4 ) {

    assertEqualInOrder(expected, multimap().values());
  }

  @CollectionFeature.Require(SUPPORTS_ITERATOR_REMOVE)
  @CollectionSize.Require(ONE)
  public void testValuesIteratorRemove() {
    Iterator<V> valuesItr = multimap().values().iterator();
    valuesItr.next();
    valuesItr.remove();
    assertTrue(multimap().isEmpty());
  }

            buffer.append(" among available goals ");
            List<MojoDescriptor> mojos = pluginDescriptor.getMojos();
            if (mojos != null) {
                for (Iterator<MojoDescriptor> it = mojos.iterator(); it.hasNext(); ) {
                    MojoDescriptor mojo = it.next();
                    if (mojo != null) {
                        buffer.append(mojo.getGoal());
                    }

    @Override
    public SampleElements<String> sampleValues() {
      return new SampleElements<>("january", "february", "march", "april", "may");
    }

    @Override
    public Collection<String> createCollection(Iterable<? extends String> values) {
      return Lists.newArrayList(values);
    }

    @Override
    public SampleElements<Entry<String, String>> samples() {
      return new SampleElements<>(

            return parent.isEmpty();
        }

        public boolean contains(final Object o) {
            return parent.contains(o);
        }

        public Iterator<E> iterator() {
            return parent.iterator();
        }

        public Object[] toArray() {
            return parent.toArray();
        }

        public <T> T[] toArray(final T[] a) {