Apache
/
commons-lang
mirror of https://github.com/apache/commons-lang.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Applying Valentin Rocher's patch to LANG-579, adding new regexp and in range methods to Validate 

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/lang/trunk@907382 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Henri Yandell 2010-02-07 05:40:10 +00:00
parent 76660f4a98
commit 779828c9a2
3 changed files with 229 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
pom.xml
View File

@ -339,6 +339,9 @@
<contributor>
<name>Antony Riley</name>
</contributor>
<contributor>
<name>Valentin Rocher</name>
</contributor>
<contributor>
<name>Scott Sanders</name>
</contributor>

135
src/main/java/org/apache/commons/lang3/Validate.java
View File

@ -19,6 +19,7 @@ package org.apache.commons.lang3;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.regex.Pattern;
/**
* <p>This class assists in validating arguments. The validation methods are
@ -48,6 +49,9 @@ import java.util.Map;
*/
public class Validate {
private static final String DEFAULT_EXCLUSIVE_BETWEEN_EX_MESSAGE = "The value %s is not in the specified exclusive range of %s to %s";
private static final String DEFAULT_INCLUSIVE_BETWEEN_EX_MESSAGE = "The value %s is not in the specified inclusive range of %s to %s";
private static final String DEFAULT_MATCHES_PATTERN_EX = "The string %s does not match the pattern %s";
private static final String DEFAULT_IS_NULL_EX_MESSAGE = "The validated object is null";
private static final String DEFAULT_IS_TRUE_EX_MESSAGE = "The validated expression is false";
private static final String DEFAULT_NO_NULL_ELEMENTS_ARRAY_EX_MESSAGE = "The validated array contains null element at index: %d";
@ -781,5 +785,134 @@ public class Validate {
throw new IllegalStateException(String.format(message, values));
}
}
/**
* <p>Validate that the specified argument character sequence matches the specified regular
* expression pattern; otherwise throwing an exception.</p>
*
* <pre>Validate.matchesPattern("hi", "[a-z]*");</pre>
*
* <p>The syntax of the pattern is the one used in the {@link Pattern} class.</p>
*
* @param input the character sequence to validate
* @param pattern regular expression pattern
* @throws IllegalArgumentException if the character sequence does not match the pattern
* @see #matchesPattern(String, String, String, Object...)
*/
public static void matchesPattern(CharSequence input, String pattern)
{
if (Pattern.matches(pattern, input) == false)
{
throw new IllegalArgumentException(String.format(DEFAULT_MATCHES_PATTERN_EX, input, pattern));
}
}
/**
* <p>Validate that the specified argument character sequence matches the specified regular
* expression pattern; otherwise throwing an exception with the specified message.</p>
*
* <pre>Validate.matchesPattern("hi", "[a-z]*", "%s does not match %s", "hi" "[a-z]*");</pre>
*
* <p>The syntax of the pattern is the one used in the {@link Pattern} class.</p>
*
* @param input the character sequence to validate
* @param pattern regular expression pattern
* @param message the exception message
* @param optional values to replace in the exception message
* @throws IllegalArgumentException if the character sequence does not match the pattern
* @see #matchesPattern(String, String)
*/
public static void matchesPattern(CharSequence input, String pattern, String message, Object... values)
{
if (Pattern.matches(pattern, input) == false)
{
throw new IllegalArgumentException(String.format(message, values));
}
}
/**
* <p>Validate that the specified argument object fall between the two
* inclusive values specified; otherwise, throws an exception.</p>
*
* <pre>Validate.inclusiveBetween(0, 2, 1);</pre>
*
* @param value the object to validate
* @param start the inclusive start value
* @param end the inclusive end value
* @throws IllegalArgumentException if the value falls out of the boundaries
* @see #inclusiveBetween(Object, Object, Comparable, String, Object...)
*/
public static <T> void inclusiveBetween(T start, T end, Comparable<T> value)
{
if (value.compareTo(start) < 0 || value.compareTo(end) > 0)
{
throw new IllegalArgumentException(String.format(DEFAULT_INCLUSIVE_BETWEEN_EX_MESSAGE, value, start, end));
}
}
/**
* <p>Validate that the specified argument object fall between the two
* inclusive values specified; otherwise, throws an exception with the
* specified message.</p>
*
* <pre>Validate.inclusiveBetween(0, 2, 1, "Not in boundaries");</pre>
*
* @param value the object to validate
* @param start the inclusive start value
* @param end the inclusive end value
* @param message the exception message
* @param optional values to replace in the exception message
* @throws IllegalArgumentException if the value falls out of the boundaries
* @see #inclusiveBetween(Object, Object, Comparable)
*/
public static <T> void inclusiveBetween(T start, T end, Comparable<T> value, String message, Object... values)
{
if (value.compareTo(start) < 0 || value.compareTo(end) > 0)
{
throw new IllegalArgumentException(String.format(message, values));
}
}
/**
* <p>Validate that the specified argument object fall between the two
* exclusive values specified; otherwise, throws an exception.</p>
*
* <pre>Validate.inclusiveBetween(0, 2, 1);</pre>
*
* @param value the object to validate
* @param start the exclusive start value
* @param end the exclusive end value
* @throws IllegalArgumentException if the value falls out of the boundaries
* @see #exclusiveBetween(Object, Object, Comparable, String, Object...)
*/
public static <T> void exclusiveBetween(T start, T end, Comparable<T> value)
{
if (value.compareTo(start) <= 0 || value.compareTo(end) >= 0)
{
throw new IllegalArgumentException(String.format(DEFAULT_EXCLUSIVE_BETWEEN_EX_MESSAGE, value, start, end));
}
}
/**
* <p>Validate that the specified argument object fall between the two
* exclusive values specified; otherwise, throws an exception with the
* specified message.</p>
*
* <pre>Validate.inclusiveBetween(0, 2, 1, "Not in boundaries");</pre>
*
* @param value the object to validate
* @param start the exclusive start value
* @param end the exclusive end value
* @param message the exception message
* @param optional values to replace in the exception message
* @throws IllegalArgumentException if the value falls out of the boundaries
* @see #exclusiveBetween(Object, Object, Comparable)
*/
public static <T> void exclusiveBetween(T start, T end, Comparable<T> value, String message, Object... values)
{
if (value.compareTo(start) <= 0 || value.compareTo(end) >= 0)
{
throw new IllegalArgumentException(String.format(message, values));
}
}
}

