/** * Returns true if the domain component of an email address is valid. * * @param domain being validated, may be in IDN format * @return true if the email address's domain is valid. */ protected boolean isValidDomain(String domain) { // see if domain is an IP address in brackets Matcher ipDomainMatcher = IP_DOMAIN_PATTERN.matcher(domain); if (ipDomainMatcher.matches()) { InetAddressValidator inetAddressValidator = InetAddressValidator.getInstance(); return inetAddressValidator.isValid(ipDomainMatcher.group(1)); } // Domain is symbolic name DomainValidator domainValidator = DomainValidator.getInstance(allowLocal); if (allowTld) { return domainValidator.isValid(domain) || (!domain.startsWith(".") && domainValidator.isValidTld(domain)); } else { return domainValidator.isValid(domain); } }
public void testVALIDATOR_412() { assertFalse(validator.isValidGenericTld("local")); assertFalse(validator.isValid("abc.local")); assertFalse(validator.isValidGenericTld("pvt")); assertFalse(validator.isValid("abc.pvt")); DomainValidator.updateTLDOverride(ArrayType.GENERIC_PLUS, new String[]{"local", "pvt"}); assertTrue(validator.isValidGenericTld("local")); assertTrue(validator.isValid("abc.local")); assertTrue(validator.isValidGenericTld("pvt")); assertTrue(validator.isValid("abc.pvt")); }
public void testIDNJava6OrLater() { String version = System.getProperty("java.version"); if (version.compareTo("1.6") < 0) { System.out.println("Cannot run Unicode IDN tests"); return; // Cannot run the test } // xn--d1abbgf6aiiy.xn--p1ai http://президент.рф assertTrue("b\u00fccher.ch should validate", validator.isValid("www.b\u00fccher.ch")); assertTrue("xn--d1abbgf6aiiy.xn--p1ai should validate", validator.isValid("xn--d1abbgf6aiiy.xn--p1ai")); assertTrue("президент.рф should validate", validator.isValid("президент.рф")); assertFalse("www.\uFFFD.ch FFFD should fail", validator.isValid("www.\uFFFD.ch")); }
public void testTopLevelDomains() { // infrastructure TLDs assertTrue(".arpa should validate as iTLD", validator.isValidInfrastructureTld(".arpa")); assertFalse(".com shouldn't validate as iTLD", validator.isValidInfrastructureTld(".com")); // generic TLDs assertTrue(".name should validate as gTLD", validator.isValidGenericTld(".name")); assertFalse(".us shouldn't validate as gTLD", validator.isValidGenericTld(".us")); // country code TLDs assertTrue(".uk should validate as ccTLD", validator.isValidCountryCodeTld(".uk")); assertFalse(".org shouldn't validate as ccTLD", validator.isValidCountryCodeTld(".org")); // case-insensitive assertTrue(".COM should validate as TLD", validator.isValidTld(".COM")); assertTrue(".BiZ should validate as TLD", validator.isValidTld(".BiZ")); // corner cases assertFalse("invalid TLD shouldn't validate", validator.isValid(".nope")); // TODO this is not guaranteed invalid forever assertFalse("empty string shouldn't validate as TLD", validator.isValid("")); assertFalse("null shouldn't validate as TLD", validator.isValid(null)); }
public void testRFC2396domainlabel() { // use fixed valid TLD assertTrue("a.ch should validate", validator.isValid("a.ch")); assertTrue("9.ch should validate", validator.isValid("9.ch")); assertTrue("az.ch should validate", validator.isValid("az.ch")); assertTrue("09.ch should validate", validator.isValid("09.ch")); assertTrue("9-1.ch should validate", validator.isValid("9-1.ch")); assertFalse("91-.ch should not validate", validator.isValid("91-.ch")); assertFalse("-.ch should not validate", validator.isValid("-.ch")); }
public void testValidDomains() { assertTrue("apache.org should validate", validator.isValid("apache.org")); assertTrue("www.google.com should validate", validator.isValid("www.google.com")); assertTrue("test-domain.com should validate", validator.isValid("test-domain.com")); assertTrue("test---domain.com should validate", validator.isValid("test---domain.com")); assertTrue("test-d-o-m-ain.com should validate", validator.isValid("test-d-o-m-ain.com")); assertTrue("two-letter domain label should validate", validator.isValid("as.uk")); assertTrue("case-insensitive ApAchE.Org should validate", validator.isValid("ApAchE.Org")); assertTrue("single-character domain label should validate", validator.isValid("z.com")); assertTrue("i.have.an-example.domain.name should validate", validator.isValid("i.have.an-example.domain.name")); }
public void testInvalidDomains() { assertFalse("bare TLD .org shouldn't validate", validator.isValid(".org")); assertFalse("domain name with spaces shouldn't validate", validator.isValid(" apache.org ")); assertFalse("domain name containing spaces shouldn't validate", validator.isValid("apa che.org")); assertFalse("domain name starting with dash shouldn't validate", validator.isValid("-testdomain.name")); assertFalse("domain name ending with dash shouldn't validate", validator.isValid("testdomain-.name")); assertFalse("domain name starting with multiple dashes shouldn't validate", validator.isValid("---c.com")); assertFalse("domain name ending with multiple dashes shouldn't validate", validator.isValid("c--.com")); assertFalse("domain name with invalid TLD shouldn't validate", validator.isValid("apache.rog")); assertFalse("URL shouldn't validate", validator.isValid("http://www.apache.org")); assertFalse("Empty string shouldn't validate as domain name", validator.isValid(" ")); assertFalse("Null shouldn't validate as domain name", validator.isValid(null)); }
public void testValidator297() { assertTrue("xn--d1abbgf6aiiy.xn--p1ai should validate", validator.isValid("xn--d1abbgf6aiiy.xn--p1ai")); // This uses a valid TLD }
public void testIDN() { assertTrue("b\u00fccher.ch in IDN should validate", validator.isValid("www.xn--bcher-kva.ch")); }
public void testAllowLocal() { DomainValidator noLocal = DomainValidator.getInstance(false); DomainValidator allowLocal = DomainValidator.getInstance(true); // Default is false, and should use singletons assertEquals(noLocal, validator); // Default won't allow local assertFalse("localhost.localdomain should validate", noLocal.isValid("localhost.localdomain")); assertFalse("localhost should validate", noLocal.isValid("localhost")); // But it may be requested assertTrue("localhost.localdomain should validate", allowLocal.isValid("localhost.localdomain")); assertTrue("localhost should validate", allowLocal.isValid("localhost")); assertTrue("hostname should validate", allowLocal.isValid("hostname")); assertTrue("machinename should validate", allowLocal.isValid("machinename")); // Check the localhost one with a few others assertTrue("apache.org should validate", allowLocal.isValid("apache.org")); assertFalse("domain name with spaces shouldn't validate", allowLocal.isValid(" apache.org ")); }
if (!domainValidator.isValid(hostLocation)) {
@Override public Predicate<Object> getPredicate() { return domain -> DomainValidator.getInstance().isValid(domain == null?null:domain.toString()); } }
@Override public boolean isValidDomain(final String value) { return this.domainValidator.isValid(value); } }
private void validate(APICreateL3NetworkMsg msg) { if (!L3NetworkType.hasType(msg.getType())) { throw new ApiMessageInterceptionException(argerr("unsupported l3network type[%s]", msg.getType())); } if (msg.getDnsDomain() != null) { DomainValidator validator = DomainValidator.getInstance(); if (!validator.isValid(msg.getDnsDomain())) { throw new ApiMessageInterceptionException(argerr("%s is not a valid domain name", msg.getDnsDomain())); } } List<L3NetworkCategory> validNetworkCategory = Arrays.asList(L3NetworkCategory.values()); for (L3NetworkCategory category : validNetworkCategory) { if (category.toString().equalsIgnoreCase(msg.getCategory())) { msg.setCategory(category.toString()); break; } } if (L3NetworkCategory.checkSystemAndCategory(msg.isSystem(), L3NetworkCategory.valueOf(msg.getCategory()))) { return; } else { throw new ApiMessageInterceptionException(argerr("not valid combination of system and category," + "only %s are valid", L3NetworkCategory.validCombination)); } }
@Override public Optional<String> validate(final String subject) { return DomainValidator.getInstance(true).isValid(subject) && !subject.contains("_") ? Optional.empty() : Optional.of(String.format("[%s] is not a valid hostname", subject)); }
/** * Validates if string <code>ip</code> is a valid url domain or * not. * * @param domain to be validated. * @return true if valid url. */ public static boolean isDomainName(String domain) { return DomainValidator.getInstance().isValid(domain); }
public static boolean isValidDomainName(String domainName) { domainName = domainName.replaceAll("_", ""); return DomainValidator.getInstance().isValid(domainName); }
@Override public boolean validate(String value) { Pattern p = Pattern.compile("^[a-zA-Z0-9]*$"); Matcher m = p.matcher(value); if (m.find()) { return true; } return org.apache.commons.validator.routines.InetAddressValidator.getInstance().isValid(value) || org.apache.commons.validator.routines.DomainValidator.getInstance().isValid(value); }
static protected void validate(CommonServicesContext services, DnsEntry dnsEntry) { if (!Strings.isNullOrEmpty(dnsEntry.getName())) { if (typesWithDomain.contains(dnsEntry.getType()) && !DomainValidator.getInstance().isValid(dnsEntry.getName())) { throw new IllegalUpdateException(services.getTranslationService().translate("error.notADomainName")); } if (strictTypesWithDomain.contains(dnsEntry.getType()) && !startWithLetterValidationRegex.matcher(dnsEntry.getName()).matches()) { throw new IllegalUpdateException(services.getTranslationService().translate("error.notStartingWithLetter")); } if (dnsEntry.getType() == DnsEntryType.A && !validIp(dnsEntry.getDetails())) { throw new IllegalUpdateException(services.getTranslationService().translate("error.notAnIp")); } if (dnsEntry.getName().contains(" ")) { throw new IllegalUpdateException(services.getTranslationService().translate("error.notADomainName")); } } }
static protected void validate(CommonServicesContext services, DnsEntry dnsEntry) { if (!Strings.isNullOrEmpty(dnsEntry.getName())) { if (typesWithDomain.contains(dnsEntry.getType()) && !DomainValidator.getInstance().isValid(dnsEntry.getName())) { throw new IllegalUpdateException(services.getTranslationService().translate("error.notADomainName")); } if (strictTypesWithDomain.contains(dnsEntry.getType()) && !startWithLetterValidationRegex.matcher(dnsEntry.getName()).matches()) { throw new IllegalUpdateException(services.getTranslationService().translate("error.notStartingWithLetter")); } if (dnsEntry.getType() == DnsEntryType.A && !validIp(dnsEntry.getDetails())) { throw new IllegalUpdateException(services.getTranslationService().translate("error.notAnIp")); } if (dnsEntry.getName().contains(" ")) { throw new IllegalUpdateException(services.getTranslationService().translate("error.notADomainName")); } } }