K key1 = entry1.getKey();
    V value1 = entry1.getValue();
    checkEntryNotNull(key1, value1);
    // Do something that works for j2cl, where we can't call getDeclaredClass():
    EnumMap<K, V> enumMap = new EnumMap<>(singletonMap(key1, value1));
    while (entryItr.hasNext()) {
      Entry<K, ? extends V> entry = entryItr.next();
      K key = entry.getKey();
      V value = entry.getValue();
      checkEntryNotNull(key, value);

    K key1 = entry1.getKey();
    V value1 = entry1.getValue();
    checkEntryNotNull(key1, value1);
    // Do something that works for j2cl, where we can't call getDeclaredClass():
    EnumMap<K, V> enumMap = new EnumMap<>(singletonMap(key1, value1));
    while (entryItr.hasNext()) {
      Entry<K, ? extends V> entry = entryItr.next();
      K key = entry.getKey();
      V value = entry.getValue();
      checkEntryNotNull(key, value);

      new Predicate<Entry<String, Integer>>() {
        @Override
        public boolean apply(Entry<String, Integer> entry) {
          return !Objects.equals(entry.getKey(), "badkey") && entry.getValue() != 55556;
        }
      };

  public MultimapsFilterEntriesAsMapTest() {
    super(true, true, false);
  }

  private Multimap<String, Integer> createMultimap() {

 * @since 4.0.0
 */
public abstract class Task {

    private final String value;

    public Task(String value) {
        this.value = Objects.requireNonNull(value, "value");
    }

    public String getValue() {
        return value;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o instanceof Task task) {

  }

  private String expectedToString(Set<Entry<K, V>> entries) {
    Map<K, V> reference = new LinkedHashMap<>();
    for (Entry<K, V> entry : entries) {
      reference.put(entry.getKey(), entry.getValue());
    }
    return reference.toString();
  }

                consumer = s -> context.logger.warn(
                        messageBuilderFactory.builder().warning(s).build());
            }
            for (String line : entry.getValue()) {
                consumer.accept(indent + "  " + line);
            }
        }
        for (SecDispatcher.ValidationResponse subsystem : response.getSubsystems()) {

                    Map<String, String> map = new LinkedHashMap<>();
                    for (Entry<String, String> entry : entries) {
                      map.put(entry.getKey(), entry.getValue());
                    }
                    return new StandardImplForwardingMap<>(map);
                  }
                })
            .named("ForwardingMap[LinkedHashMap] with standard implementations")

            }

            // Mock by index - getHeaderField(int)
            // Index 0 is status line, then headers in order
            int index = 1;
            for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
                when(conn.getHeaderField(index++)).thenReturn(entry.getValue().get(0));
            }
        }

        System.out.println("Active test descriptors:");
        for (Map.Entry<Object, TestDescriptorInternal> entry : activeDescriptorsById.entrySet()) {
            System.out.println("id= " + entry.getKey() + " -- " + entry.getValue().getDisplayName());
        }
        illegalArgumentException.printStackTrace();
    }

    public void reset() {
        this.activeDescriptorsById.clear();

        accountAttempts.entrySet().removeIf(entry -> {
            AccountAttempts account = entry.getValue();
            return !account.isLockedOut() && account.getLastAttempt().plus(cleanupInterval).isBefore(now);
        });

        // Clean up IP attempts
        ipAttempts.entrySet().removeIf(entry -> {
            IpAttempts ip = entry.getValue();
            return !ip.isBlocked() && ip.getLastAttempt().plus(cleanupInterval).isBefore(now);