struts-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From lukaszlen...@apache.org
Subject [17/57] [partial] struts git commit: Merges xwork packages into struts
Date Wed, 17 Jun 2015 21:09:17 GMT
http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/test/java/com/opensymphony/xwork2/validator/DoubleRangeValidatorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/com/opensymphony/xwork2/validator/DoubleRangeValidatorTest.java b/core/src/test/java/com/opensymphony/xwork2/validator/DoubleRangeValidatorTest.java
new file mode 100644
index 0000000..e7045c2
--- /dev/null
+++ b/core/src/test/java/com/opensymphony/xwork2/validator/DoubleRangeValidatorTest.java
@@ -0,0 +1,278 @@
+package com.opensymphony.xwork2.validator;
+
+import com.opensymphony.xwork2.*;
+import com.opensymphony.xwork2.config.providers.MockConfigurationProvider;
+import com.opensymphony.xwork2.config.providers.XmlConfigurationProvider;
+import com.opensymphony.xwork2.util.ValueStack;
+import com.opensymphony.xwork2.validator.validators.DoubleRangeFieldValidator;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Unit test for {@link DoubleRangeFieldValidator}.
+ *
+ * @author <a href="mailto:hermanns@aixcept.de">Rainer Hermanns</a>
+ * @author Claus Ibsen
+ * @version $Id$
+ */
+public class DoubleRangeValidatorTest extends XWorkTestCase {
+    private DoubleRangeFieldValidator val;
+
+    public void testRangeValidationWithError() throws Exception {
+        //Explicitly set an out-of-range double for DoubleRangeValidatorTest
+        Map<String, Object> context = new HashMap<>();
+        HashMap<String, Object> params = new HashMap<>();
+        params.put("percentage", 100.0123d);
+        context.put(ActionContext.PARAMETERS, params);
+
+        ActionProxy proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.VALIDATION_ACTION_NAME, context);
+        proxy.execute();
+        assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
+
+        Map<String, List<String>> errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
+
+        List<String> errorMessages = errors.get("percentage");
+        assertNotNull("Expected double range validation error message.", errorMessages);
+        assertEquals(1, errorMessages.size());
+
+        String errorMessage = errorMessages.get(0);
+        assertNotNull("Expecting: percentage must be between 0.1 and 10.1, current value is 100.0123.", errorMessage);
+        assertEquals("percentage must be between 0.1 and 10.1, current value is 100.0123.", errorMessage);
+    }
+
+    public void testRangeValidationNoError() throws Exception {
+        Map<String, Object> context = new HashMap<>();
+        HashMap<String, Object> params = new HashMap<>();
+        params.put("percentage", 1.234567d);
+        context.put(ActionContext.PARAMETERS, params);
+
+        ActionProxy proxy = actionProxyFactory.createActionProxy("", "percentage", context);
+        proxy.execute();
+        assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
+
+        Map<String, List<String>> errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
+        Iterator it = errors.entrySet().iterator();
+
+        List<String> errorMessages = errors.get("percentage");
+        assertNull("Expected no double range validation error message.", errorMessages);
+    }
+
+    public void testRangeNoExclusiveAndNoValueInStack() throws Exception {
+        val.setFieldName("hello");
+        val.validate("world");
+    }
+
+    public void testRangeSimpleDoubleValueInStack() throws Exception {
+        MyTestProduct prod = new MyTestProduct();
+        prod.setName("coca cola");
+        prod.setPrice(5.99);
+
+        ValueStack stack = ActionContext.getContext().getValueStack();
+        stack.push(prod);
+        ActionContext.getContext().setValueStack(stack);
+
+        val.setMinInclusive(0d);
+        val.setMaxInclusive(10d);
+        val.setFieldName("price");
+        val.validate(prod);
+    }
+
+    public void testRangeRealDoubleValueInStack() throws Exception {
+        MyTestProduct prod = new MyTestProduct();
+        prod.setName("coca cola");
+        prod.setPrice(5.99);
+        prod.setVolume(12.34d);
+
+        ValueStack stack = ActionContext.getContext().getValueStack();
+        stack.push(prod);
+        ActionContext.getContext().setValueStack(stack);
+
+        val.setMinInclusive(0d);
+        val.setMaxInclusive(30d);
+        val.setFieldName("volume");
+        val.validate(prod);
+    }
+
+    public void testRangeNotADoubleObjectValueInStack() throws Exception {
+        MyTestProduct prod = new MyTestProduct();
+        prod.setName("coca cola");
+
+        ValueStack stack = ActionContext.getContext().getValueStack();
+        stack.push(prod);
+        ActionContext.getContext().setValueStack(stack);
+
+        val.setMinInclusive(0d);
+        val.setMaxInclusive(10d);
+        val.setFieldName("name");
+
+        DelegatingValidatorContext context = new DelegatingValidatorContext(new ValidationAwareSupport());
+        val.setValidatorContext(context);
+
+        val.validate(prod);
+
+        assertEquals(0d, val.getMinInclusive());
+        assertEquals(10d, val.getMaxInclusive());
+    }
+
+    public void testEdgeOfMaxRange() throws Exception {
+        MyTestProduct prod = new MyTestProduct();
+        prod.setName("coca cola");
+        prod.setPrice(9.95);
+
+        ValueStack stack = ActionContext.getContext().getValueStack();
+        stack.push(prod);
+        ActionContext.getContext().setValueStack(stack);
+
+        val.setFieldName("price");
+
+        DelegatingValidatorContext context = new DelegatingValidatorContext(new ValidationAwareSupport());
+        val.setValidatorContext(context);
+
+        val.setMaxInclusive(9.95d);
+        val.validate(prod); // should pass
+        assertTrue(!context.hasErrors());
+        assertEquals(9.95d, val.getMaxInclusive());
+
+        val.setMaxExclusive(9.95d);
+        val.validate(prod); // should not pass
+        assertTrue(context.hasErrors());
+        assertEquals(9.95d, val.getMaxExclusive());
+    }
+
+    public void testEdgeOfMinRange() throws Exception {
+        MyTestProduct prod = new MyTestProduct();
+        prod.setName("coca cola");
+        prod.setPrice(9.95);
+
+        ValueStack stack = ActionContext.getContext().getValueStack();
+        stack.push(prod);
+        ActionContext.getContext().setValueStack(stack);
+
+        val.setFieldName("price");
+
+        DelegatingValidatorContext context = new DelegatingValidatorContext(new ValidationAwareSupport());
+        val.setValidatorContext(context);
+
+        val.setMinInclusive(9.95d);
+        val.validate(prod); // should pass
+        assertTrue(!context.hasErrors());
+
+        val.setMinExclusive(9.95d);
+        val.validate(prod); // should not pass
+        assertTrue(context.hasErrors());
+    }
+
+    public void testNoValue() throws Exception {
+        ValueStack stack = ActionContext.getContext().getValueStack();
+        ActionContext.getContext().setValueStack(stack);
+
+        val.setFieldName("price");
+
+        DelegatingValidatorContext context = new DelegatingValidatorContext(new ValidationAwareSupport());
+        val.setValidatorContext(context);
+
+        val.setMinInclusive(9.95d);
+        val.validate(null);
+        assertTrue(!context.hasErrors()); // should pass as null value passed in
+    }
+
+    public void testRangeValidationWithExpressionsFail() throws Exception {
+        //Explicitly set an out-of-range double for DoubleRangeValidatorTest
+        Map<String, Object> context = new HashMap<>();
+        HashMap<String, Object> params = new HashMap<>();
+        params.put("percentage", 100.0123d);
+        context.put(ActionContext.PARAMETERS, params);
+
+        ActionProxy proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.EXPRESSION_VALIDATION_ACTION, context);
+        proxy.execute();
+        assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
+
+        Map<String, List<String>> errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
+        List<String> errorMessages = errors.get("percentage");
+        assertNotNull("Expected double range validation error message.", errorMessages);
+        assertEquals(1, errorMessages.size());
+
+        String errorMessage = errorMessages.get(0);
+        assertNotNull("Expecting: percentage must be between 0.1 and 10.1, current value is 100.0123.", errorMessage);
+        assertEquals("percentage must be between 0.1 and 10.1, current value is 100.0123.", errorMessage);
+    }
+
+    public void testExpressionParams() throws Exception {
+        ValueStack stack = ActionContext.getContext().getValueStack();
+        ActionSupport action = new ActionSupport() {
+
+            public Double getMinInclusiveValue() {return 10d;}
+            public Double getMaxInclusiveValue() {return 11d;}
+            public Double getMinExclusiveValue() {return 13d;}
+            public Double getMaxExclusiveValue() {return 14d;}
+            public Double getPrice() {return 15d;}
+        };
+
+        stack.push(action);
+
+        val.setMinInclusiveExpression("${minInclusiveValue}");
+        val.setMaxInclusiveExpression("${maxInclusiveValue}");
+        val.setMinExclusiveExpression("${minExclusiveValue}");
+        val.setMaxExclusiveExpression("${maxExclusiveValue}");
+
+        val.setFieldName("price");
+        val.setDefaultMessage("Price is wrong!");
+
+        DelegatingValidatorContext context = new DelegatingValidatorContext(action);
+        val.setValidatorContext(context);
+
+        val.validate(action);
+        assertTrue(action.getFieldErrors().get("price").size() == 1);
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        XmlConfigurationProvider provider = new XmlConfigurationProvider("xwork-default.xml");
+        container.inject(provider);
+        loadConfigurationProviders(provider,  new MockConfigurationProvider());
+        val = new DoubleRangeFieldValidator();
+        val.setValueStack(ActionContext.getContext().getValueStack());
+        ActionContext.getContext().setParameters(new HashMap<String, Object>());
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        super.tearDown();
+        val = null;
+    }
+
+    private class MyTestProduct {
+        private double price;
+        private Double volume;
+        private String name;
+
+        public double getPrice() {
+            return price;
+        }
+
+        public void setPrice(double price) {
+            this.price = price;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public void setName(String name) {
+            this.name = name;
+        }
+
+        public Double getVolume() {
+            return volume;
+        }
+
+        public void setVolume(Double volume) {
+            this.volume = volume;
+        }
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/test/java/com/opensymphony/xwork2/validator/EmailValidatorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/com/opensymphony/xwork2/validator/EmailValidatorTest.java b/core/src/test/java/com/opensymphony/xwork2/validator/EmailValidatorTest.java
new file mode 100644
index 0000000..ca9a549
--- /dev/null
+++ b/core/src/test/java/com/opensymphony/xwork2/validator/EmailValidatorTest.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2002-2006,2009 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.opensymphony.xwork2.validator;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionSupport;
+import com.opensymphony.xwork2.XWorkTestCase;
+import com.opensymphony.xwork2.util.ValueStack;
+import com.opensymphony.xwork2.validator.validators.EmailValidator;
+
+/**
+ * Test case for Email Validator
+ *
+ * @author tm_jee
+ * @version $Date$ $Id$
+ */
+public class EmailValidatorTest extends XWorkTestCase {
+
+    public void testEmailValidity() throws Exception {
+        assertTrue(verifyEmailValidity("tmjee@yahoo.com"));
+        assertTrue(verifyEmailValidityWithExpression("tmjee@yahoo.com", "\\b^[a-z]+@[a-z]+(\\.[a-z]+)*\\.com$\\b"));
+        assertTrue(verifyEmailValidity("tm_jee@yahoo.co"));
+        assertTrue(verifyEmailValidityWithExpression("tm_jee@yahoo.co", "\\b^[a-z_]+@[a-z]+(\\.[a-z]+)*\\.co$\\b"));
+        assertTrue(verifyEmailValidity("tm.jee@yahoo.co.uk"));
+        assertTrue(verifyEmailValidity("tm.jee@yahoo.co.biz"));
+        assertTrue(verifyEmailValidity("tm_jee@yahoo.com"));
+        assertTrue(verifyEmailValidity("tm_jee@yahoo.net"));
+        assertTrue(verifyEmailValidity(" user@subname1.subname2.subname3.domainname.co.uk "));
+        assertTrue(verifyEmailValidity("tm.j'ee@yahoo.co.uk"));
+        assertTrue(verifyEmailValidity("tm.j'e.e'@yahoo.co.uk"));
+        assertTrue(verifyEmailValidity("tmj'ee@yahoo.com"));
+        assertTrue(verifyEmailValidity("ferda+mravenec@yahoo.com"));
+        assertTrue(verifyEmailValidity("Ferda+Mravenec@yaHoo.CoM"));
+
+        assertFalse(verifyEmailValidity("tm_jee#marry@yahoo.co.uk"));
+        assertFalse(verifyEmailValidity("tm_jee@ yahoo.co.uk"));
+        assertFalse(verifyEmailValidity("tm_jee  @yahoo.co.uk"));
+        assertFalse(verifyEmailValidity("tm_j ee  @yah oo.co.uk"));
+        assertFalse(verifyEmailValidity("tm_jee  @yah oo.co.uk"));
+        assertFalse(verifyEmailValidity("tm_jee @ yahoo.com"));
+        assertFalse(verifyEmailValidity(" user@subname1.subname2.subname3.domainn#ame.co.uk "));
+        assertFalse(verifyEmailValidity("aaa@aa.aaaaaaa"));
+        assertFalse(verifyEmailValidity("+ferdamravenec@yahoo.com"));
+
+        assertTrue(verifyEmailValidityWithExpression("tmjee@yahoo.co", "\\b^[a-z]+@[a-z]+(\\.[a-z]+)*\\.com$\\b"));
+    }
+
+    protected boolean verifyEmailValidity(final String email) throws Exception {
+        ActionSupport action = new ActionSupport() {
+            public String getMyEmail() {
+                return email;
+            }
+        };
+
+        EmailValidator validator = new EmailValidator();
+        validator.setValidatorContext(new DelegatingValidatorContext(action));
+        validator.setFieldName("myEmail");
+        validator.setDefaultMessage("invalid email");
+        validator.setValueStack(ActionContext.getContext().getValueStack());
+        validator.validate(action);
+
+        return (action.getFieldErrors().size() == 0);
+    }
+
+    public boolean verifyEmailValidityWithExpression(final String email, final String expression) throws Exception {
+        ActionSupport action = new ActionSupport() {
+            public String getMyEmail() {
+                return email;
+            }
+
+            public String getEmailExpression() {
+                return expression;
+            }
+        };
+
+        EmailValidator validator = new EmailValidator();
+        ValueStack valueStack = ActionContext.getContext().getValueStack();
+        valueStack.push(action);
+        validator.setValueStack(valueStack);
+
+        validator.setValidatorContext(new DelegatingValidatorContext(action));
+        validator.setFieldName("myEmail");
+        validator.setDefaultMessage("invalid email");
+        validator.setRegexExpression("${emailExpression}");
+
+        validator.validate(action);
+
+        return (action.getFieldErrors().size() == 0);
+    }
+
+    public void testCaseSensitiveViaExpression() throws Exception {
+        EmailValidator validator = verifyCaseSensitive(true);
+        assertTrue(validator.isCaseSensitive());
+
+        validator = verifyCaseSensitive(false);
+        assertFalse(validator.isCaseSensitive());
+    }
+
+    private EmailValidator verifyCaseSensitive(final boolean caseSensitive) {
+        ActionSupport action = new ActionSupport() {
+            public boolean getEmailCaseSensitive() {
+                return caseSensitive;
+            }
+        };
+
+        EmailValidator validator = new EmailValidator();
+        ValueStack valueStack = ActionContext.getContext().getValueStack();
+        valueStack.push(action);
+        validator.setValueStack(valueStack);
+
+        validator.setCaseSensitiveExpression("${emailCaseSensitive}");
+
+        return validator;
+    }
+
+    public void testTrimViaExpression() throws Exception {
+        EmailValidator validator = verifyTrim(true);
+        assertTrue(validator.isTrimed());
+
+        validator = verifyTrim(false);
+        assertFalse(validator.isTrimed());
+    }
+
+    private EmailValidator verifyTrim(final boolean trim) {
+        ActionSupport action = new ActionSupport() {
+            public boolean getTrimEmail() {
+                return trim;
+            }
+        };
+
+        EmailValidator validator = new EmailValidator();
+        ValueStack valueStack = ActionContext.getContext().getValueStack();
+        valueStack.push(action);
+        validator.setValueStack(valueStack);
+
+        validator.setTrimExpression("${trimEmail}");
+
+        return validator;
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/test/java/com/opensymphony/xwork2/validator/ExpressionValidatorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/com/opensymphony/xwork2/validator/ExpressionValidatorTest.java b/core/src/test/java/com/opensymphony/xwork2/validator/ExpressionValidatorTest.java
new file mode 100644
index 0000000..572b316
--- /dev/null
+++ b/core/src/test/java/com/opensymphony/xwork2/validator/ExpressionValidatorTest.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2002-2006,2009 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.opensymphony.xwork2.validator;
+
+import com.mockobjects.dynamic.C;
+import com.mockobjects.dynamic.Mock;
+import com.opensymphony.xwork2.*;
+import com.opensymphony.xwork2.config.entities.ActionConfig;
+import com.opensymphony.xwork2.config.providers.MockConfigurationProvider;
+import com.opensymphony.xwork2.validator.validators.ExpressionValidator;
+import org.easymock.EasyMock;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Unit test for ExpressionValidator.
+ *
+ * @author Jason Carreira
+ * @author Claus Ibsen
+ */
+public class ExpressionValidatorTest extends XWorkTestCase {
+
+    public void testExpressionValidationOfStringLength() throws ValidationException {
+        TestBean bean = new TestBean();
+        bean.setName("abc");
+        ActionContext.getContext().getValueStack().push(bean);
+
+        DelegatingValidatorContext context = new DelegatingValidatorContext(new ValidationAwareSupport());
+        container.getInstance(ActionValidatorManager.class).validate(bean, "expressionValidation", context);
+        assertTrue(context.hasFieldErrors());
+
+        final Map fieldErrors = context.getFieldErrors();
+        assertTrue(fieldErrors.containsKey("name"));
+
+        List nameErrors = (List) fieldErrors.get("name");
+        assertEquals(1, nameErrors.size());
+        assertEquals("Name must be greater than 5 characters, it is currently 'abc'", nameErrors.get(0));
+
+        bean.setName("abcdefg");
+        context = new DelegatingValidatorContext(new ValidationAwareSupport());
+        container.getInstance(ActionValidatorManager.class).validate(bean, "expressionValidation", context);
+        assertFalse(context.hasFieldErrors());
+    }
+
+    public void testExpressionValidatorFailure() throws Exception {
+        HashMap<String, Object> params = new HashMap<>();
+        params.put("date", "12/23/2002");
+        params.put("foo", "5");
+        params.put("bar", "7");
+
+        HashMap<String, Object> extraContext = new HashMap<>();
+        extraContext.put(ActionContext.PARAMETERS, params);
+
+        ActionProxy proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.VALIDATION_ACTION_NAME, extraContext);
+        proxy.execute();
+        assertTrue(((ValidationAware) proxy.getAction()).hasActionErrors());
+
+        Collection errors = ((ValidationAware) proxy.getAction()).getActionErrors();
+        assertEquals(1, errors.size());
+
+        String message = (String) errors.iterator().next();
+        assertNotNull(message);
+        assertEquals("Foo must be greater than Bar. Foo = 5, Bar = 7.", message);
+    }
+
+    public void testExpressionValidatorSuccess() throws Exception {
+        HashMap<String, Object> params = new HashMap<String, Object>();
+
+        //make it not fail
+        params.put("date", "12/23/2002");
+        params.put("foo", "10");
+        params.put("bar", "7");
+
+        HashMap<String, Object> extraContext = new HashMap<>();
+        extraContext.put(ActionContext.PARAMETERS, params);
+
+        ActionProxy proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.VALIDATION_ACTION_NAME, extraContext);
+        proxy.execute();
+        assertFalse(((ValidationAware) proxy.getAction()).hasActionErrors());
+    }
+
+    public void testGetSetExpresion() {
+        ExpressionValidator ev = new ExpressionValidator();
+        ev.setExpression("{top}");
+        assertEquals("{top}", ev.getExpression());
+    }
+
+    public void testNoBooleanExpression() throws Exception {
+        Mock mock = new Mock(ValidationAware.class);
+        mock.expect("addActionError", C.ANY_ARGS);
+
+        ExpressionValidator ev = new ExpressionValidator();
+        ev.setValidatorContext(new DelegatingValidatorContext(mock.proxy()));
+        ev.setExpression("{top}");
+        ev.setValueStack(ActionContext.getContext().getValueStack());
+        ev.validate("Hello"); // {top} will evalute to Hello that is not a Boolean
+        mock.verify();
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        loadConfigurationProviders(new MockConfigurationProvider());
+
+        ActionConfig config = new ActionConfig.Builder("", "name", "").build();
+        ActionInvocation invocation = EasyMock.createNiceMock(ActionInvocation.class);
+        ActionProxy proxy = EasyMock.createNiceMock(ActionProxy.class);
+
+        EasyMock.expect(invocation.getProxy()).andReturn(proxy).anyTimes();
+        EasyMock.expect(invocation.getAction()).andReturn(null).anyTimes();
+        EasyMock.expect(invocation.invoke()).andReturn(Action.SUCCESS).anyTimes();
+        EasyMock.expect(proxy.getMethod()).andReturn("execute").anyTimes();
+        EasyMock.expect(proxy.getConfig()).andReturn(config).anyTimes();
+
+
+        EasyMock.replay(invocation);
+        EasyMock.replay(proxy);
+
+        ActionContext.getContext().setActionInvocation(invocation);
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/test/java/com/opensymphony/xwork2/validator/GenericValidatorContext.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/com/opensymphony/xwork2/validator/GenericValidatorContext.java b/core/src/test/java/com/opensymphony/xwork2/validator/GenericValidatorContext.java
new file mode 100644
index 0000000..6273259
--- /dev/null
+++ b/core/src/test/java/com/opensymphony/xwork2/validator/GenericValidatorContext.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2002-2003,2009 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.opensymphony.xwork2.validator;
+
+import java.util.*;
+
+
+/**
+ * Dummy validator context to use to capture error messages.
+ *
+ * @author Mark Woon
+ * @author Matthew Payne
+ */
+public class GenericValidatorContext extends DelegatingValidatorContext {
+
+    private Collection<String> actionErrors;
+    private Collection<String> actionMessages;
+    private Map<String, List<String>> fieldErrors;
+
+
+    public GenericValidatorContext(Object object) {
+        super(object);
+    }
+
+
+    @Override
+    public synchronized void setActionErrors(Collection<String> errorMessages) {
+        this.actionErrors = errorMessages;
+    }
+
+    @Override
+    public synchronized Collection<String> getActionErrors() {
+        return new ArrayList<>(internalGetActionErrors());
+    }
+
+    @Override
+    public synchronized void setActionMessages(Collection<String> messages) {
+        this.actionMessages = messages;
+    }
+
+    @Override
+    public synchronized Collection<String> getActionMessages() {
+        return new ArrayList<String>(internalGetActionMessages());
+    }
+
+    @Override
+    public synchronized void setFieldErrors(Map<String, List<String>> errorMap) {
+        this.fieldErrors = errorMap;
+    }
+
+    /**
+     * Get the field specific errors.
+     *
+     * @return an unmodifiable Map with errors mapped from fieldname (String) to Collection of String error messages
+     */
+    @Override
+    public synchronized Map<String, List<String>> getFieldErrors() {
+        return new HashMap<String, List<String>>(internalGetFieldErrors());
+    }
+
+    @Override
+    public synchronized void addActionError(String anErrorMessage) {
+        internalGetActionErrors().add(anErrorMessage);
+    }
+
+    /**
+     * Add an Action level message to this Action
+     */
+    @Override
+    public void addActionMessage(String aMessage) {
+        internalGetActionMessages().add(aMessage);
+    }
+
+    @Override
+    public synchronized void addFieldError(String fieldName, String errorMessage) {
+        final Map<String, List<String>> errors = internalGetFieldErrors();
+        List<String> thisFieldErrors = errors.get(fieldName);
+
+        if (thisFieldErrors == null) {
+            thisFieldErrors = new ArrayList<>();
+            errors.put(fieldName, thisFieldErrors);
+        }
+
+        thisFieldErrors.add(errorMessage);
+    }
+
+    @Override
+    public synchronized boolean hasActionErrors() {
+        return (actionErrors != null) && !actionErrors.isEmpty();
+    }
+
+    /**
+     * Note that this does not have the same meaning as in WW 1.x
+     *
+     * @return (hasActionErrors() || hasFieldErrors())
+     */
+    @Override
+    public synchronized boolean hasErrors() {
+        return (hasActionErrors() || hasFieldErrors());
+    }
+
+    @Override
+    public synchronized boolean hasFieldErrors() {
+        return (fieldErrors != null) && !fieldErrors.isEmpty();
+    }
+
+    private Collection<String> internalGetActionErrors() {
+        if (actionErrors == null) {
+            actionErrors = new ArrayList<>();
+        }
+
+        return actionErrors;
+    }
+
+    private Collection<String> internalGetActionMessages() {
+        if (actionMessages == null) {
+            actionMessages = new ArrayList<>();
+        }
+
+        return actionMessages;
+    }
+
+    private Map<String, List<String>> internalGetFieldErrors() {
+        if (fieldErrors == null) {
+            fieldErrors = new HashMap<>();
+        }
+
+        return fieldErrors;
+    }
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/test/java/com/opensymphony/xwork2/validator/IntRangeValidatorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/com/opensymphony/xwork2/validator/IntRangeValidatorTest.java b/core/src/test/java/com/opensymphony/xwork2/validator/IntRangeValidatorTest.java
new file mode 100644
index 0000000..9c0281b
--- /dev/null
+++ b/core/src/test/java/com/opensymphony/xwork2/validator/IntRangeValidatorTest.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2002-2003,2009 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.opensymphony.xwork2.validator;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionProxy;
+import com.opensymphony.xwork2.ValidationAware;
+import com.opensymphony.xwork2.XWorkTestCase;
+import com.opensymphony.xwork2.config.providers.MockConfigurationProvider;
+import com.opensymphony.xwork2.config.providers.XmlConfigurationProvider;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * IntRangeValidatorTest
+ * <p/>
+ * Created : Jan 21, 2003 12:16:01 AM
+ *
+ * @author Jason Carreira
+ */
+public class IntRangeValidatorTest extends XWorkTestCase {
+
+    public void testRangeValidation() {
+        HashMap<String, String> params = new HashMap<>();
+        params.put("bar", "5");
+
+        HashMap<String, Object> extraContext = new HashMap<>();
+        extraContext.put(ActionContext.PARAMETERS, params);
+
+        try {
+            ActionProxy proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.VALIDATION_ACTION_NAME, extraContext);
+            proxy.execute();
+            assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
+
+            Map<String, List<String>> errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
+            List<String> errorMessages = errors.get("bar");
+            assertEquals(1, errorMessages.size());
+
+            String errorMessage = errorMessages.get(0);
+            assertNotNull(errorMessage);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail();
+        }
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        XmlConfigurationProvider provider = new XmlConfigurationProvider("xwork-test-beans.xml");
+        container.inject(provider);
+        loadConfigurationProviders(provider, new MockConfigurationProvider());
+    }
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/test/java/com/opensymphony/xwork2/validator/LongRangeValidatorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/com/opensymphony/xwork2/validator/LongRangeValidatorTest.java b/core/src/test/java/com/opensymphony/xwork2/validator/LongRangeValidatorTest.java
new file mode 100644
index 0000000..dfed43e
--- /dev/null
+++ b/core/src/test/java/com/opensymphony/xwork2/validator/LongRangeValidatorTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2002-2003,2009 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.opensymphony.xwork2.validator;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionProxy;
+import com.opensymphony.xwork2.ValidationAware;
+import com.opensymphony.xwork2.XWorkTestCase;
+import com.opensymphony.xwork2.config.providers.MockConfigurationProvider;
+import com.opensymphony.xwork2.config.providers.XmlConfigurationProvider;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * LongRangeValidatorTest
+ * <p/>
+ *
+ */
+public class LongRangeValidatorTest extends XWorkTestCase {
+
+    public void testRangeValidation() {
+        HashMap<String, String> params = new HashMap<>();
+        params.put("longFoo", "200");
+
+        HashMap<String, Object> extraContext = new HashMap<>();
+        extraContext.put(ActionContext.PARAMETERS, params);
+
+        try {
+            ActionProxy proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.VALIDATION_ACTION_NAME, extraContext);
+            proxy.execute();
+            assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
+
+            Map errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
+            List errorMessages = (List) errors.get("longFoo");
+            assertEquals(1, errorMessages.size());
+
+            String errorMessage = (String) errorMessages.get(0);
+            assertNotNull(errorMessage);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail();
+        }
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        XmlConfigurationProvider provider = new XmlConfigurationProvider("xwork-test-beans.xml");
+        container.inject(provider);
+        loadConfigurationProviders(provider, new MockConfigurationProvider());
+    }
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/test/java/com/opensymphony/xwork2/validator/ModelDrivenValidationTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/com/opensymphony/xwork2/validator/ModelDrivenValidationTest.java b/core/src/test/java/com/opensymphony/xwork2/validator/ModelDrivenValidationTest.java
new file mode 100644
index 0000000..1ced1f5
--- /dev/null
+++ b/core/src/test/java/com/opensymphony/xwork2/validator/ModelDrivenValidationTest.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2002-2003,2009 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.opensymphony.xwork2.validator;
+
+import com.opensymphony.xwork2.*;
+import com.opensymphony.xwork2.config.providers.XmlConfigurationProvider;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * ModelDrivenValidationTest
+ *
+ * @author Jason Carreira
+ *         Created Oct 1, 2003 10:08:25 AM
+ */
+public class ModelDrivenValidationTest extends XWorkTestCase {
+
+    public void testModelDrivenValidation() throws Exception {
+        Map<String, Object> params = new HashMap<>();
+        params.put("count", new String[]{"11"});
+
+        Map<String, Object> context = new HashMap<>();
+        context.put(ActionContext.PARAMETERS, params);
+
+        XmlConfigurationProvider provider = new XmlConfigurationProvider("xwork-sample.xml");
+        container.inject(provider);
+        loadConfigurationProviders(provider);
+        ActionProxy proxy = actionProxyFactory.createActionProxy(null, "TestModelDrivenValidation", context);
+        assertEquals(Action.SUCCESS, proxy.execute());
+
+        ModelDrivenAction action = (ModelDrivenAction) proxy.getAction();
+        assertTrue(action.hasFieldErrors());
+        assertTrue(action.getFieldErrors().containsKey("count"));
+        assertEquals("count must be between 1 and 10, current value is 11.", ((List) action.getFieldErrors().get("count")).get(0));
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/test/java/com/opensymphony/xwork2/validator/MyValidator.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/com/opensymphony/xwork2/validator/MyValidator.java b/core/src/test/java/com/opensymphony/xwork2/validator/MyValidator.java
new file mode 100644
index 0000000..82f1f2b
--- /dev/null
+++ b/core/src/test/java/com/opensymphony/xwork2/validator/MyValidator.java
@@ -0,0 +1,96 @@
+package com.opensymphony.xwork2.validator;
+
+import com.opensymphony.xwork2.util.ValueStack;
+
+/**
+ * TODO lukaszlenart: write a JavaDoc
+ */
+public class MyValidator implements FieldValidator, ShortCircuitableValidator {
+
+    private String message;
+    private String fieldName;
+    private String key;
+    private String[] messageParameters;
+    private ValidatorContext validatorContext;
+    private String type;
+    private ValueStack stack;
+    private boolean shortcircuit;
+
+    private int value;
+
+    public int getValue() {
+        return value;
+    }
+
+    public void setValue(int value) {
+        this.value = value;
+    }
+
+    public void setFieldName(String fieldName) {
+        this.fieldName = fieldName;
+    }
+
+    public String getFieldName() {
+        return fieldName;
+    }
+
+    public void setDefaultMessage(String message) {
+        this.message = message;
+    }
+
+    public String getDefaultMessage() {
+        return message;
+    }
+
+    public String getMessage(Object object) {
+        return "Message";
+    }
+
+    public void setMessageKey(String key) {
+        this.key = key;
+    }
+
+    public String getMessageKey() {
+        return key;
+    }
+
+    public void setMessageParameters(String[] messageParameters) {
+        this.messageParameters = messageParameters;
+    }
+
+    public String[] getMessageParameters() {
+        return messageParameters;
+    }
+
+    public void setValidatorContext(ValidatorContext validatorContext) {
+        this.validatorContext = validatorContext;
+    }
+
+    public ValidatorContext getValidatorContext() {
+        return validatorContext;
+    }
+
+    public void validate(Object object) throws ValidationException {
+        // pass
+    }
+
+    public void setValidatorType(String type) {
+        this.type = type;
+    }
+
+    public String getValidatorType() {
+        return type;
+    }
+
+    public void setValueStack(ValueStack stack) {
+        this.stack = stack;
+    }
+
+    public void setShortCircuit(boolean shortcircuit) {
+        this.shortcircuit = shortcircuit;
+    }
+
+    public boolean isShortCircuit() {
+        return shortcircuit;
+    }
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/test/java/com/opensymphony/xwork2/validator/RegexFieldValidatorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/com/opensymphony/xwork2/validator/RegexFieldValidatorTest.java b/core/src/test/java/com/opensymphony/xwork2/validator/RegexFieldValidatorTest.java
new file mode 100644
index 0000000..bebf255
--- /dev/null
+++ b/core/src/test/java/com/opensymphony/xwork2/validator/RegexFieldValidatorTest.java
@@ -0,0 +1,195 @@
+/*
+ * Copyright 2002-2006,2009 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.opensymphony.xwork2.validator;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.XWorkTestCase;
+import com.opensymphony.xwork2.util.ValueStack;
+import com.opensymphony.xwork2.validator.validators.RegexFieldValidator;
+
+import java.util.List;
+
+/**
+ * Unit test for RegexFieldValidator.
+ * <p/>
+ * This unit test is only to test that the regex field validator works, not to
+ * unit test the build in reg.exp from JDK. That is why the expressions are so simple.
+ *
+ * @author Claus Ibsen
+ */
+public class RegexFieldValidatorTest extends XWorkTestCase {
+
+    public void testMatch() throws Exception {
+        MyTestPerson testPerson = new MyTestPerson();
+        testPerson.setUsername("Secret");
+
+        ValueStack stack = ActionContext.getContext().getValueStack();
+        ActionContext.getContext().setValueStack(stack);
+
+        RegexFieldValidator validator = new RegexFieldValidator();
+        validator.setRegex("^Sec.*");
+        validator.setValidatorContext(new GenericValidatorContext(new Object()));
+        validator.setFieldName("username");
+        validator.setValueStack(ActionContext.getContext().getValueStack());
+        validator.validate(testPerson);
+
+        assertFalse(validator.getValidatorContext().hasErrors());
+        assertFalse(validator.getValidatorContext().hasActionErrors());
+        assertFalse(validator.getValidatorContext().hasActionMessages());
+        assertFalse(validator.getValidatorContext().hasFieldErrors());
+    }
+
+    public void testMatchNoTrim() throws Exception {
+        MyTestPerson testPerson = new MyTestPerson();
+        testPerson.setUsername("Secret "); // must end with one whitespace
+
+        ValueStack stack = ActionContext.getContext().getValueStack();
+        ActionContext.getContext().setValueStack(stack);
+
+        RegexFieldValidator validator = new RegexFieldValidator();
+        validator.setTrim(false);
+        validator.setRegex("^Sec.*\\s");
+        validator.setValidatorContext(new GenericValidatorContext(new Object()));
+        validator.setFieldName("username");
+        validator.setValueStack(ActionContext.getContext().getValueStack());
+        validator.validate(testPerson);
+
+        assertFalse(validator.getValidatorContext().hasErrors());
+        assertFalse(validator.getValidatorContext().hasActionErrors());
+        assertFalse(validator.getValidatorContext().hasActionMessages());
+        assertFalse(validator.getValidatorContext().hasFieldErrors());
+    }
+
+    public void testFail() throws Exception {
+        MyTestPerson testPerson = new MyTestPerson();
+        testPerson.setUsername("Superman");
+
+        ValueStack stack = ActionContext.getContext().getValueStack();
+        ActionContext.getContext().setValueStack(stack);
+
+        RegexFieldValidator validator = new RegexFieldValidator();
+        validator.setRegex("^Sec.*");
+        validator.setValidatorContext(new GenericValidatorContext(new Object()));
+        validator.setFieldName("username");
+        validator.setValueStack(ActionContext.getContext().getValueStack());
+        validator.validate(testPerson);
+
+        assertTrue(validator.getValidatorContext().hasErrors());
+        assertTrue(validator.getValidatorContext().hasFieldErrors());
+        List<String> msgs = validator.getValidatorContext().getFieldErrors().get("username");
+        assertNotNull(msgs);
+        assertTrue(msgs.size() == 1); // should contain 1 error message
+
+        // when failing the validator will not add action errors/msg
+        assertFalse(validator.getValidatorContext().hasActionErrors());
+        assertFalse(validator.getValidatorContext().hasActionMessages());
+    }
+
+    public void testNoFieldName() throws Exception {
+        MyTestPerson testPerson = new MyTestPerson();
+        testPerson.setUsername("NoExpression");
+
+        ValueStack stack = ActionContext.getContext().getValueStack();
+        ActionContext.getContext().setValueStack(stack);
+
+        RegexFieldValidator validator = new RegexFieldValidator();
+        validator.setRegex("^Sec.*");
+        validator.setValidatorContext(new GenericValidatorContext(new Object()));
+        validator.setFieldName(null);
+        validator.setValueStack(ActionContext.getContext().getValueStack());
+        validator.validate(testPerson);
+
+        assertFalse(validator.getValidatorContext().hasErrors());
+        assertFalse(validator.getValidatorContext().hasActionErrors());
+        assertFalse(validator.getValidatorContext().hasActionMessages());
+        assertFalse(validator.getValidatorContext().hasFieldErrors());
+    }
+
+    public void testGetExpression() throws Exception {
+        RegexFieldValidator validator = new RegexFieldValidator();
+        validator.setRegex("^Hello.*");
+        assertEquals("^Hello.*", validator.getRegex());
+    }
+
+    public void testIsTrimmed() throws Exception {
+        RegexFieldValidator validator = new RegexFieldValidator();
+        assertEquals(true, validator.isTrimed());
+        validator.setTrim(false);
+        assertEquals(false, validator.isTrimed());
+    }
+
+    public void testEmptyName() throws Exception {
+        MyTestPerson testPerson = new MyTestPerson();
+        testPerson.setUsername("");
+
+        ValueStack stack = ActionContext.getContext().getValueStack();
+        ActionContext.getContext().setValueStack(stack);
+
+        RegexFieldValidator validator = new RegexFieldValidator();
+        validator.setRegex("^Sec.*");
+        validator.setValidatorContext(new GenericValidatorContext(new Object()));
+        validator.setFieldName("username");
+        validator.setValueStack(ActionContext.getContext().getValueStack());
+        validator.validate(testPerson);
+
+        assertFalse(validator.getValidatorContext().hasErrors());
+        assertFalse(validator.getValidatorContext().hasActionErrors());
+        assertFalse(validator.getValidatorContext().hasActionMessages());
+        assertFalse(validator.getValidatorContext().hasFieldErrors());
+    }
+
+    public void testNoStringField() throws Exception {
+        MyTestPerson testPerson = new MyTestPerson();
+        testPerson.setAge(33);
+
+        ValueStack stack = ActionContext.getContext().getValueStack();
+        ActionContext.getContext().setValueStack(stack);
+
+        RegexFieldValidator validator = new RegexFieldValidator();
+        validator.setRegex("[0-9][0-9]");
+        validator.setValidatorContext(new GenericValidatorContext(new Object()));
+        validator.setFieldName("age");
+        validator.setValueStack(ActionContext.getContext().getValueStack());
+        validator.validate(testPerson);
+
+        assertFalse(validator.getValidatorContext().hasErrors());
+        assertFalse(validator.getValidatorContext().hasActionErrors());
+        assertFalse(validator.getValidatorContext().hasActionMessages());
+        assertFalse(validator.getValidatorContext().hasFieldErrors());
+    }
+
+    private class MyTestPerson {
+        private String username;
+        private int age;
+
+        public String getUsername() {
+            return username;
+        }
+
+        public void setUsername(String username) {
+            this.username = username;
+        }
+
+        public int getAge() {
+            return age;
+        }
+
+        public void setAge(int age) {
+            this.age = age;
+        }
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/test/java/com/opensymphony/xwork2/validator/RepopulateConversionErrorFieldValidatorSupportTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/com/opensymphony/xwork2/validator/RepopulateConversionErrorFieldValidatorSupportTest.java b/core/src/test/java/com/opensymphony/xwork2/validator/RepopulateConversionErrorFieldValidatorSupportTest.java
new file mode 100644
index 0000000..308ed2a
--- /dev/null
+++ b/core/src/test/java/com/opensymphony/xwork2/validator/RepopulateConversionErrorFieldValidatorSupportTest.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2002-2006,2009 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.opensymphony.xwork2.validator;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionSupport;
+import com.opensymphony.xwork2.XWorkTestCase;
+import com.opensymphony.xwork2.mock.MockActionInvocation;
+import com.opensymphony.xwork2.util.ValueStack;
+import com.opensymphony.xwork2.validator.validators.RepopulateConversionErrorFieldValidatorSupport;
+
+import java.util.Map;
+
+/**
+ * Test RepopulateConversionErrorFieldValidatorSupport.
+ * 
+ * @author tm_jee
+ * @version $Date$ $Id$
+ */
+public class RepopulateConversionErrorFieldValidatorSupportTest extends XWorkTestCase {
+
+	
+	InternalRepopulateConversionErrorFieldValidatorSupport validator1;
+	InternalRepopulateConversionErrorFieldValidatorSupport validator2;
+	ActionSupport action;
+	
+	public void testUseFullFieldName() throws Exception {
+		validator2.setRepopulateField(true);
+		validator2.validate(action);
+		
+		ActionContext.getContext().getActionInvocation().invoke();
+		Object valueFromStack1 = ActionContext.getContext().getValueStack().findValue("someFieldName", String.class);
+		Object valueFromStack2 = ActionContext.getContext().getValueStack().findValue("xxxsomeFieldName", String.class);
+		
+		assertNull(valueFromStack1);
+		assertEquals(valueFromStack2, "some value");
+	}
+	
+	public void testGetterSetterGetsCalledApropriately1() throws Exception {
+		
+		validator1.setRepopulateField(true);
+		validator1.validate(action);
+
+		
+		ActionContext.getContext().getActionInvocation().invoke();
+		
+		Object valueFromStack = ActionContext.getContext().getValueStack().findValue("someFieldName", String.class);
+		
+		assertEquals(valueFromStack, "some value");
+	}
+	
+	
+	public void testGetterSetterGetsCalledApropriately2() throws Exception {
+		
+		validator1.setRepopulateField(false);
+		validator1.validate(action);
+
+		
+		ActionContext.getContext().getActionInvocation().invoke();
+		
+		Object valueFromStack = ActionContext.getContext().getValueStack().findValue("someFieldName", String.class);
+		
+		assertEquals(valueFromStack, null);
+	}
+	
+	
+	@Override
+    protected void setUp() throws Exception {
+	    super.setUp();
+		ValueStack stack = ActionContext.getContext().getValueStack();
+		MockActionInvocation invocation = new MockActionInvocation();
+		invocation.setStack(stack);
+		ActionContext.getContext().setValueStack(stack);
+		ActionContext.getContext().setActionInvocation(invocation);
+		
+		String[] conversionErrorValue = new String[] { "some value" };
+		Map<String, Object> conversionErrors = ActionContext.getContext().getConversionErrors();
+		conversionErrors.put("someFieldName", conversionErrorValue);
+		conversionErrors.put("xxxsomeFieldName", conversionErrorValue);
+		
+		action = new ActionSupport();
+		validator1 = 
+			new InternalRepopulateConversionErrorFieldValidatorSupport();
+		validator1.setFieldName("someFieldName");
+		validator1.setValidatorContext(new DelegatingValidatorContext(action));
+		
+		validator2 = 
+			new InternalRepopulateConversionErrorFieldValidatorSupport();
+		validator2.setFieldName("someFieldName");
+		validator2.setValidatorContext(new DelegatingValidatorContext(action) {
+			@Override
+            public String getFullFieldName(String fieldName) {
+				return "xxx"+fieldName;
+			}
+		});
+	}
+	
+	@Override
+    protected void tearDown() throws Exception {
+	    super.tearDown();
+		validator1 = null;
+		action = null;
+	}
+	
+	
+	// === inner class ============
+	
+	class InternalRepopulateConversionErrorFieldValidatorSupport extends RepopulateConversionErrorFieldValidatorSupport {
+		public boolean doValidateGetsCalled = false;
+		
+		@Override
+        protected void doValidate(Object object) throws ValidationException {
+			doValidateGetsCalled = true;
+		}
+	}
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/test/java/com/opensymphony/xwork2/validator/ShortRangeValidatorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/com/opensymphony/xwork2/validator/ShortRangeValidatorTest.java b/core/src/test/java/com/opensymphony/xwork2/validator/ShortRangeValidatorTest.java
new file mode 100644
index 0000000..22909df
--- /dev/null
+++ b/core/src/test/java/com/opensymphony/xwork2/validator/ShortRangeValidatorTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2002-2003,2009 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.opensymphony.xwork2.validator;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionProxy;
+import com.opensymphony.xwork2.ValidationAware;
+import com.opensymphony.xwork2.XWorkTestCase;
+import com.opensymphony.xwork2.config.providers.MockConfigurationProvider;
+import com.opensymphony.xwork2.config.providers.XmlConfigurationProvider;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * ShortRangeValidatorTest
+ * <p/>
+ *
+ */
+public class ShortRangeValidatorTest extends XWorkTestCase {
+
+    public void testRangeValidation() {
+        HashMap<String, Object> params = new HashMap<>();
+        params.put("shortFoo", "200");
+
+        HashMap<String, Object> extraContext = new HashMap<>();
+        extraContext.put(ActionContext.PARAMETERS, params);
+
+        try {
+            ActionProxy proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.VALIDATION_ACTION_NAME, extraContext);
+            proxy.execute();
+            assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
+
+            Map errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
+            List errorMessages = (List) errors.get("shortFoo");
+            assertEquals(1, errorMessages.size());
+
+            String errorMessage = (String) errorMessages.get(0);
+            assertNotNull(errorMessage);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail();
+        }
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        XmlConfigurationProvider provider = new XmlConfigurationProvider("xwork-test-beans.xml");
+        container.inject(provider);
+        loadConfigurationProviders(provider, new MockConfigurationProvider());
+    }
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/test/java/com/opensymphony/xwork2/validator/SimpleActionValidationTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/com/opensymphony/xwork2/validator/SimpleActionValidationTest.java b/core/src/test/java/com/opensymphony/xwork2/validator/SimpleActionValidationTest.java
new file mode 100644
index 0000000..dc1fad8
--- /dev/null
+++ b/core/src/test/java/com/opensymphony/xwork2/validator/SimpleActionValidationTest.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright 2002-2003,2009 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.opensymphony.xwork2.validator;
+
+import com.opensymphony.xwork2.*;
+import com.opensymphony.xwork2.config.providers.MockConfigurationProvider;
+import com.opensymphony.xwork2.config.providers.XmlConfigurationProvider;
+import com.opensymphony.xwork2.util.ValueStack;
+import com.opensymphony.xwork2.validator.validators.ValidatorSupport;
+
+import java.util.*;
+
+
+/**
+ * SimpleActionValidationTest
+ * <p/>
+ * Created : Jan 20, 2003 11:04:25 PM
+ *
+ * @author Jason Carreira
+ */
+public class SimpleActionValidationTest extends XWorkTestCase {
+
+    public void testAliasValidation() {
+        HashMap<String, Object> params = new HashMap<>();
+        params.put("baz", "10");
+
+        //valid values
+        params.put("bar", "7");
+        params.put("date", "12/23/2002");
+        params.put("percentage", "1.23456789");
+
+        HashMap<String, Object> extraContext = new HashMap<String, Object>();
+        extraContext.put(ActionContext.PARAMETERS, params);
+
+        try {
+            ActionProxy proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.VALIDATION_ACTION_NAME, extraContext);
+            proxy.execute();
+
+            ValidationAware validationAware = (ValidationAware) proxy.getAction();
+            assertFalse(validationAware.hasFieldErrors());
+
+            // put in an out-of-range value to see if the old validators still work
+            ActionContext.setContext(new ActionContext(new HashMap<String, Object>()));
+            params.put("bar", "42");
+            proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.VALIDATION_ALIAS_NAME, extraContext);
+            proxy.execute();
+            validationAware = (ValidationAware) proxy.getAction();
+            assertTrue(validationAware.hasFieldErrors());
+
+            Map<String, List<String>> errors = validationAware.getFieldErrors();
+            assertTrue(errors.containsKey("baz"));
+
+            List<String> bazErrors = errors.get("baz");
+            assertEquals(1, bazErrors.size());
+
+            String message = bazErrors.get(0);
+            assertEquals("baz out of range.", message);
+            assertTrue(errors.containsKey("bar"));
+
+            List<String> barErrors = errors.get("bar");
+            assertEquals(1, barErrors.size());
+            message = barErrors.get(0);
+            assertEquals("bar must be between 6 and 10, current value is 42.", message);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail();
+        }
+    }
+
+    public void testLookingUpFieldNameAsTextKey() {
+        HashMap<String, Object> params = new HashMap<>();
+
+        // should cause a message
+        params.put("baz", "-1");
+
+        //valid values
+        params.put("bar", "7");
+
+        HashMap<String, Object> extraContext = new HashMap<>();
+        extraContext.put(ActionContext.PARAMETERS, params);
+
+        try {
+            ActionProxy proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.VALIDATION_ACTION_NAME, extraContext);
+            proxy.execute();
+            assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
+
+            Map<String, List<String>> errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
+            List<String> bazErrors = errors.get("baz");
+            assertEquals(1, bazErrors.size());
+
+            String errorMessage = bazErrors.get(0);
+            assertNotNull(errorMessage);
+            assertEquals("Baz Field must be greater than 0", errorMessage);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail();
+        }
+    }
+
+    public void testMessageKey() {
+        HashMap<String, Object> params = new HashMap<>();
+        params.put("foo", "200");
+
+        HashMap<String, Object> extraContext = new HashMap<>();
+        extraContext.put(ActionContext.PARAMETERS, params);
+
+        try {
+            ActionProxy proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.VALIDATION_ACTION_NAME, extraContext);
+            ValueStack stack = ActionContext.getContext().getValueStack();
+            ActionContext.setContext(new ActionContext(stack.getContext()));
+            ActionContext.getContext().setLocale(Locale.US);
+            proxy.execute();
+            assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
+
+            Map<String, List<String>> errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
+            List<String> fooErrors = errors.get("foo");
+            assertEquals(1, fooErrors.size());
+
+            String errorMessage = fooErrors.get(0);
+            assertNotNull(errorMessage);
+            assertEquals("Foo Range Message", errorMessage);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail();
+        }
+    }
+
+    public void testMessageKeyIsReturnedIfNoOtherDefault() throws ValidationException {
+        Validator validator = new ValidatorSupport() {
+            public void validate(Object object) throws ValidationException {
+                addActionError(object);
+            }
+        };
+        validator.setValueStack(ActionContext.getContext().getValueStack());
+
+        String messageKey = "does.not.exist";
+        validator.setMessageKey(messageKey);
+
+        ValidatorContext validatorContext = new DelegatingValidatorContext(new SimpleAction());
+        validator.setValidatorContext(validatorContext);
+        validator.validate(this);
+        assertTrue(validatorContext.hasActionErrors());
+
+        Collection<String> errors = validatorContext.getActionErrors();
+        assertEquals(1, errors.size());
+        assertEquals(messageKey, errors.toArray()[0]);
+    }
+
+    public void testParamterizedMessage() {
+        HashMap<String, Object> params = new HashMap<>();
+        params.put("bar", "42");
+
+        HashMap<String, Object> extraContext = new HashMap<>();
+        extraContext.put(ActionContext.PARAMETERS, params);
+
+        try {
+            ActionProxy proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.VALIDATION_ACTION_NAME, extraContext);
+            proxy.execute();
+            assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
+
+            Map<String, List<String>> errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
+            List<String> barErrors = errors.get("bar");
+            assertEquals(1, barErrors.size());
+
+            String errorMessage = barErrors.get(0);
+            assertNotNull(errorMessage);
+            assertEquals("bar must be between 6 and 10, current value is 42.", errorMessage);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail();
+        }
+    }
+
+    public void testSubPropertiesAreValidated() {
+        HashMap<String, Object> params = new HashMap<>();
+        params.put("baz", "10");
+
+        //valid values
+        params.put("foo", "8");
+        params.put("bar", "7");
+        params.put("date", "12/23/2002");
+
+        params.put("bean.name", "Name should be valid");
+
+        // this should cause a message
+        params.put("bean.count", "100");
+
+        HashMap<String, Object> extraContext = new HashMap<>();
+        extraContext.put(ActionContext.PARAMETERS, params);
+
+        try {
+            ActionProxy proxy = actionProxyFactory.createActionProxy("", MockConfigurationProvider.VALIDATION_SUBPROPERTY_NAME, extraContext);
+            proxy.execute();
+            assertTrue(((ValidationAware) proxy.getAction()).hasFieldErrors());
+
+            Map<String, List<String>> errors = ((ValidationAware) proxy.getAction()).getFieldErrors();
+            List<String> beanCountErrors = errors.get("bean.count");
+            assertEquals(1, beanCountErrors.size());
+
+            String errorMessage = beanCountErrors.get(0);
+            assertNotNull(errorMessage);
+            assertEquals("bean.count out of range.", errorMessage);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail();
+        }
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        XmlConfigurationProvider provider = new XmlConfigurationProvider("xwork-test-beans.xml");
+        container.inject(provider);
+        loadConfigurationProviders(provider, new MockConfigurationProvider());
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/test/java/com/opensymphony/xwork2/validator/StringLengthFieldValidatorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/com/opensymphony/xwork2/validator/StringLengthFieldValidatorTest.java b/core/src/test/java/com/opensymphony/xwork2/validator/StringLengthFieldValidatorTest.java
new file mode 100644
index 0000000..1fae0a9
--- /dev/null
+++ b/core/src/test/java/com/opensymphony/xwork2/validator/StringLengthFieldValidatorTest.java
@@ -0,0 +1,220 @@
+/*
+ * Copyright 2002-2006,2009 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.opensymphony.xwork2.validator;
+
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionSupport;
+import com.opensymphony.xwork2.XWorkTestCase;
+import com.opensymphony.xwork2.util.ValueStack;
+import com.opensymphony.xwork2.validator.validators.StringLengthFieldValidator;
+
+/**
+ * 
+ * @author tm_jee
+ * @version $Date$ $Id$
+ */
+public class StringLengthFieldValidatorTest extends XWorkTestCase {
+
+	protected InternalActionSupport action;
+	protected StringLengthFieldValidator validator;
+	
+	public void testStringLengthEmptyNoTrim1() throws Exception {
+		action.setMyField("");
+		
+		validator.setTrim(false);
+		validator.validate(action);
+		
+		assertEquals(action.getMyField(), "");
+		assertFalse(action.hasFieldErrors());
+	}
+	
+	public void testStringLengthNullNoTrim() throws Exception {
+		action.setMyField(null);
+
+		validator.setTrim(false);
+		validator.validate(action);
+		
+		assertEquals(action.getMyField(), null);
+		assertFalse(action.hasFieldErrors());
+	}
+	
+	public void testStringLengthEmptyTrim1() throws Exception {
+		action.setMyField("   ");
+		
+		validator.setTrim(true);
+		validator.validate(action);
+		
+		assertEquals(action.getMyField(), "   ");
+		assertFalse(action.hasFieldErrors());
+	}
+	
+	public void testStringLengthEmptyNoTrim2() throws Exception {
+		action.setMyField("          ");
+		
+		validator.setTrim(false);
+		validator.validate(action);
+		
+		assertEquals(action.getMyField(), "          ");
+		assertTrue(action.hasFieldErrors());
+	}
+	
+	
+	public void testStringLengthNullTrim() throws Exception {
+		action.setMyField(null);
+
+		validator.setTrim(true);
+		validator.validate(action);
+		
+		assertEquals(action.getMyField(), null);
+		assertFalse(action.hasFieldErrors());
+	}
+	
+	public void testInvalidStringLengthNoTrim() throws Exception {
+		action.setMyField("abcdefghijklmn");
+		
+		validator.setTrim(false);
+		validator.validate(action);
+		
+		assertEquals(action.getMyField(), "abcdefghijklmn");
+		assertTrue(action.hasFieldErrors());
+	}
+	
+	public void testInvalidStringLengthTrim() throws Exception {
+		action.setMyField("abcdefghijklmn   ");
+		
+		validator.setTrim(true);
+		validator.validate(action);
+		
+		assertEquals(action.getMyField(), "abcdefghijklmn   ");
+		assertTrue(action.hasFieldErrors());
+	}
+	
+	public void testValidStringLengthNoTrim() throws Exception {
+		action.setMyField("   ");
+		
+		validator.setTrim(false);
+		validator.validate(action);
+		
+		assertEquals(action.getMyField(), "   ");
+		assertFalse(action.hasFieldErrors());
+	}
+	
+	public void testValidStringLengthTrim() throws Exception {
+		action.setMyField("asd          ");
+		
+		validator.setTrim(true);
+		validator.validate(action);
+		
+		assertEquals(action.getMyField(), "asd          ");
+		assertFalse(action.hasFieldErrors());
+	}
+
+    public void testMinLengthViaExpression() throws Exception {
+        assertEquals(2, validator.getMinLength());
+        action.setMinLengthValue(10);
+
+        validator.setMinLengthExpression("${minLengthValue}");
+
+        assertEquals(10, validator.getMinLength());
+    }
+
+    public void testMaxLengthViaExpression() throws Exception {
+        assertEquals(5, validator.getMaxLength());
+        action.setMaxLengthValue(100);
+
+        validator.setMaxLengthExpression("${maxLengthValue}");
+
+        assertEquals(100, validator.getMaxLength());
+    }
+
+    public void testTrimViaExpression() throws Exception {
+        assertTrue(validator.isTrim());
+        action.setTrimValue(false);
+
+        validator.setTrimExpression("${trimValue}");
+
+        assertFalse(validator.isTrim());
+    }
+
+    @Override
+	protected void setUp() throws Exception {
+		super.setUp();
+
+        action = new InternalActionSupport();
+        ValueStack valueStack = ActionContext.getContext().getValueStack();
+        valueStack.push(action);
+
+		validator = new StringLengthFieldValidator();
+		validator.setFieldName("myField");
+		validator.setMessageKey("error");
+		validator.setValidatorContext(new DelegatingValidatorContext(action));
+		validator.setMaxLength(5);
+		validator.setMinLength(2);
+        validator.setValueStack(valueStack);
+    }
+	
+	
+	@Override
+	protected void tearDown() throws Exception {
+		super.tearDown();
+		action = null;
+		validator = null;
+	}
+	
+	public static class InternalActionSupport extends ActionSupport {
+
+		private static final long serialVersionUID = 1L;
+
+        private String myField;
+        private boolean trimValue;
+        private int minLengthValue;
+        private int maxLengthValue;
+
+        public String getMyField() {
+            return this.myField;
+        }
+
+        public void setMyField(String myField) {
+            this.myField = myField;
+        }
+
+        public boolean isTrimValue() {
+            return trimValue;
+        }
+
+        public void setTrimValue(boolean trimValue) {
+            this.trimValue = trimValue;
+        }
+
+        public int getMinLengthValue() {
+            return minLengthValue;
+        }
+
+        public void setMinLengthValue(int minLengthValue) {
+            this.minLengthValue = minLengthValue;
+        }
+
+        public int getMaxLengthValue() {
+            return maxLengthValue;
+        }
+
+        public void setMaxLengthValue(int maxLengthValue) {
+            this.maxLengthValue = maxLengthValue;
+        }
+
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/test/java/com/opensymphony/xwork2/validator/StringValidatorTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/com/opensymphony/xwork2/validator/StringValidatorTest.java b/core/src/test/java/com/opensymphony/xwork2/validator/StringValidatorTest.java
new file mode 100644
index 0000000..9742b5a
--- /dev/null
+++ b/core/src/test/java/com/opensymphony/xwork2/validator/StringValidatorTest.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright 2002-2006,2009 The Apache Software Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.opensymphony.xwork2.validator;
+
+import com.opensymphony.xwork2.Action;
+import com.opensymphony.xwork2.ActionContext;
+import com.opensymphony.xwork2.ActionInvocation;
+import com.opensymphony.xwork2.ActionProxy;
+import com.opensymphony.xwork2.ValidationAwareSupport;
+import com.opensymphony.xwork2.XWorkTestCase;
+import com.opensymphony.xwork2.config.entities.ActionConfig;
+import com.opensymphony.xwork2.config.providers.MockConfigurationProvider;
+import com.opensymphony.xwork2.test.Equidae;
+import com.opensymphony.xwork2.validator.validators.RequiredStringValidator;
+import org.easymock.EasyMock;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author Mark Woon
+ * @author tm_jee (tm_jee (at) yahoo.co.uk )
+ */
+public class StringValidatorTest extends XWorkTestCase {
+
+    public void testRequiredStringWithNullValue() throws Exception {
+        Equidae equidae = new Equidae();
+        equidae.setHorse(null);
+
+        DelegatingValidatorContext context = new DelegatingValidatorContext(new ValidationAwareSupport());
+        container.getInstance(ActionValidatorManager.class).validate(equidae, null, context);
+
+        assertTrue(context.hasFieldErrors());
+    }
+
+
+    public void testRequiredString() throws Exception {
+        Equidae equidae = new Equidae();
+
+        // everything should fail
+        equidae.setHorse("");
+        ActionContext.getContext().getValueStack().push(equidae);
+
+        DelegatingValidatorContext context = new DelegatingValidatorContext(new ValidationAwareSupport());
+        container.getInstance(ActionValidatorManager.class).validate(equidae, null, context);
+
+        assertTrue(context.hasFieldErrors());
+
+        Map fieldErrors = context.getFieldErrors();
+        assertTrue(fieldErrors.containsKey("horse"));
+        assertEquals(2, ((List) fieldErrors.get("horse")).size());
+
+        // trim = false should fail
+        equidae.setHorse("  ");
+        ActionContext.getContext().getValueStack().push(equidae);
+        context = new DelegatingValidatorContext(new ValidationAwareSupport());
+        container.getInstance(ActionValidatorManager.class).validate(equidae, null, context);
+
+        assertTrue(context.hasFieldErrors());
+        fieldErrors = context.getFieldErrors();
+        assertTrue(fieldErrors.containsKey("horse"));
+
+        List errors = (List) fieldErrors.get("horse");
+        assertEquals(1, errors.size());
+        assertEquals("trim", (String) errors.get(0));
+    }
+
+    public void testStringLength() throws Exception {
+        Equidae equidae = new Equidae();
+
+        equidae.setCow("asdf");
+        equidae.setDonkey("asdf");
+        ActionContext.getContext().getValueStack().push(equidae);
+
+        DelegatingValidatorContext context = new DelegatingValidatorContext(new ValidationAwareSupport());
+        container.getInstance(ActionValidatorManager.class).validate(equidae, null, context);
+        assertTrue(context.hasFieldErrors());
+
+        Map fieldErrors = context.getFieldErrors();
+
+        // cow
+        assertTrue(fieldErrors.containsKey("cow"));
+
+        List errors = (List) fieldErrors.get("cow");
+        assertEquals(2, errors.size());
+        assertEquals("noTrim-min5", errors.get(0));
+        assertEquals("noTrim-min5-max10", errors.get(1));
+
+        // donkey
+        assertTrue(fieldErrors.containsKey("donkey"));
+        errors = (List) fieldErrors.get("donkey");
+        assertEquals(2, errors.size());
+        assertEquals("trim-min5", errors.get(0));
+        assertEquals("trim-min5-max10", errors.get(1));
+
+        equidae.setCow("asdf  ");
+        equidae.setDonkey("asdf  ");
+        ActionContext.getContext().getValueStack().push(equidae);
+        context = new DelegatingValidatorContext(new ValidationAwareSupport());
+        container.getInstance(ActionValidatorManager.class).validate(equidae, null, context);
+        assertTrue(context.hasFieldErrors());
+
+        fieldErrors = context.getFieldErrors();
+
+        // cow
+        assertFalse(fieldErrors.containsKey("cow"));
+
+        // donkey
+        assertTrue(fieldErrors.containsKey("donkey"));
+        errors = (List) fieldErrors.get("donkey");
+        assertEquals(2, errors.size());
+        assertEquals("trim-min5", errors.get(0));
+        assertEquals("trim-min5-max10", errors.get(1));
+
+        equidae.setCow("asdfasdf");
+        equidae.setDonkey("asdfasdf");
+        ActionContext.getContext().getValueStack().push(equidae);
+        context = new DelegatingValidatorContext(new ValidationAwareSupport());
+        container.getInstance(ActionValidatorManager.class).validate(equidae, null, context);
+        assertTrue(context.hasFieldErrors());
+
+        fieldErrors = context.getFieldErrors();
+
+        // cow
+        assertFalse(fieldErrors.containsKey("cow"));
+
+        // donkey
+        assertFalse(fieldErrors.containsKey("donkey"));
+
+        equidae.setCow("asdfasdf   ");
+        equidae.setDonkey("asdfasdf   ");
+        ActionContext.getContext().getValueStack().push(equidae);
+        context = new DelegatingValidatorContext(new ValidationAwareSupport());
+        container.getInstance(ActionValidatorManager.class).validate(equidae, null, context);
+        assertTrue(context.hasFieldErrors());
+
+        fieldErrors = context.getFieldErrors();
+
+        // cow
+        assertTrue(fieldErrors.containsKey("cow"));
+        errors = (List) fieldErrors.get("cow");
+        assertEquals(2, errors.size());
+        assertEquals("noTrim-min5-max10", errors.get(0));
+        assertEquals("noTrim-max10", errors.get(1));
+
+        // donkey
+        assertFalse(fieldErrors.containsKey("donkey"));
+
+        equidae.setCow("asdfasdfasdf");
+        equidae.setDonkey("asdfasdfasdf");
+        ActionContext.getContext().getValueStack().push(equidae);
+        context = new DelegatingValidatorContext(new ValidationAwareSupport());
+        container.getInstance(ActionValidatorManager.class).validate(equidae, null, context);
+        assertTrue(context.hasFieldErrors());
+
+        fieldErrors = context.getFieldErrors();
+
+        // cow
+        assertTrue(fieldErrors.containsKey("cow"));
+        errors = (List) fieldErrors.get("cow");
+        assertEquals(2, errors.size());
+        assertEquals("noTrim-min5-max10", errors.get(0));
+        assertEquals("noTrim-max10", errors.get(1));
+
+        // donkey
+        assertTrue(fieldErrors.containsKey("donkey"));
+        errors = (List) fieldErrors.get("donkey");
+        assertEquals(2, errors.size());
+        assertEquals("trim-min5-max10", errors.get(0));
+        assertEquals("trim-max10", errors.get(1));
+    }
+
+    public void testGetSetTrim() {
+        RequiredStringValidator val = new RequiredStringValidator();
+
+        val.setTrim(true);
+        assertEquals(true, val.isTrim());
+
+        val.setTrim(false);
+        assertEquals(false, val.isTrim());
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        loadConfigurationProviders(new MockConfigurationProvider());
+
+        ActionConfig config = new ActionConfig.Builder("", "name", "").build();
+        ActionInvocation invocation = EasyMock.createNiceMock(ActionInvocation.class);
+        ActionProxy proxy = EasyMock.createNiceMock(ActionProxy.class);
+
+        EasyMock.expect(invocation.getProxy()).andReturn(proxy).anyTimes();
+        EasyMock.expect(invocation.getAction()).andReturn(null).anyTimes();
+        EasyMock.expect(invocation.invoke()).andReturn(Action.SUCCESS).anyTimes();
+        EasyMock.expect(proxy.getMethod()).andReturn("execute").anyTimes();
+        EasyMock.expect(proxy.getConfig()).andReturn(config).anyTimes();
+
+
+        EasyMock.replay(invocation);
+        EasyMock.replay(proxy);
+
+        ActionContext.getContext().setActionInvocation(invocation);
+    }
+}


Mime
View raw message