</stringParams>
              <propertiesParam>
                <property>
                  <name>key1</name>
                  <value>value1</value>
                </property>
                <property>
                  <name>key2</name>
                  <value>value2</value>
                </property>
              </propertiesParam>
            </configuration>

              </stringParams>
              <propertiesParam>
                <property>
                  <name>key1</name>
                  <value>value1</value>
                </property>
                <property>
                  <name>key2</name>
                  <value>value2</value>
                </property>
              </propertiesParam>
            </configuration>

        }
    }

    protected final Map<Key, CacheRecord> cache = new ConcurrentHashMap<>();

    @Override
    public Key createKey(List<? extends ClassRealm> extensionRealms) {
        return new CacheKey(extensionRealms);
    }

    public CacheRecord get(Key key) {
        return cache.get(key);
    }

    public CacheRecord put(Key key, ClassRealm projectRealm, DependencyFilter extensionArtifactFilter) {

    }

    public CacheRecord get(Key key) {
        return cache.get(key);
    }

    @Override
    public CacheRecord get(Key key, PluginRealmSupplier supplier)
            throws PluginResolutionException, PluginContainerException {
        try {
            return cache.computeIfAbsent(key, k -> {
                try {
                    return supplier.load();

        Key key = new CacheKey(
                project,
                project.getRemoteProjectRepositories(),
                scopesToCollect,
                scopesToResolve,
                aggregating,
                session);
        return keys.computeIfAbsent(key, k -> k);
    }

    @Override
    public CacheRecord get(Key key) throws LifecycleExecutionException {

     */
    String ID_COMBINATION_MODE_ATTRIBUTE = "combine.id";

    /**
     * In case of complex XML structures, combining can be done based on keys.
     * This is a comma separated list of attribute names.
     */
    String KEYS_COMBINATION_MODE_ATTRIBUTE = "combine.keys";

    /**
     * This default mode for combining a DOM node during merge means that where element names match, the process will

    private final int rank;

    private final String key;

    private static Map<String, ArtifactStatus> map;

    private ArtifactStatus(String key, int rank) {
        this.rank = rank;
        this.key = key;

        if (map == null) {
            map = new HashMap<>();
        }
        map.put(key, this);
    }

    public static ArtifactStatus valueOf(String status) {

    void setUp() throws Exception {
        cache = new DefaultProjectArtifactsCache();
    }

    @Test
    void testProjectDependencyOrder() throws Exception {
        ProjectArtifactsCache.Key project1 = new ProjectArtifactsCache.Key() {};

        Set<Artifact> artifacts = new LinkedHashSet<>(4);
        artifacts.add(new DefaultArtifact("g", "a1", "v", "compile", "jar", "", null));

        } else {
            if (anew) {
                cache = new ConcurrentHashMap<>();
                repositoryCache.put(session, KEY, cache);
            } else {
                cache = (ConcurrentHashMap<Object, Supplier<?>>)
                        repositoryCache.computeIfAbsent(session, KEY, ConcurrentHashMap::new);
            }
            return new DefaultModelCache(cache);
        }
    }

        for (int i = 0; i < projects.size(); i++) {
            MavenProject project = projects.get(i);
            String key = BuilderCommon.getKey(project);

            this.getProjects().put(key, project);
            this.getIndices().put(key, i);
        }
    }

    public Map<String, MavenProject> getProjects() {
        return projects;
    }