/** * 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); }
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); }
/** * 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;
assertFalse("Length 12-300", regex.isValid("300456789012")); assertFalse("Length 12-36", regex.isValid("363456789012")); assertFalse("Length 13-300", regex.isValid("3004567890123")); assertFalse("Length 13-36", regex.isValid("3634567890123")); assertTrue("Length 14-300", regex.isValid("30045678901234")); assertTrue("Length 14-36", regex.isValid("36345678901234")); assertFalse("Length 15-300", regex.isValid("300456789012345")); assertFalse("Length 15-36", regex.isValid("363456789012345")); assertFalse("Length 16-300", regex.isValid("3004567890123456")); assertFalse("Length 16-36", regex.isValid("3634567890123456")); assertFalse("Length 17-300", regex.isValid("30045678901234567")); assertFalse("Length 17-36", regex.isValid("36345678901234567")); assertFalse("Length 18-300", regex.isValid("300456789012345678")); assertFalse("Length 18-36", regex.isValid("363456789012345678")); assertTrue("Prefix 300", regex.isValid("30045678901234")); assertTrue("Prefix 301", regex.isValid("30145678901234")); assertTrue("Prefix 302", regex.isValid("30245678901234")); assertTrue("Prefix 303", regex.isValid("30345678901234")); assertTrue("Prefix 304", regex.isValid("30445678901234")); assertTrue("Prefix 305", regex.isValid("30545678901234")); assertFalse("Prefix 306", regex.isValid("30645678901234")); assertFalse("Prefix 3094", regex.isValid("30945678901234")); assertTrue( "Prefix 3095", regex.isValid("30955678901234")); assertFalse("Prefix 3096", regex.isValid("30965678901234")); assertFalse("Prefix 35", regex.isValid("35345678901234")); assertTrue("Prefix 36", regex.isValid("36345678901234")); assertFalse("Prefix 37", regex.isValid("37345678901234")); assertTrue("Prefix 38", regex.isValid("38345678901234"));
assertFalse("Length 12-6011", regex.isValid("601156789012")); assertFalse("Length 12-65", regex.isValid("653456789012")); assertFalse("Length 13-6011", regex.isValid("6011567890123")); assertFalse("Length 13-65", regex.isValid("6534567890123")); assertFalse("Length 14-6011", regex.isValid("60115678901234")); assertFalse("Length 14-65", regex.isValid("65345678901234")); assertFalse("Length 15-6011", regex.isValid("601156789012345")); assertFalse("Length 15-65", regex.isValid("653456789012345")); assertTrue("Length 16-6011", regex.isValid("6011567890123456")); assertTrue("Length 16-644", regex.isValid("6444567890123456")); assertTrue("Length 16-648", regex.isValid("6484567890123456")); assertTrue("Length 16-65", regex.isValid("6534567890123456")); assertFalse("Length 17-6011", regex.isValid("60115678901234567")); assertFalse("Length 17-65", regex.isValid("65345678901234567")); assertFalse("Length 18-6011", regex.isValid("601156789012345678")); assertFalse("Length 18-65", regex.isValid("653456789012345678")); assertFalse("Prefix 640", regex.isValid("6404567890123456")); assertFalse("Prefix 641", regex.isValid("6414567890123456")); assertFalse("Prefix 642", regex.isValid("6424567890123456")); assertFalse("Prefix 643", regex.isValid("6434567890123456")); assertFalse("Prefix 6010", regex.isValid("6010567890123456")); assertFalse("Prefix 6012", regex.isValid("6012567890123456")); assertFalse("Invalid Char", regex.isValid("6011567x90123456")); assertTrue("Valid regex", regex.isValid(ERROR_DISCOVER)); assertTrue("Valid regex65", regex.isValid(ERROR_DISCOVER65)); assertFalse("Invalid", validator.isValid(ERROR_DISCOVER)); assertFalse("Invalid65", validator.isValid(ERROR_DISCOVER65));
assertFalse("Length 12", regex.isValid("343456789012")); assertFalse("Length 13", regex.isValid("3434567890123")); assertFalse("Length 14", regex.isValid("34345678901234")); assertTrue("Length 15", regex.isValid("343456789012345")); assertFalse("Length 16", regex.isValid("3434567890123456")); assertFalse("Length 17", regex.isValid("34345678901234567")); assertFalse("Length 18", regex.isValid("343456789012345678")); assertFalse("Prefix 33", regex.isValid("333456789012345")); assertTrue("Prefix 34", regex.isValid("343456789012345")); assertFalse("Prefix 35", regex.isValid("353456789012345")); assertFalse("Prefix 36", regex.isValid("363456789012345")); assertTrue("Prefix 37", regex.isValid("373456789012345")); assertFalse("Prefix 38", regex.isValid("383456789012345")); assertFalse("Prefix 41", regex.isValid("413456789012345")); assertFalse("Invalid Char", regex.isValid("3434567x9012345")); assertTrue("Valid regex", regex.isValid(ERROR_AMEX)); assertFalse("Invalid", validator.isValid(ERROR_AMEX)); assertNull("validate()", validator.validate(ERROR_AMEX));
assertFalse("Length 12", regex.isValid("513456789012")); assertFalse("Length 13", regex.isValid("5134567890123")); assertFalse("Length 14", regex.isValid("51345678901234")); assertFalse("Length 15", regex.isValid("513456789012345")); assertTrue("Length 16", regex.isValid("5134567890123456")); assertFalse("Length 17", regex.isValid("51345678901234567")); assertFalse("Length 18", regex.isValid("513456789012345678")); assertFalse("Prefix 41", regex.isValid("4134567890123456")); assertFalse("Prefix 50", regex.isValid("5034567890123456")); assertTrue("Prefix 51", regex.isValid("5134567890123456")); assertTrue("Prefix 52", regex.isValid("5234567890123456")); assertTrue("Prefix 53", regex.isValid("5334567890123456")); assertTrue("Prefix 54", regex.isValid("5434567890123456")); assertTrue("Prefix 55", regex.isValid("5534567890123456")); assertFalse("Prefix 56", regex.isValid("5634567890123456")); assertFalse("Prefix 61", regex.isValid("6134567890123456")); assertFalse("Invalid Char", regex.isValid("5134567x90123456")); assertTrue("Valid regex", regex.isValid(ERROR_MASTERCARD)); assertFalse("Invalid", validator.isValid(ERROR_MASTERCARD)); assertNull("validate()", validator.validate(ERROR_MASTERCARD)); assertFalse("222099",rev.isValid("222099"+PAD)); for(int i=222100; i <= 272099; i++) { String j = Integer.toString(i)+PAD; assertTrue(j, rev.isValid(j)); assertFalse("272100",rev.isValid("272100"+PAD));
/** * 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)); }
assertFalse("Length 12", regex.isValid("423456789012")); assertTrue("Length 13", regex.isValid("4234567890123")); assertFalse("Length 14", regex.isValid("42345678901234")); assertFalse("Length 15", regex.isValid("423456789012345")); assertTrue("Length 16", regex.isValid("4234567890123456")); assertFalse("Length 17", regex.isValid("42345678901234567")); assertFalse("Length 18", regex.isValid("423456789012345678")); assertFalse("Invalid Pref-A", regex.isValid("3234567890123")); assertFalse("Invalid Pref-B", regex.isValid("3234567890123456")); assertFalse("Invalid Char-A", regex.isValid("4234567x90123")); assertFalse("Invalid Char-B", regex.isValid("4234567x90123456")); assertTrue("Valid regex", regex.isValid(ERROR_VISA)); assertTrue("Valid regex-S", regex.isValid(ERROR_SHORT_VISA)); assertFalse("Invalid", validator.isValid(ERROR_VISA)); assertFalse("Invalid-S", validator.isValid(ERROR_SHORT_VISA));
/** * 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")); }
assertEquals("isValid() Multiple", true, multiple.isValid(value)); assertEquals("isValid() 1st", false, single1.isValid(value)); assertEquals("isValid() 2nd", true, single2.isValid(value)); assertEquals("isValid() 3rd", false, single3.isValid(value)); assertEquals("isValid() Invalid", false, multiple.isValid(value)); assertEquals("validate() Invalid", null, multiple.validate(value)); assertEquals("match() Multiple", null, multiple.match(value));
assertEquals("Sensitive isValid() Multiple", true, multiple.isValid(value)); assertEquals("Sensitive isValid() 1st", false, single1.isValid(value)); assertEquals("Sensitive isValid() 2nd", true, single2.isValid(value)); assertEquals("Sensitive isValid() 3rd", false, single3.isValid(value)); assertEquals("isValid() Invalid", false, multiple.isValid(value)); assertEquals("validate() Invalid", null, multiple.validate(value)); assertEquals("match() Multiple", null, multiple.match(value));
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); }
/** * 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")); }
private boolean isValidDomain(String domain) { String[] groups = domainRegex.match(domain); if (groups != null && groups.length > 0) { return true; } else { if (hostnameRegex.isValid(domain)) { return true; } } return false; }
private boolean isValidDomain(String domain) { String[] groups = domainRegex.match(domain); if (groups != null && groups.length > 0) { return true; } else { if (hostnameRegex.isValid(domain)) { return true; } } return false; }
/** * Checks if the value matches the regular expression. */ public boolean matchRegex(String pattern, String input) { return new RegexValidator(pattern).isValid(input); }
/** * 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); }
@Override public ValidationResult validate(MuleEvent event) { RegexValidator validator = new RegexValidator(new String[] {regex}, caseSensitive); return validator.isValid(value) ? ok() : fail(); }