93
src/test/java/org/apache/commons/lang3/ValidateTest.java
View File

@ -754,5 +754,96 @@ public class ValidateTest extends TestCase {
String test = Validate.validIndex(input, 0);
assertSame(input, test);
}
public void testMatchesPattern()
{
CharSequence str = "hi";
Validate.matchesPattern(str, "[a-z]*");
try
{
Validate.matchesPattern(str, "[0-9]*");
fail("Expecting IllegalArgumentException");
}
catch (IllegalArgumentException e)
{
assertEquals("The string hi does not match the pattern [0-9]*", e.getMessage());
}
}
public void testMatchesPattern_withMessage()
{
CharSequence str = "hi";
Validate.matchesPattern(str, "[a-z]*", "Does not match");
try
{
Validate.matchesPattern(str, "[0-9]*", "Does not match");
fail("Expecting IllegalArgumentException");
}
catch (IllegalArgumentException e)
{
assertEquals("Does not match", e.getMessage());
}
}
public void testInclusiveBetween()
{
Validate.inclusiveBetween("a", "c", "b");
Validate.inclusiveBetween(0, 2, 1);
Validate.inclusiveBetween(0, 2, 2);
try {
Validate.inclusiveBetween(0, 5, 6);
fail("Expecting IllegalArgumentException");
} catch (IllegalArgumentException e) {
assertEquals("The value 6 is not in the specified inclusive range of 0 to 5", e.getMessage());
}
}
public void testInclusiveBetween_withMessage()
{
Validate.inclusiveBetween("a", "c", "b", "Error");
Validate.inclusiveBetween(0, 2, 1, "Error");
Validate.inclusiveBetween(0, 2, 2, "Error");
try {
Validate.inclusiveBetween(0, 5, 6, "Error");
fail("Expecting IllegalArgumentException");
} catch (IllegalArgumentException e) {
assertEquals("Error", e.getMessage());
}
}
public void testExclusiveBetween()
{
Validate.exclusiveBetween("a", "c", "b");
Validate.exclusiveBetween(0, 2, 1);
try {
Validate.exclusiveBetween(0, 5, 6);
fail("Expecting IllegalArgumentException");
} catch (IllegalArgumentException e) {
assertEquals("The value 6 is not in the specified exclusive range of 0 to 5", e.getMessage());
}
try {
Validate.exclusiveBetween(0, 5, 5);
fail("Expecting IllegalArgumentException");
} catch (IllegalArgumentException e) {
assertEquals("The value 5 is not in the specified exclusive range of 0 to 5", e.getMessage());
}
}
public void testExclusiveBetween_withMessage()
{
Validate.exclusiveBetween("a", "c", "b", "Error");
Validate.exclusiveBetween(0, 2, 1, "Error");
try {
Validate.exclusiveBetween(0, 5, 6, "Error");
fail("Expecting IllegalArgumentException");
} catch (IllegalArgumentException e) {
assertEquals("Error", e.getMessage());
}
try {
Validate.exclusiveBetween(0, 5, 5, "Error");
fail("Expecting IllegalArgumentException");
} catch (IllegalArgumentException e) {
assertEquals("Error", e.getMessage());
}
}
}