* collector by only using a constant number of internal objects.
 *
 * <p>If there are no removals, then iteration order for the {@link #entrySet}, {@link #keySet}, and
 * {@link #values} views is the same as insertion order. Any removal invalidates any ordering
 * guarantees.
 *
 * <p>This class should not be assumed to be universally superior to {@code java.util.HashMap}.

  }

  private void testHasMapEntriesInOrder(Map<?, ?> map, Object... alternatingKeysAndValues) {
    List<? extends Entry<?, ?>> entries = new ArrayList<>(map.entrySet());
    List<Object> keys = new ArrayList<>(map.keySet());
    List<Object> values = new ArrayList<>(map.values());
    assertThat(alternatingKeysAndValues).hasLength(2 * entries.size());
    assertThat(alternatingKeysAndValues).hasLength(2 * keys.size());

    protected void writeFessConfig(final ZipOutputStream zos, final String id) {
        if (fessConfig instanceof SimpleImpl) {
            final Properties prop = new Properties();
            ((SimpleImpl) fessConfig).keySet().stream().forEach(k -> prop.setProperty(k, fessConfig.get(k)));

            final ZipEntry entry = new ZipEntry(id + "/fess_config.properties");
            try {
                zos.putNextEntry(entry);

            final UserInfoBhv userInfoBhv = ComponentUtil.getComponent(UserInfoBhv.class);
            userInfoBhv.selectList(cb -> {
                cb.query().setId_InScope(userInfoMap.keySet());
                cb.fetchFirst(userInfoMap.size());
            }).forEach(userInfo -> {
                final String code = userInfo.getId();
                final UserInfo entity = userInfoMap.get(code);

                        PopulatableMapAsMultimap.create();
                    populateMultimapForKeySet(multimap, elements);
                    return multimap.build().keySet();
                  }
                })
            .named("Multimaps.forMap.keySet")
            .withFeatures(FOR_MAP_FEATURES_ANY)
            .createTestSuite());

    // TODO: use collection testers on Multimaps.forMap.values

  @CollectionSize.Require(absent = ZERO)
  public void testPutAbsentConcurrentWithKeySetIteration() {
    assertThrows(
        ConcurrentModificationException.class,
        () -> {
          Iterator<K> iterator = getMap().keySet().iterator();
          put(e3());
          iterator.next();
        });
  }

  @MapFeature.Require({FAILS_FAST_ON_CONCURRENT_MODIFICATION, SUPPORTS_PUT})
  @CollectionSize.Require(absent = ZERO)

    // TODO(lowasser): make this trigger only if the map is a submap
    // currently, the KeySetGenerator won't work properly for a subset of a keyset of a submap
    keySetFeatures.add(CollectionFeature.SUBSET_VIEW);
    if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEYS)) {
      keySetFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES);

        predecessorCount,
        successorCount);
  }

  @Override
  public Set<N> adjacentNodes() {
    if (orderedNodeConnections == null) {
      return Collections.unmodifiableSet(adjacentNodeValues.keySet());
    } else {
      return new AbstractSet<N>() {
        @Override
        public UnmodifiableIterator<N> iterator() {
          Iterator<NodeConnection<N>> nodeConnections = orderedNodeConnections.iterator();

     */
    public int forceRotateAllKeys() {
        checkNotClosed();

        int rotated = 0;
        java.util.List<String> sessionIds = new java.util.ArrayList<>(sessionKeys.keySet());

        for (String sessionId : sessionIds) {
            // Skip archived keys
            if (!sessionId.contains(".v")) {
                try {
                    rotateSessionKey(sessionId);

        };

    ServiceManager manager = new ServiceManager(asList(a));
    manager.startAsync();
    manager.stopAsync();
    manager.awaitStopped(10, MILLISECONDS);
    assertThat(manager.servicesByState().keySet()).containsExactly(Service.State.TERMINATED);
  }

  public void testNotifyStoppedAfterFailure() throws TimeoutException {
    Service a =
        new AbstractService() {
          @Override