for (Object e : elements) {
      array[i++] = (Character) e;
    }
    return create(array);
  }

  /**
   * Creates a new collection containing the given elements; implement this method instead of {@link
   * #create(Object...)}.
   */
  protected abstract List<Character> create(Character[] elements);

  @Override
  public Character[] createArray(int length) {
    return new Character[length];
  }

import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.Set;

/**
 * Optional features of classes derived from {@link Multiset}.
 *
 * @author Louis Wasserman
 */
@SuppressWarnings("rawtypes") // maybe avoidable if we rework the whole package?
@GwtCompatible
public enum MultisetFeature implements Feature<Multiset> {
  /**

/**
 * Pluggable interface for compiling a regex pattern. By default this package uses the {@code
 * java.util.regex} library, but an alternate implementation can be supplied using the {@link
 * java.util.ServiceLoader} mechanism.
 */
@GwtIncompatible
@ElementTypesAreNonnullByDefault
interface PatternCompiler {
  /**
   * Compiles the given pattern.
   *

import java.util.Arrays;
import java.util.Collection;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

/** Tests for a directed {@link StandardMutableGraph}. */
@AndroidIncompatible
@RunWith(Parameterized.class)
public final class StandardMutableDirectedGraphTest extends AbstractStandardDirectedGraphTest {

 * limitations under the License.
 */

package com.google.common.collect;

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

/**
 * Implementation of {@link ImmutableListMultimap} with no entries.
 *
 * @author Jared Levy
 */
@GwtCompatible(serializable = true)
@ElementTypesAreNonnullByDefault
class EmptyImmutableListMultimap extends ImmutableListMultimap<Object, Object> {

              earlierRequirement),
          intersection(newFeatures, earlierFeatures),
          source);
    }
  }

  /**
   * Construct a new {@link java.util.Set} that is the intersection of the given sets.
   *
   * @deprecated Use {@link com.google.common.collect.Sets#intersection(Set, Set)} instead.
   */
  @Deprecated
  public static <T> Set<T> intersection(Set<? extends T> set1, Set<? extends T> set2) {

  void setBackingMap(Map<E, Count> backingMap) {
    this.backingMap = backingMap;
  }

  // Required Implementations

  /**
   * {@inheritDoc}
   *
   * <p>Invoking {@link Multiset.Entry#getCount} on an entry in the returned set always returns the
   * current count of that element in the multiset, as opposed to the count at the time the entry
   * was retrieved.
   */
  @Override

   * first node in insertion order; all values at indices ≥ {@link #size()} are UNSET.
   */
  @CheckForNull private transient int[] predecessor;

  /**
   * Pointer to the successor of an entry in insertion order. ENDPOINT indicates a node is the last
   * node in insertion order; all values at indices ≥ {@link #size()} are UNSET.
   */
  @CheckForNull private transient int[] successor;

import com.google.common.testing.SerializableTester;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import junit.framework.TestCase;

/**
 * Tests for {@link PairedStats}. This tests instances created by {@link
 * PairedStatsAccumulator#snapshot}.
 *
 * @author Pete Gillin
 */
public class PairedStatsTest extends TestCase {

  public void testCount() {

import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.junit.Ignore;

/**
 * A generic JUnit test which tests {@code toString()} operations on a map. Can't be invoked
 * directly; please see {@link com.google.common.collect.testing.MapTestSuiteBuilder}.
 *
 * @author Kevin Bourrillion
 * @author Louis Wasserman
 */
@GwtCompatible