} catch (Exception e) {
            context.failure("Failed to create temp project structure: " + e.getMessage());
            // Mark all POMs as errors
            errorPoms.addAll(pomMap.keySet());
        }

        return new UpgradeResult(processedPoms, modifiedPoms, errorPoms);
    }

    /**
     * Upgrades plugins in the document.

  }

  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());

            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

     */
    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);

  @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)

   * they were inserted into the builder. For example, in the above example, {@code
   * WORD_TO_INT.entrySet()} is guaranteed to iterate over the entries in the order {@code "one"=1,
   * "two"=2, "three"=3}, and {@code keySet()} and {@code values()} respect the same order. If you
   * want a different order, consider using {@link #orderEntriesByValue(Comparator)}, which changes
   * this builder to sort entries by value.
   *

    // 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);

     */
    public static void updateObjectTags(final String objectName, final Map<String, String> tagItems) {
        final Map<String, String> tags = new HashMap<>();
        tagItems.keySet().stream().filter(s -> s.startsWith("name")).forEach(nameKey -> {
            final String valueKey = nameKey.replace("name", "value");
            final String name = tagItems.get(nameKey);

        };

    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