You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@struts.apache.org by lu...@apache.org on 2020/04/27 18:38:36 UTC
[struts] branch WW-5065-append-or-not-cherry-pick created (now
d960e94)
This is an automated email from the ASF dual-hosted git repository.
lukaszlenart pushed a change to branch WW-5065-append-or-not-cherry-pick
in repository https://gitbox.apache.org/repos/asf/struts.git.
at d960e94 WW-5070 Fixes post cherry-pick issue
This branch includes the following new commits:
new 9b9b3cd WW-5065 Defines a new flag to control appending params
new 40c60da WW-5065 Cleans up code and marks old constructor as deprecated
new 3ff0ba7 WW-5065 Adds missing flag value
new d960e94 WW-5070 Fixes post cherry-pick issue
The 4 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
[struts] 02/04: WW-5065 Cleans up code and marks old constructor as
deprecated
Posted by lu...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
lukaszlenart pushed a commit to branch WW-5065-append-or-not-cherry-pick
in repository https://gitbox.apache.org/repos/asf/struts.git
commit 40c60da5a055f1d000d991abac64b3eb25a44c54
Author: Lukasz Lenart <lu...@apache.org>
AuthorDate: Fri Apr 24 09:32:50 2020 +0200
WW-5065 Cleans up code and marks old constructor as deprecated
---
.../xwork2/config/impl/AbstractMatcher.java | 36 +++++++++++++---------
1 file changed, 21 insertions(+), 15 deletions(-)
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/impl/AbstractMatcher.java b/core/src/main/java/com/opensymphony/xwork2/config/impl/AbstractMatcher.java
index d170c03..7fe4254 100644
--- a/core/src/main/java/com/opensymphony/xwork2/config/impl/AbstractMatcher.java
+++ b/core/src/main/java/com/opensymphony/xwork2/config/impl/AbstractMatcher.java
@@ -40,11 +40,6 @@ public abstract class AbstractMatcher<E> implements Serializable {
private static final Logger LOG = LogManager.getLogger(AbstractMatcher.class);
/**
- * <p> The logging instance </p>
- */
- private static final Logger log = LogManager.getLogger(AbstractMatcher.class);
-
- /**
* <p> Handles all wildcard pattern matching. </p>
*/
PatternMatcher<Object> wildcard;
@@ -73,6 +68,17 @@ public abstract class AbstractMatcher<E> implements Serializable {
}
/**
+ * Creates a matcher with {@link #appendNamedParameters} set to true to keep backward compatibility
+ *
+ * @param helper an instance of {@link PatternMatcher}
+ * @deprecated use @{link {@link AbstractMatcher(PatternMatcher, boolean)} instead
+ */
+ @Deprecated
+ public AbstractMatcher(PatternMatcher<?> helper) {
+ this(helper, true);
+ }
+
+ /**
* <p>
* Finds and precompiles the wildcard patterns. Patterns will be evaluated
* in the order they were added. Only patterns that actually contain a
@@ -100,17 +106,17 @@ public abstract class AbstractMatcher<E> implements Serializable {
name = name.substring(1);
}
- log.debug("Compiling pattern '{}'", name);
+ LOG.debug("Compiling pattern '{}'", name);
pattern = wildcard.compilePattern(name);
- compiledPatterns.add(new Mapping<E>(name, pattern, target));
+ compiledPatterns.add(new Mapping<>(name, pattern, target));
if (looseMatch) {
int lastStar = name.lastIndexOf('*');
if (lastStar > 1 && lastStar == name.length() - 1) {
if (name.charAt(lastStar - 1) != '*') {
pattern = wildcard.compilePattern(name.substring(0, lastStar - 1));
- compiledPatterns.add(new Mapping<E>(name, pattern, target));
+ compiledPatterns.add(new Mapping<>(name, pattern, target));
}
}
}
@@ -131,12 +137,12 @@ public abstract class AbstractMatcher<E> implements Serializable {
E config = null;
if (compiledPatterns.size() > 0) {
- log.debug("Attempting to match '{}' to a wildcard pattern, {} available", potentialMatch, compiledPatterns.size());
+ LOG.debug("Attempting to match '{}' to a wildcard pattern, {} available", potentialMatch, compiledPatterns.size());
- Map<String,String> vars = new LinkedHashMap<String,String>();
+ Map<String,String> vars = new LinkedHashMap<>();
for (Mapping<E> m : compiledPatterns) {
if (wildcard.match(vars, potentialMatch, m.getPattern())) {
- log.debug("Value matches pattern '{}'", m.getOriginalPattern());
+ LOG.debug("Value matches pattern '{}'", m.getOriginalPattern());
config = convert(potentialMatch, m.getTarget(), vars);
break;
}
@@ -211,7 +217,7 @@ public abstract class AbstractMatcher<E> implements Serializable {
c = val.charAt(x);
if (x < len - 2 &&
c == '{' && '}' == val.charAt(x+2)) {
- varVal = (String)vars.get(String.valueOf(val.charAt(x + 1)));
+ varVal = vars.get(String.valueOf(val.charAt(x + 1)));
if (varVal != null) {
ret.append(varVal);
}
@@ -232,18 +238,18 @@ public abstract class AbstractMatcher<E> implements Serializable {
/**
* <p> The original pattern. </p>
*/
- private String original;
+ private final String original;
/**
* <p> The compiled pattern. </p>
*/
- private Object pattern;
+ private final Object pattern;
/**
* <p> The original object. </p>
*/
- private E config;
+ private final E config;
/**
* <p> Contructs a read-only Mapping instance. </p>
[struts] 04/04: WW-5070 Fixes post cherry-pick issue
Posted by lu...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
lukaszlenart pushed a commit to branch WW-5065-append-or-not-cherry-pick
in repository https://gitbox.apache.org/repos/asf/struts.git
commit d960e94820eaca17ae72d7d8e58a47fa1486072c
Author: Lukasz Lenart <lu...@apache.org>
AuthorDate: Mon Apr 27 20:38:25 2020 +0200
WW-5070 Fixes post cherry-pick issue
---
.../com/opensymphony/xwork2/config/impl/ActionConfigMatcherTest.java | 1 +
1 file changed, 1 insertion(+)
diff --git a/core/src/test/java/com/opensymphony/xwork2/config/impl/ActionConfigMatcherTest.java b/core/src/test/java/com/opensymphony/xwork2/config/impl/ActionConfigMatcherTest.java
index aa2d648..ac52256 100644
--- a/core/src/test/java/com/opensymphony/xwork2/config/impl/ActionConfigMatcherTest.java
+++ b/core/src/test/java/com/opensymphony/xwork2/config/impl/ActionConfigMatcherTest.java
@@ -24,6 +24,7 @@ import com.opensymphony.xwork2.config.entities.ExceptionMappingConfig;
import com.opensymphony.xwork2.config.entities.InterceptorMapping;
import com.opensymphony.xwork2.config.entities.ResultConfig;
import com.opensymphony.xwork2.util.WildcardHelper;
+import org.apache.struts2.util.RegexPatternMatcher;
import java.util.HashMap;
import java.util.Map;
[struts] 01/04: WW-5065 Defines a new flag to control appending
params
Posted by lu...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
lukaszlenart pushed a commit to branch WW-5065-append-or-not-cherry-pick
in repository https://gitbox.apache.org/repos/asf/struts.git
commit 9b9b3cd264f49ac51526a787a5db57c8c8e30efb
Author: Lukasz Lenart <lu...@apache.org>
AuthorDate: Wed Apr 22 07:59:13 2020 +0200
WW-5065 Defines a new flag to control appending params
---
.../xwork2/config/impl/AbstractMatcher.java | 39 +++++++++---
.../xwork2/config/impl/ActionConfigMatcher.java | 28 ++++++++-
.../xwork2/config/impl/DefaultConfiguration.java | 17 +++--
.../xwork2/config/impl/NamespaceMatcher.java | 20 +++++-
.../providers/XWorkConfigurationProvider.java | 2 +
.../java/org/apache/struts2/StrutsConstants.java | 3 +
.../config/impl/ActionConfigMatcherTest.java | 73 ++++++++++++++++++++++
7 files changed, 164 insertions(+), 18 deletions(-)
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/impl/AbstractMatcher.java b/core/src/main/java/com/opensymphony/xwork2/config/impl/AbstractMatcher.java
index 3b3b74b..d170c03 100644
--- a/core/src/main/java/com/opensymphony/xwork2/config/impl/AbstractMatcher.java
+++ b/core/src/main/java/com/opensymphony/xwork2/config/impl/AbstractMatcher.java
@@ -36,6 +36,9 @@ import java.util.*;
* @since 2.1
*/
public abstract class AbstractMatcher<E> implements Serializable {
+
+ private static final Logger LOG = LogManager.getLogger(AbstractMatcher.class);
+
/**
* <p> The logging instance </p>
*/
@@ -50,10 +53,23 @@ public abstract class AbstractMatcher<E> implements Serializable {
* <p> The compiled patterns and their associated target objects </p>
*/
List<Mapping<E>> compiledPatterns = new ArrayList<>();
- ;
+
+ /**
+ * This flag controls if passed named params should be appended
+ * to the map in {@link #replaceParameters(Map, Map)}
+ * and will be accessible in {@link com.opensymphony.xwork2.config.entities.ResultConfig}.
+ * If set to false, the named parameters won't be appended.
+ *
+ * This behaviour is controlled by {@link org.apache.struts2.StrutsConstants#STRUTS_MATCHER_APPEND_NAMED_PARAMETERS}
+ *
+ * @since 2.5.23
+ * See WW-5065
+ */
+ private final boolean appendNamedParameters;
- public AbstractMatcher(PatternMatcher<?> helper) {
+ public AbstractMatcher(PatternMatcher<?> helper, boolean appendNamedParameters) {
this.wildcard = (PatternMatcher<Object>) helper;
+ this.appendNamedParameters = appendNamedParameters;
}
/**
@@ -152,20 +168,23 @@ public abstract class AbstractMatcher<E> implements Serializable {
*/
protected Map<String,String> replaceParameters(Map<String, String> orig, Map<String,String> vars) {
Map<String, String> map = new LinkedHashMap<>();
-
+
//this will set the group index references, like {1}
for (Map.Entry<String,String> entry : orig.entrySet()) {
map.put(entry.getKey(), convertParam(entry.getValue(), vars));
}
-
- //the values map will contain entries like name->"Lex Luthor" and 1->"Lex Luthor"
- //now add the non-numeric values
- for (Map.Entry<String,String> entry: vars.entrySet()) {
- if (!NumberUtils.isCreatable(entry.getKey())) {
- map.put(entry.getKey(), entry.getValue());
+
+ if (appendNamedParameters) {
+ LOG.debug("Appending named parameters to the result map");
+ //the values map will contain entries like name->"Lex Luthor" and 1->"Lex Luthor"
+ //now add the non-numeric values
+ for (Map.Entry<String,String> entry: vars.entrySet()) {
+ if (!NumberUtils.isCreatable(entry.getKey())) {
+ map.put(entry.getKey(), entry.getValue());
+ }
}
}
-
+
return map;
}
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/impl/ActionConfigMatcher.java b/core/src/main/java/com/opensymphony/xwork2/config/impl/ActionConfigMatcher.java
index b94fff6..344339e 100644
--- a/core/src/main/java/com/opensymphony/xwork2/config/impl/ActionConfigMatcher.java
+++ b/core/src/main/java/com/opensymphony/xwork2/config/impl/ActionConfigMatcher.java
@@ -58,7 +58,33 @@ public class ActionConfigMatcher extends AbstractMatcher<ActionConfig> implement
public ActionConfigMatcher(PatternMatcher<?> patternMatcher,
Map<String, ActionConfig> configs,
boolean looseMatch) {
- super(patternMatcher);
+ this(patternMatcher, configs, looseMatch, true);
+ }
+
+ /**
+ * <p> Finds and precompiles the wildcard patterns from the ActionConfig
+ * "path" attributes. ActionConfig's will be evaluated in the order they
+ * exist in the config file. Only paths that actually contain a
+ * wildcard will be compiled. </p>
+ *
+ * <p>Patterns can optionally be matched "loosely". When
+ * the end of the pattern matches \*[^*]\*$ (wildcard, no wildcard,
+ * wildcard), if the pattern fails, it is also matched as if the
+ * last two characters didn't exist. The goal is to support the
+ * legacy "*!*" syntax, where the "!*" is optional.</p>
+ *
+ * @param patternMatcher pattern matcher
+ * @param configs An array of ActionConfig's to process
+ * @param looseMatch To loosely match wildcards or not
+ * @param appendNamedParameters To append named parameters or not
+ *
+ * @since 2.5.23
+ * See WW-5065
+ */
+ public ActionConfigMatcher(PatternMatcher<?> patternMatcher,
+ Map<String, ActionConfig> configs,
+ boolean looseMatch, boolean appendNamedParameters) {
+ super(patternMatcher, appendNamedParameters);
for (Map.Entry<String, ActionConfig> entry : configs.entrySet()) {
addPattern(entry.getKey(), entry.getValue(), looseMatch);
}
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/impl/DefaultConfiguration.java b/core/src/main/java/com/opensymphony/xwork2/config/impl/DefaultConfiguration.java
index 42cfabb..cf46680 100644
--- a/core/src/main/java/com/opensymphony/xwork2/config/impl/DefaultConfiguration.java
+++ b/core/src/main/java/com/opensymphony/xwork2/config/impl/DefaultConfiguration.java
@@ -291,6 +291,8 @@ public class DefaultConfiguration implements Configuration {
builder.constant(StrutsConstants.STRUTS_CONFIGURATION_XML_RELOAD, "false");
builder.constant(StrutsConstants.STRUTS_I18N_RELOAD, "false");
+ builder.constant(StrutsConstants.STRUTS_MATCHER_APPEND_NAMED_PARAMETERS, "true");
+
return builder.create(true);
}
@@ -340,8 +342,12 @@ public class DefaultConfiguration implements Configuration {
}
PatternMatcher<int[]> matcher = container.getInstance(PatternMatcher.class);
+ boolean appendNamedParameters = Boolean.parseBoolean(
+ container.getInstance(String.class, StrutsConstants.STRUTS_MATCHER_APPEND_NAMED_PARAMETERS)
+ );
+
return new RuntimeConfigurationImpl(Collections.unmodifiableMap(namespaceActionConfigs),
- Collections.unmodifiableMap(namespaceConfigs), matcher);
+ Collections.unmodifiableMap(namespaceConfigs), matcher, appendNamedParameters);
}
private void setDefaultResults(Map<String, ResultConfig> results, PackageConfig packageContext) {
@@ -419,15 +425,18 @@ public class DefaultConfiguration implements Configuration {
public RuntimeConfigurationImpl(Map<String, Map<String, ActionConfig>> namespaceActionConfigs,
Map<String, String> namespaceConfigs,
- PatternMatcher<int[]> matcher) {
+ PatternMatcher<int[]> matcher,
+ boolean appendNamedParameters)
+ {
this.namespaceActionConfigs = namespaceActionConfigs;
this.namespaceConfigs = namespaceConfigs;
this.namespaceActionConfigMatchers = new LinkedHashMap<>();
- this.namespaceMatcher = new NamespaceMatcher(matcher, namespaceActionConfigs.keySet());
+ this.namespaceMatcher = new NamespaceMatcher(matcher, namespaceActionConfigs.keySet(), appendNamedParameters);
for (Map.Entry<String, Map<String, ActionConfig>> entry : namespaceActionConfigs.entrySet()) {
- namespaceActionConfigMatchers.put(entry.getKey(), new ActionConfigMatcher(matcher, entry.getValue(), true));
+ ActionConfigMatcher configMatcher = new ActionConfigMatcher(matcher, entry.getValue(), true, appendNamedParameters);
+ namespaceActionConfigMatchers.put(entry.getKey(), configMatcher);
}
}
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/impl/NamespaceMatcher.java b/core/src/main/java/com/opensymphony/xwork2/config/impl/NamespaceMatcher.java
index 01decd3..b24fc75 100644
--- a/core/src/main/java/com/opensymphony/xwork2/config/impl/NamespaceMatcher.java
+++ b/core/src/main/java/com/opensymphony/xwork2/config/impl/NamespaceMatcher.java
@@ -29,9 +29,23 @@ import java.util.Set;
* @since 2.1
*/
public class NamespaceMatcher extends AbstractMatcher<NamespaceMatch> {
- public NamespaceMatcher(PatternMatcher<?> patternMatcher,
- Set<String> namespaces) {
- super(patternMatcher);
+
+ public NamespaceMatcher(PatternMatcher<?> patternMatcher, Set<String> namespaces) {
+ this(patternMatcher, namespaces, true);
+ }
+
+ /**
+ * Matches namespace strings against a wildcard pattern matcher
+ *
+ * @param patternMatcher pattern matcher
+ * @param namespaces A set of namespaces to process
+ * @param appendNamedParameters To append named parameters or not
+ *
+ * @since 2.5.23
+ * See WW-5065
+ */
+ public NamespaceMatcher(PatternMatcher<?> patternMatcher, Set<String> namespaces, boolean appendNamedParameters) {
+ super(patternMatcher, appendNamedParameters);
for (String name : namespaces) {
if (!patternMatcher.isLiteral(name)) {
addPattern(name, new NamespaceMatch(name, null), false);
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/providers/XWorkConfigurationProvider.java b/core/src/main/java/com/opensymphony/xwork2/config/providers/XWorkConfigurationProvider.java
index cffb451..ecd6d6e 100644
--- a/core/src/main/java/com/opensymphony/xwork2/config/providers/XWorkConfigurationProvider.java
+++ b/core/src/main/java/com/opensymphony/xwork2/config/providers/XWorkConfigurationProvider.java
@@ -107,6 +107,7 @@ import com.opensymphony.xwork2.validator.DefaultValidatorFactory;
import com.opensymphony.xwork2.validator.DefaultValidatorFileParser;
import com.opensymphony.xwork2.validator.ValidatorFactory;
import com.opensymphony.xwork2.validator.ValidatorFileParser;
+import com.sun.org.apache.xpath.internal.operations.Bool;
import ognl.MethodAccessor;
import ognl.PropertyAccessor;
import org.apache.struts2.StrutsConstants;
@@ -225,6 +226,7 @@ public class XWorkConfigurationProvider implements ConfigurationProvider {
props.setProperty(StrutsConstants.STRUTS_CONFIGURATION_XML_RELOAD, Boolean.FALSE.toString());
props.setProperty(StrutsConstants.STRUTS_ALLOW_STATIC_METHOD_ACCESS, Boolean.FALSE.toString());
props.setProperty(StrutsConstants.STRUTS_ALLOW_STATIC_FIELD_ACCESS, Boolean.TRUE.toString());
+ props.setProperty(StrutsConstants.STRUTS_MATCHER_APPEND_NAMED_PARAMETERS, Boolean.TRUE.toString());
}
}
diff --git a/core/src/main/java/org/apache/struts2/StrutsConstants.java b/core/src/main/java/org/apache/struts2/StrutsConstants.java
index a55ed62..6f71ce8 100644
--- a/core/src/main/java/org/apache/struts2/StrutsConstants.java
+++ b/core/src/main/java/org/apache/struts2/StrutsConstants.java
@@ -346,4 +346,7 @@ public final class StrutsConstants {
public static final String STRUTS_DISALLOW_PROXY_MEMBER_ACCESS = "struts.disallowProxyMemberAccess";
public static final String STRUTS_OGNL_AUTO_GROWTH_COLLECTION_LIMIT = "struts.ognl.autoGrowthCollectionLimit";
+
+ /** See {@link com.opensymphony.xwork2.config.impl.AbstractMatcher#appendNamedParameters */
+ public static final String STRUTS_MATCHER_APPEND_NAMED_PARAMETERS = "";
}
diff --git a/core/src/test/java/com/opensymphony/xwork2/config/impl/ActionConfigMatcherTest.java b/core/src/test/java/com/opensymphony/xwork2/config/impl/ActionConfigMatcherTest.java
index 7e0a60c..aa2d648 100644
--- a/core/src/test/java/com/opensymphony/xwork2/config/impl/ActionConfigMatcherTest.java
+++ b/core/src/test/java/com/opensymphony/xwork2/config/impl/ActionConfigMatcherTest.java
@@ -142,6 +142,79 @@ public class ActionConfigMatcherTest extends XWorkTestCase {
}
+ /**
+ * Test to make sure the {@link AbstractMatcher#replaceParameters(Map, Map)} method isn't adding values to the
+ * return value.
+ */
+ public void testReplaceParametersWithNoAppendingParams() {
+ Map<String, ActionConfig> map = new HashMap<>();
+
+ HashMap<String, String> params = new HashMap<>();
+ params.put("first", "{1}");
+
+ ActionConfig config = new ActionConfig.Builder("package", "foo/{one}/{two}/{three}", "foo.bar.Action")
+ .addParams(params)
+ .addExceptionMapping(new ExceptionMappingConfig.Builder("foo{1}", "java.lang.{2}Exception", "success{1}")
+ .addParams(new HashMap<>(params))
+ .build())
+ .addResultConfig(new ResultConfig.Builder("success{1}", "foo.{2}").addParams(params).build())
+ .setStrictMethodInvocation(false)
+ .build();
+ map.put("foo/{one}/{two}/{three}", config);
+ ActionConfigMatcher replaceMatcher = new ActionConfigMatcher(new RegexPatternMatcher(), map, false, false);
+ ActionConfig matched = replaceMatcher.match("foo/paramOne/paramTwo/paramThree");
+ assertNotNull("ActionConfig should be matched", matched);
+
+ // Verify all The ActionConfig, ExceptionConfig, and ResultConfig have the correct number of params
+ assertEquals("The ActionConfig should have the correct number of params", 1, matched.getParams().size());
+ assertEquals("The ExceptionMappingConfigs should have the correct number of params", 1, matched.getExceptionMappings().get(0).getParams().size());
+ assertEquals("The ResultConfigs should have the correct number of params", 1, matched.getResults().get("successparamOne").getParams().size());
+
+ // Verify the params are still getting their values replaced correctly
+ assertEquals("The ActionConfig params have replaced values", "paramOne", matched.getParams().get("first"));
+ assertEquals("The ActionConfig params have replaced values", "paramOne", matched.getExceptionMappings().get(0).getParams().get("first"));
+ assertEquals("The ActionConfig params have replaced values", "paramOne", matched.getResults().get("successparamOne").getParams().get("first"));
+ }
+
+ /**
+ * Test to make sure the {@link AbstractMatcher#replaceParameters(Map, Map)} method is adding values to the
+ * return value.
+ */
+ public void testReplaceParametersWithAppendingParams() {
+ Map<String, ActionConfig> map = new HashMap<>();
+
+ HashMap<String, String> params = new HashMap<>();
+ params.put("first", "{1}");
+
+ ActionConfig config = new ActionConfig.Builder("package", "foo/{one}/{two}/{three}", "foo.bar.Action")
+ .addParams(params)
+ .addExceptionMapping(new ExceptionMappingConfig.Builder("foo{1}", "java.lang.{2}Exception", "success{1}")
+ .addParams(new HashMap<>(params))
+ .build())
+ .addResultConfig(new ResultConfig.Builder("success{1}", "foo.{2}").addParams(params).build())
+ .setStrictMethodInvocation(false)
+ .build();
+ map.put("foo/{one}/{two}/{three}", config);
+ ActionConfigMatcher replaceMatcher = new ActionConfigMatcher(new RegexPatternMatcher(), map, false, true);
+ ActionConfig matched = replaceMatcher.match("foo/paramOne/paramTwo/paramThree");
+ assertNotNull("ActionConfig should be matched", matched);
+
+ assertEquals(4, matched.getParams().size());
+ assertEquals(4, matched.getExceptionMappings().get(0).getParams().size());
+ assertEquals(4, matched.getResults().get("successparamOne").getParams().size());
+
+ // Verify the params are still getting their values replaced correctly
+ assertEquals("paramOne", matched.getParams().get("first"));
+ assertEquals("paramOne", matched.getParams().get("one"));
+ assertEquals("paramTwo", matched.getParams().get("two"));
+ assertEquals("paramThree", matched.getParams().get("three"));
+ assertEquals("paramOne", matched.getExceptionMappings().get(0).getParams().get("first"));
+ assertEquals("paramOne", matched.getExceptionMappings().get(0).getParams().get("one"));
+ assertEquals("paramTwo", matched.getExceptionMappings().get(0).getParams().get("two"));
+ assertEquals("paramThree", matched.getExceptionMappings().get(0).getParams().get("three"));
+ assertEquals("paramOne", matched.getResults().get("successparamOne").getParams().get("first"));
+ }
+
private Map<String,ActionConfig> buildActionConfigMap() {
Map<String, ActionConfig> map = new HashMap<>();
[struts] 03/04: WW-5065 Adds missing flag value
Posted by lu...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
lukaszlenart pushed a commit to branch WW-5065-append-or-not-cherry-pick
in repository https://gitbox.apache.org/repos/asf/struts.git
commit 3ff0ba78c171438a636d7f75c2b0a9271f932060
Author: Lukasz Lenart <lu...@apache.org>
AuthorDate: Fri Apr 24 09:33:06 2020 +0200
WW-5065 Adds missing flag value
---
core/src/main/java/org/apache/struts2/StrutsConstants.java | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/core/src/main/java/org/apache/struts2/StrutsConstants.java b/core/src/main/java/org/apache/struts2/StrutsConstants.java
index 6f71ce8..b48b8be 100644
--- a/core/src/main/java/org/apache/struts2/StrutsConstants.java
+++ b/core/src/main/java/org/apache/struts2/StrutsConstants.java
@@ -348,5 +348,5 @@ public final class StrutsConstants {
public static final String STRUTS_OGNL_AUTO_GROWTH_COLLECTION_LIMIT = "struts.ognl.autoGrowthCollectionLimit";
/** See {@link com.opensymphony.xwork2.config.impl.AbstractMatcher#appendNamedParameters */
- public static final String STRUTS_MATCHER_APPEND_NAMED_PARAMETERS = "";
+ public static final String STRUTS_MATCHER_APPEND_NAMED_PARAMETERS = "struts.matcher.appendNamedParameters";
}