/** * Test Null value */ public void testNullValue() { RegexValidator validator = new RegexValidator(REGEX); assertEquals("Instance isValid()", false, validator.isValid(null)); assertEquals("Instance validate()", null, validator.validate(null)); assertEquals("Instance match()", null, validator.match(null)); }
final boolean isValidDomainSyntax(String domain) { if (domain == null) { return false; } domain = unicodeToASCII(domain); // hosts must be equally reachable via punycode and Unicode; // Unicode is never shorter than punycode, so check punycode // if domain did not convert, then it will be caught by ASCII // checks in the regexes below if (domain.length() > MAX_DOMAIN_LENGTH) { return false; } String[] groups = domainRegex.match(domain); return (groups != null && groups.length > 0) || hostnameRegex.isValid(domain); }
/** * Test toString() method */ public void testToString() { RegexValidator single = new RegexValidator(REGEX); assertEquals("Single", "RegexValidator{" + REGEX + "}", single.toString()); RegexValidator multiple = new RegexValidator(new String[] {REGEX, REGEX}); assertEquals("Multiple", "RegexValidator{" + REGEX + "," + REGEX + "}", multiple.toString()); }
/** * Construct a code validator with a specified regular * expression, minimum/maximum length and {@link CheckDigit} validation. * The RegexValidator validator is created to be case-sensitive * * @param regex The regular expression * @param minLength The minimum length of the code * @param maxLength The maximum length of the code * @param checkdigit The check digit validation routine */ public CodeValidator(String regex, int minLength, int maxLength, CheckDigit checkdigit) { if (regex != null && regex.length() > 0) { this.regexValidator = new RegexValidator(regex); } else { this.regexValidator = null; } this.minLength = minLength; this.maxLength = maxLength; this.checkdigit = checkdigit; }
public static boolean isValidMac(final String macAddr) { RegexValidator mv = new RegexValidator("^(?:[0-9a-f]{1,2}([-:\\.]))(?:[0-9a-f]{1,2}\\1){4}[0-9a-f]{1,2}$", false); return mv.isValid(macAddr); }
/** * Validate an IBAN Code * * @param code The value validation is being performed on * @return <code>true</code> if the value is valid */ public boolean isValid(String code) { Validator formatValidator = getValidator(code); if (formatValidator == null || code.length() != formatValidator.lengthOfIBAN || !formatValidator.validator.isValid(code)) { return false; } return IBANCheckDigit.IBAN_CHECK_DIGIT.isValid(code); }
// Copied from org.apache.commons.validator.routines.DomainValidator private static final String DOMAIN_LABEL_REGEX = "\\p{Alnum}(?>[\\p{Alnum}-]*\\p{Alnum})*"; // Changed to include new gTLD - http://data.iana.org/TLD/tlds-alpha-by-domain.txt private static final String TOP_LABEL_REGEX = "\\p{Alpha}[\\p{Alnum}-]*\\p{Alpha}"; // Copied from org.apache.commons.validator.routines.DomainValidator private static final String DOMAIN_NAME_REGEX = "^(?:" + DOMAIN_LABEL_REGEX + "\\.)+" + "(" + TOP_LABEL_REGEX + ")$"; private static final RegexValidator domainRegex = new RegexValidator(DOMAIN_NAME_REGEX); private static final EmailValidator EMAIL_VALIDATOR = new EmailValidator(); public static boolean isValidDomain(String domain) { String[] groups = domainRegex.match(domain); return groups != null && groups.length > 0; }
/** * Test using separators */ public void testMastercardUsingSeparators() { String MASTERCARD_REGEX_SEP = "^(5[1-5]\\d{2})(?:[- ])?(\\d{4})(?:[- ])?(\\d{4})(?:[- ])?(\\d{4})$"; CodeValidator validator = new CodeValidator(MASTERCARD_REGEX_SEP, LuhnCheckDigit.LUHN_CHECK_DIGIT); RegexValidator regex = validator.getRegexValidator(); // ****** Test Regular Expression ****** // length 16 and start with a "51-55" assertEquals("Number", "5134567890123456", regex.validate("5134567890123456")); assertEquals("Hyphen", "5134567890123456", regex.validate("5134-5678-9012-3456")); assertEquals("Space", "5134567890123456", regex.validate("5134 5678 9012 3456")); assertEquals("MixedA", "5134567890123456", regex.validate("5134-5678 9012-3456")); assertEquals("MixedB", "5134567890123456", regex.validate("5134 5678-9012 3456")); assertFalse("Invalid Separator A", regex.isValid("5134.5678.9012.3456")); assertFalse("Invalid Separator B", regex.isValid("5134_5678_9012_3456")); assertFalse("Invalid Grouping A", regex.isValid("513-45678-9012-3456")); assertFalse("Invalid Grouping B", regex.isValid("5134-567-89012-3456")); assertFalse("Invalid Grouping C", regex.isValid("5134-5678-901-23456")); // *********** Test Validator ********** assertEquals("Valid-A", "5500000000000004", validator.validate("5500-0000-0000-0004")); assertEquals("Valid-B", "5424000000000015", validator.validate("5424 0000 0000 0015")); assertEquals("Valid-C", "5301250070000191", validator.validate("5301-250070000191")); assertEquals("Valid-D", "5123456789012346", validator.validate("5123456789012346")); }
String[] groups = ipv4Validator.match(inet4Address);
code = regexValidator.validate(code); if (code == null) { return null;
/** * Test exceptions */ public void testExceptions() { String invalidRegex = "^([abCD12]*$"; try { new RegexValidator(invalidRegex); } catch (PatternSyntaxException e) { // expected } }
/** * Checks if the value matches the regular expression. */ public boolean matchRegex(String pattern, String input) { return new RegexValidator(pattern).isValid(input); }
/** * Returns true if the specified <code>String</code> parses * as a valid domain name with a recognized top-level domain. * The parsing is case-insensitive. * @param domain the parameter to check for domain name syntax * @return true if the parameter is a valid domain name */ public boolean isValid(String domain) { if (domain == null) { return false; } domain = unicodeToASCII(domain); // hosts must be equally reachable via punycode and Unicode; // Unicode is never shorter than punycode, so check punycode // if domain did not convert, then it will be caught by ASCII // checks in the regexes below if (domain.length() > MAX_DOMAIN_LENGTH) { return false; } String[] groups = domainRegex.match(domain); if (groups != null && groups.length > 0) { return isValidTld(groups[0]); } return allowLocal && hostnameRegex.isValid(domain); }
if (authorityValidator != null && authorityValidator.isValid(authority)) { return true;
RegexValidator regex = new RegexValidator("^[0-9]*$"); assertEquals("Constructor 4 - regex", "RegexValidator{^[0-9]*$}", validator.getRegexValidator().toString()); assertEquals("Constructor 4 - min length", -1, validator.getMinLength()); assertEquals("Constructor 4 - max length", -1, validator.getMaxLength()); assertEquals("Constructor 5 - regex", "RegexValidator{^[0-9]*$}", validator.getRegexValidator().toString()); assertEquals("Constructor 5 - min length", 13, validator.getMinLength()); assertEquals("Constructor 5 - max length", 13, validator.getMaxLength()); assertEquals("Constructor 6 - regex", "RegexValidator{^[0-9]*$}", validator.getRegexValidator().toString()); assertEquals("Constructor 6 - min length", 10, validator.getMinLength()); assertEquals("Constructor 6 - max length", 20, validator.getMaxLength());
@Override // must return full string public String validate(String value) { if (super.match(value) != null) { int length = value.length(); for(CreditCardRange range : ccr) { if (validLength(length, range)) { if (range.high == null) { // single prefix only if (value.startsWith(range.low)) { return value; } } else if (range.low.compareTo(value) <= 0 // no need to trim value here && // here we have to ignore digits beyond the prefix range.high.compareTo(value.substring(0, range.high.length())) >= 0) { return value; } } } } return null; } @Override
code = regexValidator.validate(code); if (code == null) { return null;
/** * Test instance methods with single regular expression. */ public void testSingle() { RegexValidator sensitive = new RegexValidator(REGEX); RegexValidator insensitive = new RegexValidator(REGEX, false); // isValid() assertEquals("Sensitive isValid() valid", true, sensitive.isValid("ac-DE-1")); assertEquals("Sensitive isValid() invalid", false, sensitive.isValid("AB-de-1")); assertEquals("Insensitive isValid() valid", true, insensitive.isValid("AB-de-1")); assertEquals("Insensitive isValid() invalid", false, insensitive.isValid("ABd-de-1")); // validate() assertEquals("Sensitive validate() valid", "acDE1", sensitive.validate("ac-DE-1")); assertEquals("Sensitive validate() invalid", null, sensitive.validate("AB-de-1")); assertEquals("Insensitive validate() valid", "ABde1", insensitive.validate("AB-de-1")); assertEquals("Insensitive validate() invalid", null, insensitive.validate("ABd-de-1")); // match() checkArray("Sensitive match() valid", new String[] {"ac", "DE", "1"}, sensitive.match("ac-DE-1")); checkArray("Sensitive match() invalid", null, sensitive.match("AB-de-1")); checkArray("Insensitive match() valid", new String[] {"AB", "de", "1"}, insensitive.match("AB-de-1")); checkArray("Insensitive match() invalid", null, insensitive.match("ABd-de-1")); assertEquals("validate one", "ABC", (new RegexValidator("^([A-Z]*)$")).validate("ABC")); checkArray("match one", new String[] {"ABC"}, (new RegexValidator("^([A-Z]*)$")).match("ABC")); }
/** * Creates the validator * @param cc the country code * @param len the length of the IBAN * @param format the regex to use to check the format */ public Validator(String cc, int len, String format) { if (!(cc.length() == 2 && Character.isUpperCase(cc.charAt(0)) && Character.isUpperCase(cc.charAt(1)))) { throw new IllegalArgumentException("Invalid country Code; must be exactly 2 upper-case characters"); } if (len > MAX_LEN || len < MIN_LEN) { throw new IllegalArgumentException("Invalid length parameter, must be in range "+MIN_LEN+" to "+MAX_LEN+" inclusive: " +len); } if (!format.startsWith(cc)) { throw new IllegalArgumentException("countryCode '"+cc+"' does not agree with format: " + format); } this.countryCode = cc; this.lengthOfIBAN = len; this.validator = new RegexValidator(format); } }
public static boolean isValidMac(final String macAddr) { final RegexValidator mv = new RegexValidator("^(?:[0-9a-f]{1,2}([-:\\.]))(?:[0-9a-f]{1,2}\\1){4}[0-9a-f]{1,2}$", false); return mv.isValid(macAddr); }