* inputs, with counts equal to the result of applying {@code countFunction} to the inputs.
   * Elements are added in encounter order.
   *
   * <p>If the mapped elements contain duplicates (according to {@link Object#equals}), the element
   * will be added more than once, with the count summed over all appearances of the element.
   *
   * <p>Note that {@code stream.collect(toMultiset(function, e -> 1, supplier))} is equivalent to

daresay it's a French mouse, come over with William the
Conqueror.'  (For, with all her knowledge of history, Alice had
no very clear notion how long ago anything had happened.)  So she
began again:  `Ou est ma chatte?' which was the first sentence in
her French lesson-book.  The Mouse gave a sudden leap out of the
water, and seemed to quiver all over with fright.  `Oh, I beg

![Interceptors Diagram](../assets/images/******@****.***)

### Application Interceptors

   * an application-specified ordering of lock acquisitions. The application defines the allowed
   * ordering with an {@code Enum} whose values each correspond to a lock type. The order in which
   * the values are declared dictates the allowed order of lock acquisition. In other words, locks
   * corresponding to smaller values of {@link Enum#ordinal()} should only be acquired before locks
   * with larger ordinals. Example:
   *

 *  Upgrade: Build with Conscrypt 2.5.1.


## Version 4.8.1

_2020-08-06_

 *  Fix: Don't crash in `HeldCertificate.Builder` when creating certificates on older versions of
    Android, including Android 6. We were using a feature of `SimpleDateFormat` that wasn't
    available in those versions!


## Version 4.8.0

_2020-07-11_

        List<ResolverType> order = config.getResolveOrder();
        assertEquals(4, order.size());
        assertEquals(ResolverType.RESOLVER_LMHOSTS, order.get(0));
        assertEquals(ResolverType.RESOLVER_DNS, order.get(1));
        assertEquals(ResolverType.RESOLVER_WINS, order.get(2));
        assertEquals(ResolverType.RESOLVER_BCAST, order.get(3));
    }

    @Test

    }

    @Override
    public Entry<K, V>[] createArray(int length) {
      return generator.createArray(length);
    }

    @Override
    public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
      return generator.order(insertionOrder);
    }

    @SuppressWarnings("unchecked")
    @Override
    public K[] createKeyArray(int length) {
      return (K[]) new Object[length];
    }

import org.gradle.api.tasks.TaskAction;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.*;

/**
 * Checks adoc files for reversed multi-language snippet order.
 * Only rule enforced:
 *   In a ==== ... ==== block, if there are at least two [.multi-language-sample] snippets,
 *   flag when the first is GROOVY and the second is KOTLIN.
 */
@CacheableTask

   *         <li>{@code predecessors(node)}: Connecting edge insertion order
   *         <li>{@code successors(node)}: Connecting edge insertion order
   *         <li>{@code incidentEdges(node)}: Stable order
   *         <li>{@code inEdges(node)}: Edge insertion order
   *         <li>{@code outEdges(node)}: Edge insertion order
   *         <li>{@code adjacentEdges(edge)}: Stable order

   *         <li>{@code predecessors(node)}: Connecting edge insertion order
   *         <li>{@code successors(node)}: Connecting edge insertion order
   *         <li>{@code incidentEdges(node)}: Stable order
   *         <li>{@code inEdges(node)}: Edge insertion order
   *         <li>{@code outEdges(node)}: Edge insertion order
   *         <li>{@code adjacentEdges(edge)}: Stable order