/**
     * Returns the element type of a parameterized {@link Collection}.
     * <p>
     * If <code>type</code> is not a parameterized {@link Collection}, <code>null</code> is returned.
     * </p>
     *
     * @param type
     *            the type to analyze
     * @return the element type of the collection, or null if not a parameterized collection
     */

        return json.toString();
    }

    private void appendJsonValue(final StringBuilder json, final Object value) {
        if (value instanceof Collection) {
            json.append("[");
            boolean first = true;
            for (final Object item : (Collection<?>) value) {
                if (!first) {
                    json.append(", ");
                }
                first = false;

    }

    /**
     *
     */
    public static class Baz {

        /** */
        @SuppressWarnings("rawtypes")
        public Collection collectionOfRawtype;

        /** */
        public Collection<String> collectionOfString;

        /** */
        public Map<String, Integer> map;

    }

    }

    public void setArtifactExists(boolean artifactExists) {
        this.artifactExists = artifactExists;
    }

    public Collection<ArtifactMetadata> getDependencies() {
        return dependencies;
    }

    public void setDependencies(Collection<ArtifactMetadata> dependencies) {
        this.dependencies = dependencies;
    }

    public String getArtifactUri() {
        return artifactUri;

      warmUp(cache, 0, 100);

      Collection<Object> values = cache.asMap().values();
      values.clear();
      checkEmpty(values);
      checkEmpty(cache);
    }
  }

  public void testValues_empty_remove() {
    for (LoadingCache<Object, Object> cache : caches()) {
      Collection<Object> values = cache.asMap().values();
      assertThat(values.remove(null)).isFalse();

import org.elasticsearch.common.util.set.Sets;
import org.elasticsearch.gateway.GatewayAllocator;
import org.elasticsearch.snapshots.EmptySnapshotsInfoService;

import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

public final class Allocators {
    private static class NoopGatewayAllocator extends GatewayAllocator {

package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import java.util.Collection;

/**
 * Implementation of {@link ImmutableListMultimap} with no entries.
 *
 * @author Mike Ward
 */
@GwtCompatible
final class EmptyImmutableSetMultimap extends ImmutableSetMultimap<Object, Object> {

  }

  public void testIn_apply() {
    Collection<Integer> nums = Arrays.asList(1, 5);
    Predicate<@Nullable Integer> isOneOrFive = Predicates.in(nums);

    assertTrue(isOneOrFive.apply(1));
    assertTrue(isOneOrFive.apply(5));
    assertFalse(isOneOrFive.apply(3));
    assertFalse(isOneOrFive.apply(null));
  }

  public void testIn_equality() {
    Collection<Integer> nums = ImmutableSet.of(1, 5);

  void register(Object listener) {
    Multimap<Class<?>, Subscriber> listenerMethods = findAllSubscribers(listener);

    for (Entry<Class<?>, Collection<Subscriber>> entry : listenerMethods.asMap().entrySet()) {
      Class<?> eventType = entry.getKey();
      Collection<Subscriber> eventMethodsInListener = entry.getValue();

      CopyOnWriteArraySet<Subscriber> eventSubscribers = subscribers.get(eventType);

            return parent.remove(o);
        }

        public boolean containsAll(final Collection<?> c) {
            return parent.containsAll(c);
        }

        public boolean addAll(final Collection<? extends E> c) {
            return parent.addAll(c);
        }

        public boolean addAll(final int index, final Collection<? extends E> c) {
            return parent.addAll(index, c);
        }