public void testEmpty() {
String testStr = "";
assertTrue(StringUtil.isEmpty(testStr));
testStr = null;
assertTrue(StringUtil.isEmpty(testStr));
}
private static boolean allRangeComponentsAreEmpty(
String opLeft, String valLeft, String opRight, String valRight) {
boolean fromOpBlank = StringUtil.isEmpty(opLeft);
boolean toOpBlank = StringUtil.isEmpty(opRight);
boolean fromValueBlank = StringUtil.isEmpty(valLeft);
boolean toValueBlank = StringUtil.isEmpty(valRight);
return (fromOpBlank && toOpBlank && fromValueBlank && toValueBlank);
}
public void testNotEmpty() {
String testStr = "x";
assertTrue(!StringUtil.isEmpty(testStr));
testStr = "notherstring";
assertTrue(!StringUtil.isEmpty(testStr));
testStr = " ";
assertTrue(!StringUtil.isEmpty(testStr));
}
/**
* This method validates a range of numeric values.
*
* <p>Each side of the range includes a relational operator (>,>=,<,<=,=) and the value. The value
* can include a decimal number with an optional space and then anything to the right of the space
* is ignored (like units: mm).
*
* <p>Though vacuous, if neither side is specified, the range is considered to be valid. Not
* counting when nothing is specified, the left "side" is required, and the right side is
* optional. When specifying a side, both the operator and value must be specified.
*
* <p>When the range is ok, null is returned. Otherwise a cryptic string is returned.... this
* string is a key to a resource bundle or something? no clue.
*
* <p>(Apparently) bad things about this method that am afraid to change:
*
* <ul>
* <li>This is a ** validation ** method whose main point is to return a _message_ if something
* is wrong, but if the value isn't a decimal number it throws an exception instead of
* returning a message.
* <li>The left value being 0 is considered an error. What about negative numbers!!!!?!?!!?!??!?
* <li>when an operator is = and there is both a left and right side this method considers that
* valid....
* </ul>
*/
public static String validateRange(
String opLeft, String valLeft, String opRight, String valRight) {
logger.debug(
"validation for range: " + opLeft + "|" + valLeft + "|" + opRight + "|" + valRight);
if (allRangeComponentsAreEmpty(opLeft, valLeft, opRight, valRight)) {
return null;
}
// Make sure that the left operator and value are filled out
if (leftSideHasEmptyComponent(opLeft, valLeft)) {
return ResourceBundleUtil.getString("searchNoRange");
}
// Makes sure both right values are either selected or deselected
if (rightSideHasOnlyOneComponent(opRight, valRight)) {
return ResourceBundleUtil.getString("searchInvalidOperator");
}
// Look for a space in the value (e.g. '0 mm') and ignore anything after the space
valLeft = stripUnits(valLeft);
double leftVal = Double.parseDouble(valLeft);
// Makes sure no values are selected on the right if you are using less
// than
if (opLeft.equals(RangeData.LESS_THAN) || opLeft.equals(RangeData.LESS_THAN_EQUAL)) {
if (!StringUtil.isEmpty(opRight)) {
return ResourceBundleUtil.getString("searchInvalidRightOperator");
}
if (leftVal == 0) {
return ResourceBundleUtil.getString("searchValueZero");
}
} else {
if (!StringUtil.isEmpty(valRight)) {
valRight = stripUnits(valRight);
double rightVal = Double.parseDouble(valRight);
// Makes sure that the values of the range selected are valid
if (rightVal <= leftVal) {
return ResourceBundleUtil.getString("searchInvalidRange");
}
}
}
// Return null if no errors found
return null;
}
/**
* This range is "empty" if:
*
* <ul>
* <li>neither operator is specified (regardless of value??)
* <li>assuming both operators are not blank, then if either side has an operator it must have a
* value (or be considered empty).
* </ul>
*
* If there's no from:/left side specified, but there's a to:/right side specified, it's NOT empty
* which doesn't really jive with {@link #validateRange}
*/
public boolean isEmpty() {
boolean fromOpBlank = StringUtil.isEmpty(fromOperator);
boolean toOpBlank = StringUtil.isEmpty(toOperator);
boolean fromValueBlank = (fromValue == null);
boolean toValueBlank = (toValue == null);
if (fromOpBlank && toOpBlank) {
return true;
}
if (!fromOpBlank && fromValueBlank) {
return true;
}
if (!toOpBlank && toValueBlank) {
return true;
}
return false;
}
private static boolean rightSideHasOnlyOneComponent(String opRight, String valRight) {
return StringUtil.isEmpty(opRight) ^ StringUtil.isEmpty(valRight);
}
private static boolean leftSideHasEmptyComponent(String opLeft, String valLeft) {
return StringUtil.isEmpty(opLeft) || StringUtil.isEmpty(valLeft);
}
