Map<String, org.apache.maven.api.services.ToolchainFactory> v4Factories =
                lookup.lookupMap(org.apache.maven.api.services.ToolchainFactory.class);
        Map<String, org.apache.maven.api.services.ToolchainFactory> allFactories = new HashMap<>();
        for (Map.Entry<String, ToolchainFactory> entry : v3Factories.entrySet()) {
            ToolchainFactory v3Factory = entry.getValue();

      }
      SortedMap<K, V> map = (SortedMap<K, V>) delegate.create(allEntries.toArray());

      return createSubMap(map, firstExclusive, lastExclusive);
    }

    /**
     * Calls the smallest subMap overload that filters out the extreme values. This method is
     * overridden in NavigableMapTestSuiteBuilder.
     */
    SortedMap<K, V> createSubMap(SortedMap<K, V> map, K firstExclusive, K lastExclusive) {

    private List<String> inactiveProfileIds = Collections.emptyList();

    private Map<String, String> systemProperties = Collections.emptyMap();

    private Map<String, String> userProperties = Collections.emptyMap();

    private Map<String, String> projectProperties = Collections.emptyMap();

    private File projectDirectory;

    @Override

  /**
   * Returns a map view that associates each key with the corresponding values in the multimap.
   * Changes to the returned map, such as element removal, will update the underlying multimap. The
   * map does not support {@code setValue()} on its entries, {@code put}, or {@code putAll}.
   *
   * <p>When passed a key that is present in the map, {@code asMap().get(Object)} has the same

 *
 * <p>Like any other {@code Map<Class, Object>}, this map may contain entries for primitive types,
 * and a primitive type and its corresponding wrapper type may map to different values.
 *
 * <h3>Implementations</h3>
 *
 * <ul>
 *   <li>{@link ImmutableClassToInstanceMap}
 *   <li>{@link MutableClassToInstanceMap}
 * </ul>
 *
 * <p>To map a generic type to an instance of that type, use {@link

  public void testViewSerialization() {
    Map<String, Integer> map = ImmutableSortedMap.of("one", 1, "two", 2, "three", 3);
    SerializableTester.reserializeAndAssert(map.entrySet());
    SerializableTester.reserializeAndAssert(map.keySet());
    assertEquals(
        new ArrayList<>(map.values()),
        new ArrayList<>(SerializableTester.reserialize(map.values())));
  }

  public void testViewSerialization() {
    Map<String, Integer> map = ImmutableSortedMap.of("one", 1, "two", 2, "three", 3);
    SerializableTester.reserializeAndAssert(map.entrySet());
    SerializableTester.reserializeAndAssert(map.keySet());
    assertEquals(
        new ArrayList<>(map.values()),
        new ArrayList<>(SerializableTester.reserialize(map.values())));
  }

        @SuppressWarnings("unchecked")
        Map<String, List<String>> map = (Map<String, List<String>>) propMap.get(DEFAULT_LABEL_VALUES);
        if (map == null) {
            final String value = getSystemProperty(Constants.DEFAULT_LABEL_VALUE_PROPERTY);
            if (StringUtil.isBlank(value)) {
                map = Collections.emptyMap();
            } else {

  /**
   * Returns a map view that associates each key with the corresponding values in the multimap.
   * Changes to the returned map, such as element removal, will update the underlying multimap. The
   * map does not support {@code setValue()} on its entries, {@code put}, or {@code putAll}.
   *
   * <p>When passed a key that is present in the map, {@code asMap().get(Object)} has the same

        new TypeResolver()
            .where(
                new TypeCapture<Map<Integer, T>>() {}.capture(),
                new TypeCapture<Map<? extends Number, ? extends Number>>() {}.capture())
            .resolveType(subtype);
  }

  interface TypedKeyMap<T> extends Map<Integer, T> {}

  interface TypedListKeyMap<T> extends Map<List<Integer>, T> {}

  private static <T> Type aTypeVariable() {