final HttpServletRequest req = (HttpServletRequest) request;
        final String servletPath = req.getServletPath();
        for (final Map.Entry<String, String> entry : encodingMap.entrySet()) {
            final String path = entry.getKey();
            if (servletPath.startsWith(path)) {
                req.setCharacterEncoding(entry.getValue());

        Map<Integer, TestResolvedDependency> dependenciesById = [:]
        for (Map.Entry entry : treeStructure.entrySet()) {
            Integer id = entry.getKey() as Integer
            dependenciesById.put(id, new TestResolvedDependency())
        }
        for (Map.Entry entry : treeStructure.entrySet()) {
            Integer id = entry.getKey() as Integer
            dependenciesById.get(id).children = entry.getValue().collect {

    }

    public static <K, V> StreamOf<Map.Entry<K, V>> stream(final Map<K, V> map) {
        return new StreamOf<>(() -> map != null ? map.entrySet().stream() : Collections.<K, V> emptyMap().entrySet().stream());
    }

    public static class StreamOf<T> {

        private final Supplier<Stream<T>> supplier;

        public StreamOf(final Supplier<Stream<T>> supplier) {

    for (int i = 0; i < entries.size(); i++) {
      assertEqualInOrder(
          entries.subList(0, i), navigableMap.headMap(entries.get(i).getKey()).entrySet());
    }
  }

  public void testTailMap() {
    List<Entry<K, V>> entries =
        Helpers.copyToList(
            getSubjectGenerator()

        ImmutableMap.Builder<String, String> changedBuilder = ImmutableMap.builder();
        for (Map.Entry<String, ValueSnapshot> entry : current.entrySet()) {
            String propertyName = entry.getKey();
            ValueSnapshot currentSnapshot = entry.getValue();
            ValueSnapshot previousSnapshot = previous.get(propertyName);

        for (Map.Entry<String, String> entry : dependenciesToAll.entrySet()) {
            builder.put(entry.getKey(), DependentsSet.dependencyToAll(entry.getValue()));
        }
        Set<String> collected = new HashSet<>();
        for (Map.Entry<String, Set<String>> entry : accessibleDependents.entrySet()) {
            if (collected.add(entry.getKey())) {

public class MultisetForEachEntryTester<E> extends AbstractMultisetTester<E> {
  public void testForEachEntry() {
    List<Entry<E>> expected = new ArrayList<>(getMultiset().entrySet());
    List<Entry<E>> actual = new ArrayList<>();
    getMultiset()
        .forEachEntry((element, count) -> actual.add(Multisets.immutableEntry(element, count)));
    Helpers.assertEqualIgnoringOrder(expected, actual);

            return this;
        }

        public TemplateOperationBuilder withDocumentationBindings(Map<String, String> documentationBindings) {
            for (Map.Entry<String, String> entry : documentationBindings.entrySet()){
                bindings.put(entry.getKey(), documentationRegistry.getDocumentationFor(entry.getValue()));
            }
            return this;
        }

        for (Iterator<Map.Entry<String, Object>> i = hmap.entrySet().iterator(); i.hasNext();) {
            i.next();
        }
        System.out.println("HashMap iteration:" + (System.currentTimeMillis() - start));

        start = System.currentTimeMillis();
        for (Iterator<Map.Entry<String, Object>> i = amap.entrySet().iterator(); i.hasNext();) {
            i.next();
        }

     */
    abstract Set<Entry<K, V>> createEntrySet();

    @LazyInit @CheckForNull private transient Set<Entry<K, V>> entrySet;

    @Override
    public Set<Entry<K, V>> entrySet() {
      Set<Entry<K, V>> result = entrySet;
      return (result == null) ? entrySet = createEntrySet() : result;
    }

    @LazyInit @CheckForNull private transient Set<K> keySet;

    @Override