Fix RegexBasedInterpolator cache - populate existingAnswers map when cacheAnswers is true

Co-authored-by: slachiewicz <6705942+slachiewicz@users.noreply.github.com>

Author: Copilot

src/main/java/org/codehaus/plexus/interpolation/RegexBasedInterpolator.java

@@ -301,6 +301,10 @@ private String interpolate(
                     // but this could result in multiple lookups of stringValue, and replaceAll is not correct behaviour
                     result = StringUtils.replace(result, wholeExpr, String.valueOf(value));
 
+                    if (cacheAnswers) {
+                        existingAnswers.put(realExpr, value);
+                    }
+
                     matcher.reset(result);
                 }
             } finally {

src/test/java/org/codehaus/plexus/interpolation/RegexBasedInterpolatorTest.java

@@ -223,4 +223,73 @@ public Object execute(String expression, Object value) {
 
         System.out.println("time with pattern reuse and RegexBasedInterpolator instance reuse " + (end - start));
     }
+
+    @Test
+    public void testCacheAnswersTrue() throws InterpolationException {
+        Map ctx = new HashMap();
+        ctx.put("key", "value");
+
+        final int[] valueSourceCallCount = {0};
+
+        ValueSource vs = new AbstractValueSource(false) {
+            @Override
+            public Object getValue(String expression) {
+                valueSourceCallCount[0]++;
+                return ctx.get(expression);
+            }
+        };
+
+        RegexBasedInterpolator interpolator = new RegexBasedInterpolator();
+        interpolator.setCacheAnswers(true);
+        interpolator.addValueSource(vs);
+
+        // First interpolation
+        String result = interpolator.interpolate("${key}-${key}-${key}-${key}");
+        assertEquals("value-value-value-value", result);
+        assertEquals(1, valueSourceCallCount[0]);
+
+        // Second interpolation - cache should be used, no new ValueSource calls
+        result = interpolator.interpolate("${key}-${key}-${key}-${key}");
+        assertEquals("value-value-value-value", result);
+        assertEquals(1, valueSourceCallCount[0]); // still 1, cache was used
+
+        // Third interpolation with different expression that also uses cached value
+        result = interpolator.interpolate("The value is ${key}");
+        assertEquals("The value is value", result);
+        assertEquals(1, valueSourceCallCount[0]); // still 1, cache was used
+    }
+
+    @Test
+    public void testCacheAnswersFalse() throws InterpolationException {
+        Map ctx = new HashMap();
+        ctx.put("key", "value");
+
+        final int[] valueSourceCallCount = {0};
+
+        ValueSource vs = new AbstractValueSource(false) {
+            @Override
+            public Object getValue(String expression) {
+                valueSourceCallCount[0]++;
+                return ctx.get(expression);
+            }
+        };
+
+        RegexBasedInterpolator interpolator = new RegexBasedInterpolator();
+        interpolator.addValueSource(vs);
+
+        // First interpolation
+        String result = interpolator.interpolate("${key}-${key}-${key}-${key}");
+        assertEquals("value-value-value-value", result);
+        assertEquals(1, valueSourceCallCount[0]);
+
+        // Second interpolation - without caching, ValueSource is called again
+        result = interpolator.interpolate("${key}-${key}-${key}-${key}");
+        assertEquals("value-value-value-value", result);
+        assertEquals(2, valueSourceCallCount[0]); // incremented to 2
+
+        // Third interpolation
+        result = interpolator.interpolate("The value is ${key}");
+        assertEquals("The value is value", result);
+        assertEquals(3, valueSourceCallCount[0]); // incremented to 3
+    }
 }