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

        assertEquals("three", pom.getValue(prefix + "stringParams/stringParam[3]"));
        assertEquals("four", pom.getValue(prefix + "stringParams/stringParam[4]"));
        assertEquals("key1", pom.getValue(prefix + "propertiesParam/property[1]/name"));
        assertEquals("key2", pom.getValue(prefix + "propertiesParam/property[2]/name"));
    }

    /* MNG-3864*/
    @Test

    private boolean parallel;

    /**
     * Plugin context keyed by project ({@link MavenProject#getId()}) and by plugin lookup key
     * ({@link PluginDescriptor#getPluginLookupKey()}). Plugin contexts itself are mappings of {@link String} keys to
     * {@link Object} values.
     */
    @SuppressWarnings("checkstyle:linelength")

        }
    }

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

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

        String key = "m2.name";
        String checkValue = "value";

        MavenProject project = createDefaultProject();
        project.getModel().getProperties().setProperty(key, checkValue);

        ExpressionEvaluator ee = createExpressionEvaluator(project, new Properties());

        Object value = ee.evaluate("${" + key + "}");

        assertEquals(checkValue, value);
    }

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