target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void validateCommunity() { ParserHelper.validateCommunity("1:1"); ParserHelper.validateCommunity("65535:65535"); } | public static void validateCommunity(final String yytext) { final int colon = yytext.indexOf(':'); final long from = Long.valueOf(yytext.substring(0, colon)); if (from > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } final long to = Long.valueOf(yytext.substring(colon + 1)); if (to > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } } | ParserHelper { public static void validateCommunity(final String yytext) { final int colon = yytext.indexOf(':'); final long from = Long.valueOf(yytext.substring(0, colon)); if (from > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } final long to = Long.valueOf(yytext.substring(colon + 1)); if (to > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } } } | ParserHelper { public static void validateCommunity(final String yytext) { final int colon = yytext.indexOf(':'); final long from = Long.valueOf(yytext.substring(0, colon)); if (from > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } final long to = Long.valueOf(yytext.substring(colon + 1)); if (to > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } } private ParserHelper(); } | ParserHelper { public static void validateCommunity(final String yytext) { final int colon = yytext.indexOf(':'); final long from = Long.valueOf(yytext.substring(0, colon)); if (from > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } final long to = Long.valueOf(yytext.substring(colon + 1)); if (to > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } | ParserHelper { public static void validateCommunity(final String yytext) { final int colon = yytext.indexOf(':'); final long from = Long.valueOf(yytext.substring(0, colon)); if (from > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } final long to = Long.valueOf(yytext.substring(colon + 1)); if (to > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } |
@Test(expected = IllegalArgumentException.class) public void validateCommunityBeforeColonOutOfRange() { ParserHelper.validateCommunity("65536:1"); } | public static void validateCommunity(final String yytext) { final int colon = yytext.indexOf(':'); final long from = Long.valueOf(yytext.substring(0, colon)); if (from > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } final long to = Long.valueOf(yytext.substring(colon + 1)); if (to > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } } | ParserHelper { public static void validateCommunity(final String yytext) { final int colon = yytext.indexOf(':'); final long from = Long.valueOf(yytext.substring(0, colon)); if (from > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } final long to = Long.valueOf(yytext.substring(colon + 1)); if (to > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } } } | ParserHelper { public static void validateCommunity(final String yytext) { final int colon = yytext.indexOf(':'); final long from = Long.valueOf(yytext.substring(0, colon)); if (from > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } final long to = Long.valueOf(yytext.substring(colon + 1)); if (to > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } } private ParserHelper(); } | ParserHelper { public static void validateCommunity(final String yytext) { final int colon = yytext.indexOf(':'); final long from = Long.valueOf(yytext.substring(0, colon)); if (from > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } final long to = Long.valueOf(yytext.substring(colon + 1)); if (to > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } | ParserHelper { public static void validateCommunity(final String yytext) { final int colon = yytext.indexOf(':'); final long from = Long.valueOf(yytext.substring(0, colon)); if (from > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } final long to = Long.valueOf(yytext.substring(colon + 1)); if (to > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } |
@Test(expected = IllegalArgumentException.class) public void validateCommunityAfterColonOutOfRange() { ParserHelper.validateCommunity("1:65536"); } | public static void validateCommunity(final String yytext) { final int colon = yytext.indexOf(':'); final long from = Long.valueOf(yytext.substring(0, colon)); if (from > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } final long to = Long.valueOf(yytext.substring(colon + 1)); if (to > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } } | ParserHelper { public static void validateCommunity(final String yytext) { final int colon = yytext.indexOf(':'); final long from = Long.valueOf(yytext.substring(0, colon)); if (from > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } final long to = Long.valueOf(yytext.substring(colon + 1)); if (to > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } } } | ParserHelper { public static void validateCommunity(final String yytext) { final int colon = yytext.indexOf(':'); final long from = Long.valueOf(yytext.substring(0, colon)); if (from > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } final long to = Long.valueOf(yytext.substring(colon + 1)); if (to > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } } private ParserHelper(); } | ParserHelper { public static void validateCommunity(final String yytext) { final int colon = yytext.indexOf(':'); final long from = Long.valueOf(yytext.substring(0, colon)); if (from > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } final long to = Long.valueOf(yytext.substring(colon + 1)); if (to > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } | ParserHelper { public static void validateCommunity(final String yytext) { final int colon = yytext.indexOf(':'); final long from = Long.valueOf(yytext.substring(0, colon)); if (from > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } final long to = Long.valueOf(yytext.substring(colon + 1)); if (to > MAX_16BIT_NUMBER) { syntaxError("Community number " + yytext + " contains an invalid number"); } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } |
@Test public void validateDomainName() { ParserHelper.validateDomainName("12345678901234567890123456789012345678901234567890" + "12345678901234567890123456789012345678901234567890" + "12345678901234567890123456789012345678901234567890" + "12345678901234567890123456789012345678901234567890" + "1234567890123456789012345678901234567890123456789012345"); } | public static void validateDomainName(final String yytext) { if (yytext.length() > DOMAIN_NAME_MAX_LENGTH) { syntaxError("Domain name " + yytext + " is longer than 255 characters"); } } | ParserHelper { public static void validateDomainName(final String yytext) { if (yytext.length() > DOMAIN_NAME_MAX_LENGTH) { syntaxError("Domain name " + yytext + " is longer than 255 characters"); } } } | ParserHelper { public static void validateDomainName(final String yytext) { if (yytext.length() > DOMAIN_NAME_MAX_LENGTH) { syntaxError("Domain name " + yytext + " is longer than 255 characters"); } } private ParserHelper(); } | ParserHelper { public static void validateDomainName(final String yytext) { if (yytext.length() > DOMAIN_NAME_MAX_LENGTH) { syntaxError("Domain name " + yytext + " is longer than 255 characters"); } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } | ParserHelper { public static void validateDomainName(final String yytext) { if (yytext.length() > DOMAIN_NAME_MAX_LENGTH) { syntaxError("Domain name " + yytext + " is longer than 255 characters"); } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } |
@Test(expected = IllegalArgumentException.class) public void validateDomainNameTooLong() { ParserHelper.validateDomainName("12345678901234567890123456789012345678901234567890" + "12345678901234567890123456789012345678901234567890" + "12345678901234567890123456789012345678901234567890" + "12345678901234567890123456789012345678901234567890" + "12345678901234567890123456789012345678901234567890123456"); } | public static void validateDomainName(final String yytext) { if (yytext.length() > DOMAIN_NAME_MAX_LENGTH) { syntaxError("Domain name " + yytext + " is longer than 255 characters"); } } | ParserHelper { public static void validateDomainName(final String yytext) { if (yytext.length() > DOMAIN_NAME_MAX_LENGTH) { syntaxError("Domain name " + yytext + " is longer than 255 characters"); } } } | ParserHelper { public static void validateDomainName(final String yytext) { if (yytext.length() > DOMAIN_NAME_MAX_LENGTH) { syntaxError("Domain name " + yytext + " is longer than 255 characters"); } } private ParserHelper(); } | ParserHelper { public static void validateDomainName(final String yytext) { if (yytext.length() > DOMAIN_NAME_MAX_LENGTH) { syntaxError("Domain name " + yytext + " is longer than 255 characters"); } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } | ParserHelper { public static void validateDomainName(final String yytext) { if (yytext.length() > DOMAIN_NAME_MAX_LENGTH) { syntaxError("Domain name " + yytext + " is longer than 255 characters"); } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } |
@Test public void validateDomainNameLabel() { ParserHelper.validateDomainNameLabel("abcdefghijklmnopqrstuvwxyz"); ParserHelper.validateDomainNameLabel("ABCDEFGHIJKLMNOPQRSTUVWXYZ"); ParserHelper.validateDomainNameLabel("123456789012345678901234567890123456789012345678901234567890123"); } | public static void validateDomainNameLabel(final String yytext) { if (yytext.length() > DOMAIN_NAME_LABEL_MAX_LENGTH) { syntaxError("Domain name label " + yytext + " is longer than 63 characters"); } } | ParserHelper { public static void validateDomainNameLabel(final String yytext) { if (yytext.length() > DOMAIN_NAME_LABEL_MAX_LENGTH) { syntaxError("Domain name label " + yytext + " is longer than 63 characters"); } } } | ParserHelper { public static void validateDomainNameLabel(final String yytext) { if (yytext.length() > DOMAIN_NAME_LABEL_MAX_LENGTH) { syntaxError("Domain name label " + yytext + " is longer than 63 characters"); } } private ParserHelper(); } | ParserHelper { public static void validateDomainNameLabel(final String yytext) { if (yytext.length() > DOMAIN_NAME_LABEL_MAX_LENGTH) { syntaxError("Domain name label " + yytext + " is longer than 63 characters"); } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } | ParserHelper { public static void validateDomainNameLabel(final String yytext) { if (yytext.length() > DOMAIN_NAME_LABEL_MAX_LENGTH) { syntaxError("Domain name label " + yytext + " is longer than 63 characters"); } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } |
@Test public void as_number_range() throws Exception { File zipFile = FileHelper.addToZipFile("arin.test", "arin_db.txt", "ASHandle: AS701\n" + "OrgID: MCICS\n" + "ASName: UUNET\n" + "ASNumber: 701 - 705\n" + "RegDate: 1990-08-03\n" + "Updated: 2012-03-20\n" + "Source: ARIN\n"); try { subject.handleObjects(zipFile, objectHandler); assertThat(objectHandler.getLines(), hasSize(0)); assertThat(objectHandler.getObjects(), hasSize(5)); assertThat(objectHandler.getObjects(), contains( RpslObject.parse( "aut-num: AS701\n" + "org: MCICS\n" + "as-name: UUNET\n" + "source: ARIN"), RpslObject.parse( "aut-num: AS702\n" + "org: MCICS\n" + "as-name: UUNET\n" + "source: ARIN"), RpslObject.parse( "aut-num: AS703\n" + "org: MCICS\n" + "as-name: UUNET\n" + "source: ARIN"), RpslObject.parse( "aut-num: AS704\n" + "org: MCICS\n" + "as-name: UUNET\n" + "source: ARIN"), RpslObject.parse( "aut-num: AS705\n" + "org: MCICS\n" + "as-name: UUNET\n" + "source: ARIN") )); } finally { zipFile.delete(); } } | @Override public void handleObjects(final File file, final ObjectHandler handler) throws IOException { ZipFile zipFile = null; try { zipFile = new ZipFile(file, ZipFile.OPEN_READ); final ZipEntry zipEntry = zipFile.getEntry(zipEntryName); if (zipEntry == null) { logger.error("Zipfile {} does not contain dump {}", file, zipEntryName); return; } final BufferedReader reader = new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry), StandardCharsets.UTF_8)); handleLines(reader, new LineHandler() { @Override public void handleLines(final List<String> lines) { if (lines.isEmpty() || IGNORED_OBJECTS.contains(ciString(StringUtils.substringBefore(lines.get(0), ":")))) { logger.debug("Ignoring:\n\n{}\n", lines); return; } final RpslObjectBuilder rpslObjectBuilder = new RpslObjectBuilder(Joiner.on("").join(lines)); for (RpslObject next : expand(rpslObjectBuilder.getAttributes())) { handler.handle(next); } } private List<RpslObject> expand(final List<RpslAttribute> attributes) { if (attributes.get(0).getKey().equals("ashandle")) { final String asnumber = findAttributeValue(attributes, "asnumber"); if (asnumber != null) { final Matcher rangeMatcher = AS_NUMBER_RANGE.matcher(asnumber); if (rangeMatcher.find()) { final List<RpslObject> objects = Lists.newArrayList(); final int begin = Integer.parseInt(rangeMatcher.group(1)); final int end = Integer.parseInt(rangeMatcher.group(2)); for (int index = begin; index <= end; index++) { attributes.set(0, new RpslAttribute(AttributeType.AUT_NUM, String.format("AS%d", index))); objects.add(new RpslObject(transform(attributes))); } return objects; } } } return Lists.newArrayList(new RpslObject(transform(attributes))); } private List<RpslAttribute> transform(final List<RpslAttribute> attributes) { final List<RpslAttribute> newAttributes = Lists.newArrayList(); for (RpslAttribute attribute : attributes) { final Function<RpslAttribute, RpslAttribute> transformFunction = TRANSFORM_FUNCTIONS.get(ciString(attribute.getKey())); if (transformFunction != null) { attribute = transformFunction.apply(attribute); } final AttributeType attributeType = attribute.getType(); if (attributeType == null) { continue; } else if (AttributeType.INETNUM.equals(attributeType) || AttributeType.INET6NUM.equals(attributeType)) { newAttributes.add(0, attribute); } else { newAttributes.add(attribute); } } return newAttributes; } @Nullable private String findAttributeValue(final List<RpslAttribute> attributes, final String key) { for (RpslAttribute attribute : attributes) { if (attribute.getKey().equals(key)) { return attribute.getCleanValue().toString(); } } return null; } }); } finally { if (zipFile != null) { zipFile.close(); } } } | ArinGrsSource extends GrsSource { @Override public void handleObjects(final File file, final ObjectHandler handler) throws IOException { ZipFile zipFile = null; try { zipFile = new ZipFile(file, ZipFile.OPEN_READ); final ZipEntry zipEntry = zipFile.getEntry(zipEntryName); if (zipEntry == null) { logger.error("Zipfile {} does not contain dump {}", file, zipEntryName); return; } final BufferedReader reader = new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry), StandardCharsets.UTF_8)); handleLines(reader, new LineHandler() { @Override public void handleLines(final List<String> lines) { if (lines.isEmpty() || IGNORED_OBJECTS.contains(ciString(StringUtils.substringBefore(lines.get(0), ":")))) { logger.debug("Ignoring:\n\n{}\n", lines); return; } final RpslObjectBuilder rpslObjectBuilder = new RpslObjectBuilder(Joiner.on("").join(lines)); for (RpslObject next : expand(rpslObjectBuilder.getAttributes())) { handler.handle(next); } } private List<RpslObject> expand(final List<RpslAttribute> attributes) { if (attributes.get(0).getKey().equals("ashandle")) { final String asnumber = findAttributeValue(attributes, "asnumber"); if (asnumber != null) { final Matcher rangeMatcher = AS_NUMBER_RANGE.matcher(asnumber); if (rangeMatcher.find()) { final List<RpslObject> objects = Lists.newArrayList(); final int begin = Integer.parseInt(rangeMatcher.group(1)); final int end = Integer.parseInt(rangeMatcher.group(2)); for (int index = begin; index <= end; index++) { attributes.set(0, new RpslAttribute(AttributeType.AUT_NUM, String.format("AS%d", index))); objects.add(new RpslObject(transform(attributes))); } return objects; } } } return Lists.newArrayList(new RpslObject(transform(attributes))); } private List<RpslAttribute> transform(final List<RpslAttribute> attributes) { final List<RpslAttribute> newAttributes = Lists.newArrayList(); for (RpslAttribute attribute : attributes) { final Function<RpslAttribute, RpslAttribute> transformFunction = TRANSFORM_FUNCTIONS.get(ciString(attribute.getKey())); if (transformFunction != null) { attribute = transformFunction.apply(attribute); } final AttributeType attributeType = attribute.getType(); if (attributeType == null) { continue; } else if (AttributeType.INETNUM.equals(attributeType) || AttributeType.INET6NUM.equals(attributeType)) { newAttributes.add(0, attribute); } else { newAttributes.add(attribute); } } return newAttributes; } @Nullable private String findAttributeValue(final List<RpslAttribute> attributes, final String key) { for (RpslAttribute attribute : attributes) { if (attribute.getKey().equals(key)) { return attribute.getCleanValue().toString(); } } return null; } }); } finally { if (zipFile != null) { zipFile.close(); } } } } | ArinGrsSource extends GrsSource { @Override public void handleObjects(final File file, final ObjectHandler handler) throws IOException { ZipFile zipFile = null; try { zipFile = new ZipFile(file, ZipFile.OPEN_READ); final ZipEntry zipEntry = zipFile.getEntry(zipEntryName); if (zipEntry == null) { logger.error("Zipfile {} does not contain dump {}", file, zipEntryName); return; } final BufferedReader reader = new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry), StandardCharsets.UTF_8)); handleLines(reader, new LineHandler() { @Override public void handleLines(final List<String> lines) { if (lines.isEmpty() || IGNORED_OBJECTS.contains(ciString(StringUtils.substringBefore(lines.get(0), ":")))) { logger.debug("Ignoring:\n\n{}\n", lines); return; } final RpslObjectBuilder rpslObjectBuilder = new RpslObjectBuilder(Joiner.on("").join(lines)); for (RpslObject next : expand(rpslObjectBuilder.getAttributes())) { handler.handle(next); } } private List<RpslObject> expand(final List<RpslAttribute> attributes) { if (attributes.get(0).getKey().equals("ashandle")) { final String asnumber = findAttributeValue(attributes, "asnumber"); if (asnumber != null) { final Matcher rangeMatcher = AS_NUMBER_RANGE.matcher(asnumber); if (rangeMatcher.find()) { final List<RpslObject> objects = Lists.newArrayList(); final int begin = Integer.parseInt(rangeMatcher.group(1)); final int end = Integer.parseInt(rangeMatcher.group(2)); for (int index = begin; index <= end; index++) { attributes.set(0, new RpslAttribute(AttributeType.AUT_NUM, String.format("AS%d", index))); objects.add(new RpslObject(transform(attributes))); } return objects; } } } return Lists.newArrayList(new RpslObject(transform(attributes))); } private List<RpslAttribute> transform(final List<RpslAttribute> attributes) { final List<RpslAttribute> newAttributes = Lists.newArrayList(); for (RpslAttribute attribute : attributes) { final Function<RpslAttribute, RpslAttribute> transformFunction = TRANSFORM_FUNCTIONS.get(ciString(attribute.getKey())); if (transformFunction != null) { attribute = transformFunction.apply(attribute); } final AttributeType attributeType = attribute.getType(); if (attributeType == null) { continue; } else if (AttributeType.INETNUM.equals(attributeType) || AttributeType.INET6NUM.equals(attributeType)) { newAttributes.add(0, attribute); } else { newAttributes.add(attribute); } } return newAttributes; } @Nullable private String findAttributeValue(final List<RpslAttribute> attributes, final String key) { for (RpslAttribute attribute : attributes) { if (attribute.getKey().equals(key)) { return attribute.getCleanValue().toString(); } } return null; } }); } finally { if (zipFile != null) { zipFile.close(); } } } @Autowired ArinGrsSource(
@Value("${grs.import.arin.source:}") final String source,
final SourceContext sourceContext,
final DateTimeProvider dateTimeProvider,
final AuthoritativeResourceData authoritativeResourceData,
final Downloader downloader,
@Value("${grs.import.arin.download:}") final String download,
@Value("${grs.import.arin.zipEntryName:}") final String zipEntryName); } | ArinGrsSource extends GrsSource { @Override public void handleObjects(final File file, final ObjectHandler handler) throws IOException { ZipFile zipFile = null; try { zipFile = new ZipFile(file, ZipFile.OPEN_READ); final ZipEntry zipEntry = zipFile.getEntry(zipEntryName); if (zipEntry == null) { logger.error("Zipfile {} does not contain dump {}", file, zipEntryName); return; } final BufferedReader reader = new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry), StandardCharsets.UTF_8)); handleLines(reader, new LineHandler() { @Override public void handleLines(final List<String> lines) { if (lines.isEmpty() || IGNORED_OBJECTS.contains(ciString(StringUtils.substringBefore(lines.get(0), ":")))) { logger.debug("Ignoring:\n\n{}\n", lines); return; } final RpslObjectBuilder rpslObjectBuilder = new RpslObjectBuilder(Joiner.on("").join(lines)); for (RpslObject next : expand(rpslObjectBuilder.getAttributes())) { handler.handle(next); } } private List<RpslObject> expand(final List<RpslAttribute> attributes) { if (attributes.get(0).getKey().equals("ashandle")) { final String asnumber = findAttributeValue(attributes, "asnumber"); if (asnumber != null) { final Matcher rangeMatcher = AS_NUMBER_RANGE.matcher(asnumber); if (rangeMatcher.find()) { final List<RpslObject> objects = Lists.newArrayList(); final int begin = Integer.parseInt(rangeMatcher.group(1)); final int end = Integer.parseInt(rangeMatcher.group(2)); for (int index = begin; index <= end; index++) { attributes.set(0, new RpslAttribute(AttributeType.AUT_NUM, String.format("AS%d", index))); objects.add(new RpslObject(transform(attributes))); } return objects; } } } return Lists.newArrayList(new RpslObject(transform(attributes))); } private List<RpslAttribute> transform(final List<RpslAttribute> attributes) { final List<RpslAttribute> newAttributes = Lists.newArrayList(); for (RpslAttribute attribute : attributes) { final Function<RpslAttribute, RpslAttribute> transformFunction = TRANSFORM_FUNCTIONS.get(ciString(attribute.getKey())); if (transformFunction != null) { attribute = transformFunction.apply(attribute); } final AttributeType attributeType = attribute.getType(); if (attributeType == null) { continue; } else if (AttributeType.INETNUM.equals(attributeType) || AttributeType.INET6NUM.equals(attributeType)) { newAttributes.add(0, attribute); } else { newAttributes.add(attribute); } } return newAttributes; } @Nullable private String findAttributeValue(final List<RpslAttribute> attributes, final String key) { for (RpslAttribute attribute : attributes) { if (attribute.getKey().equals(key)) { return attribute.getCleanValue().toString(); } } return null; } }); } finally { if (zipFile != null) { zipFile.close(); } } } @Autowired ArinGrsSource(
@Value("${grs.import.arin.source:}") final String source,
final SourceContext sourceContext,
final DateTimeProvider dateTimeProvider,
final AuthoritativeResourceData authoritativeResourceData,
final Downloader downloader,
@Value("${grs.import.arin.download:}") final String download,
@Value("${grs.import.arin.zipEntryName:}") final String zipEntryName); @Override void acquireDump(final Path path); @Override void handleObjects(final File file, final ObjectHandler handler); } | ArinGrsSource extends GrsSource { @Override public void handleObjects(final File file, final ObjectHandler handler) throws IOException { ZipFile zipFile = null; try { zipFile = new ZipFile(file, ZipFile.OPEN_READ); final ZipEntry zipEntry = zipFile.getEntry(zipEntryName); if (zipEntry == null) { logger.error("Zipfile {} does not contain dump {}", file, zipEntryName); return; } final BufferedReader reader = new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry), StandardCharsets.UTF_8)); handleLines(reader, new LineHandler() { @Override public void handleLines(final List<String> lines) { if (lines.isEmpty() || IGNORED_OBJECTS.contains(ciString(StringUtils.substringBefore(lines.get(0), ":")))) { logger.debug("Ignoring:\n\n{}\n", lines); return; } final RpslObjectBuilder rpslObjectBuilder = new RpslObjectBuilder(Joiner.on("").join(lines)); for (RpslObject next : expand(rpslObjectBuilder.getAttributes())) { handler.handle(next); } } private List<RpslObject> expand(final List<RpslAttribute> attributes) { if (attributes.get(0).getKey().equals("ashandle")) { final String asnumber = findAttributeValue(attributes, "asnumber"); if (asnumber != null) { final Matcher rangeMatcher = AS_NUMBER_RANGE.matcher(asnumber); if (rangeMatcher.find()) { final List<RpslObject> objects = Lists.newArrayList(); final int begin = Integer.parseInt(rangeMatcher.group(1)); final int end = Integer.parseInt(rangeMatcher.group(2)); for (int index = begin; index <= end; index++) { attributes.set(0, new RpslAttribute(AttributeType.AUT_NUM, String.format("AS%d", index))); objects.add(new RpslObject(transform(attributes))); } return objects; } } } return Lists.newArrayList(new RpslObject(transform(attributes))); } private List<RpslAttribute> transform(final List<RpslAttribute> attributes) { final List<RpslAttribute> newAttributes = Lists.newArrayList(); for (RpslAttribute attribute : attributes) { final Function<RpslAttribute, RpslAttribute> transformFunction = TRANSFORM_FUNCTIONS.get(ciString(attribute.getKey())); if (transformFunction != null) { attribute = transformFunction.apply(attribute); } final AttributeType attributeType = attribute.getType(); if (attributeType == null) { continue; } else if (AttributeType.INETNUM.equals(attributeType) || AttributeType.INET6NUM.equals(attributeType)) { newAttributes.add(0, attribute); } else { newAttributes.add(attribute); } } return newAttributes; } @Nullable private String findAttributeValue(final List<RpslAttribute> attributes, final String key) { for (RpslAttribute attribute : attributes) { if (attribute.getKey().equals(key)) { return attribute.getCleanValue().toString(); } } return null; } }); } finally { if (zipFile != null) { zipFile.close(); } } } @Autowired ArinGrsSource(
@Value("${grs.import.arin.source:}") final String source,
final SourceContext sourceContext,
final DateTimeProvider dateTimeProvider,
final AuthoritativeResourceData authoritativeResourceData,
final Downloader downloader,
@Value("${grs.import.arin.download:}") final String download,
@Value("${grs.import.arin.zipEntryName:}") final String zipEntryName); @Override void acquireDump(final Path path); @Override void handleObjects(final File file, final ObjectHandler handler); } |
@Test(expected = IllegalArgumentException.class) public void validateDomainNameLabelTooLong() { ParserHelper.validateDomainNameLabel("1234567890123456789012345678901234567890123456789012345678901234"); } | public static void validateDomainNameLabel(final String yytext) { if (yytext.length() > DOMAIN_NAME_LABEL_MAX_LENGTH) { syntaxError("Domain name label " + yytext + " is longer than 63 characters"); } } | ParserHelper { public static void validateDomainNameLabel(final String yytext) { if (yytext.length() > DOMAIN_NAME_LABEL_MAX_LENGTH) { syntaxError("Domain name label " + yytext + " is longer than 63 characters"); } } } | ParserHelper { public static void validateDomainNameLabel(final String yytext) { if (yytext.length() > DOMAIN_NAME_LABEL_MAX_LENGTH) { syntaxError("Domain name label " + yytext + " is longer than 63 characters"); } } private ParserHelper(); } | ParserHelper { public static void validateDomainNameLabel(final String yytext) { if (yytext.length() > DOMAIN_NAME_LABEL_MAX_LENGTH) { syntaxError("Domain name label " + yytext + " is longer than 63 characters"); } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } | ParserHelper { public static void validateDomainNameLabel(final String yytext) { if (yytext.length() > DOMAIN_NAME_LABEL_MAX_LENGTH) { syntaxError("Domain name label " + yytext + " is longer than 63 characters"); } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } |
@Test public void validateAsRange() { ParserHelper.validateAsRange("AS1 - AS2"); ParserHelper.validateAsRange("AS1 - AS2"); } | public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } | ParserHelper { public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } } | ParserHelper { public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } private ParserHelper(); } | ParserHelper { public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } | ParserHelper { public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } |
@Test(expected = IllegalArgumentException.class) public void validateAsRangeInverseRange() { ParserHelper.validateAsRange("AS2 - AS1"); } | public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } | ParserHelper { public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } } | ParserHelper { public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } private ParserHelper(); } | ParserHelper { public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } | ParserHelper { public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } |
@Test(expected = IllegalArgumentException.class) public void validateAsRangeInvalidToNoSpaces() { ParserHelper.validateAsRange("AS1-AS" + (1L << 32)); } | public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } | ParserHelper { public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } } | ParserHelper { public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } private ParserHelper(); } | ParserHelper { public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } | ParserHelper { public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } |
@Test(expected = IllegalArgumentException.class) public void validateAsRangeInvalidToWithSpaces() { ParserHelper.validateAsRange("AS1 - AS" + (1L << 32)); } | public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } | ParserHelper { public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } } | ParserHelper { public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } private ParserHelper(); } | ParserHelper { public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } | ParserHelper { public static void validateAsRange(final String yytext) { Matcher matcher = AS_RANGE_PATTERN.matcher(yytext); if (matcher.find()) { long begin = Long.valueOf(matcher.group(1)); if (begin > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } long end = Long.valueOf(matcher.group(2)); if (end > MAX_32BIT_NUMBER) { syntaxError("AS Number " + yytext + " is invalid"); } if (end < begin) { syntaxError("AS Range " + yytext + " is invalid"); } } } private ParserHelper(); static void check16bit(final String number); static void check32bit(final String number); static void checkMaskLength(final String maskLength); static void checkMaskLengthv6(final String maskLength); static void checkStringLength(final String ip, final int maxAllowedLength); static void validateMoreSpecificsOperator(final String yytext); static void validateRangeMoreSpecificsOperators(final String yytext); static void validateAsNumber(final String yytext); static void validateIpv4PrefixRange(final String yytext); static void validateIpv6PrefixRange(final String yytext); static void validateIpv4Prefix(final String yytext); static void validateIpv6Prefix(final String yytext); static void validateIpv4(final String yytext); static void validateIpv6(final String yytext); static void validateCommunity(final String yytext); static void validateDomainName(final String yytext); static void validateDomainNameLabel(final String yytext); static void validateSmallInt(final String yytext); static void validateAsRange(final String yytext); static void log(final String message); static void log(final Exception exception); static void syntaxError(final String message); static void parserError(final String message); } |
@Test(expected = IndexOutOfBoundsException.class) public void write_bytes_offset_out_of_bounds() { subject.write(buffer, 2, buffer.length); } | public void write(final int b) { final int newcount = count + 1; if (newcount > buf.length) { buf = Arrays.copyOf(buf, Math.max(buf.length << 1, newcount)); } buf[count] = (byte) b; count = newcount; } | ByteArrayOutput extends OutputStream { public void write(final int b) { final int newcount = count + 1; if (newcount > buf.length) { buf = Arrays.copyOf(buf, Math.max(buf.length << 1, newcount)); } buf[count] = (byte) b; count = newcount; } } | ByteArrayOutput extends OutputStream { public void write(final int b) { final int newcount = count + 1; if (newcount > buf.length) { buf = Arrays.copyOf(buf, Math.max(buf.length << 1, newcount)); } buf[count] = (byte) b; count = newcount; } ByteArrayOutput(); ByteArrayOutput(final int initialCapacity); } | ByteArrayOutput extends OutputStream { public void write(final int b) { final int newcount = count + 1; if (newcount > buf.length) { buf = Arrays.copyOf(buf, Math.max(buf.length << 1, newcount)); } buf[count] = (byte) b; count = newcount; } ByteArrayOutput(); ByteArrayOutput(final int initialCapacity); void write(final int b); void write(final byte b[]); void write(final byte b[], final int off, final int len); void reset(); byte[] toByteArray(); int size(); } | ByteArrayOutput extends OutputStream { public void write(final int b) { final int newcount = count + 1; if (newcount > buf.length) { buf = Arrays.copyOf(buf, Math.max(buf.length << 1, newcount)); } buf[count] = (byte) b; count = newcount; } ByteArrayOutput(); ByteArrayOutput(final int initialCapacity); void write(final int b); void write(final byte b[]); void write(final byte b[], final int off, final int len); void reset(); byte[] toByteArray(); int size(); } |
@Test public void reset() { subject.write(buffer); subject.reset(); assertThat(subject.toByteArray(), is(new byte[]{})); subject.write(buffer); assertThat(subject.toByteArray(), is(buffer)); } | public void reset() { count = 0; } | ByteArrayOutput extends OutputStream { public void reset() { count = 0; } } | ByteArrayOutput extends OutputStream { public void reset() { count = 0; } ByteArrayOutput(); ByteArrayOutput(final int initialCapacity); } | ByteArrayOutput extends OutputStream { public void reset() { count = 0; } ByteArrayOutput(); ByteArrayOutput(final int initialCapacity); void write(final int b); void write(final byte b[]); void write(final byte b[], final int off, final int len); void reset(); byte[] toByteArray(); int size(); } | ByteArrayOutput extends OutputStream { public void reset() { count = 0; } ByteArrayOutput(); ByteArrayOutput(final int initialCapacity); void write(final int b); void write(final byte b[]); void write(final byte b[], final int off, final int len); void reset(); byte[] toByteArray(); int size(); } |
@Test public void size() { subject.write(buffer); assertThat(subject.size(), is(buffer.length)); } | public int size() { return count; } | ByteArrayOutput extends OutputStream { public int size() { return count; } } | ByteArrayOutput extends OutputStream { public int size() { return count; } ByteArrayOutput(); ByteArrayOutput(final int initialCapacity); } | ByteArrayOutput extends OutputStream { public int size() { return count; } ByteArrayOutput(); ByteArrayOutput(final int initialCapacity); void write(final int b); void write(final byte b[]); void write(final byte b[], final int off, final int len); void reset(); byte[] toByteArray(); int size(); } | ByteArrayOutput extends OutputStream { public int size() { return count; } ByteArrayOutput(); ByteArrayOutput(final int initialCapacity); void write(final int b); void write(final byte b[]); void write(final byte b[], final int off, final int len); void reset(); byte[] toByteArray(); int size(); } |
@Test public void convert_ascii_string() { final String ascii = "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~"; assertThat(Latin1Conversion.convertString(ascii), is(ascii)); } | public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } |
@Test public void convert_supplement_latin1_string() { assertThat(Latin1Conversion.convertString(SUPPLEMENT), is(SUPPLEMENT)); } | public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } |
@Test public void single_as_number() throws Exception { File zipFile = FileHelper.addToZipFile("arin.test", "arin_db.txt", "ASHandle: AS701\n" + "OrgID: MCICS\n" + "ASName: UUNET\n" + "ASNumber: 701\n" + "RegDate: 1990-08-03\n" + "Updated: 2012-03-20\n" + "Source: ARIN\n"); try { subject.handleObjects(zipFile, objectHandler); assertThat(objectHandler.getLines(), hasSize(0)); assertThat(objectHandler.getObjects(), hasSize(1)); assertThat(objectHandler.getObjects(), contains( RpslObject.parse( "aut-num: AS701\n" + "org: MCICS\n" + "as-name: UUNET\n" + "source: ARIN"))); } finally { zipFile.delete(); } } | @Override public void handleObjects(final File file, final ObjectHandler handler) throws IOException { ZipFile zipFile = null; try { zipFile = new ZipFile(file, ZipFile.OPEN_READ); final ZipEntry zipEntry = zipFile.getEntry(zipEntryName); if (zipEntry == null) { logger.error("Zipfile {} does not contain dump {}", file, zipEntryName); return; } final BufferedReader reader = new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry), StandardCharsets.UTF_8)); handleLines(reader, new LineHandler() { @Override public void handleLines(final List<String> lines) { if (lines.isEmpty() || IGNORED_OBJECTS.contains(ciString(StringUtils.substringBefore(lines.get(0), ":")))) { logger.debug("Ignoring:\n\n{}\n", lines); return; } final RpslObjectBuilder rpslObjectBuilder = new RpslObjectBuilder(Joiner.on("").join(lines)); for (RpslObject next : expand(rpslObjectBuilder.getAttributes())) { handler.handle(next); } } private List<RpslObject> expand(final List<RpslAttribute> attributes) { if (attributes.get(0).getKey().equals("ashandle")) { final String asnumber = findAttributeValue(attributes, "asnumber"); if (asnumber != null) { final Matcher rangeMatcher = AS_NUMBER_RANGE.matcher(asnumber); if (rangeMatcher.find()) { final List<RpslObject> objects = Lists.newArrayList(); final int begin = Integer.parseInt(rangeMatcher.group(1)); final int end = Integer.parseInt(rangeMatcher.group(2)); for (int index = begin; index <= end; index++) { attributes.set(0, new RpslAttribute(AttributeType.AUT_NUM, String.format("AS%d", index))); objects.add(new RpslObject(transform(attributes))); } return objects; } } } return Lists.newArrayList(new RpslObject(transform(attributes))); } private List<RpslAttribute> transform(final List<RpslAttribute> attributes) { final List<RpslAttribute> newAttributes = Lists.newArrayList(); for (RpslAttribute attribute : attributes) { final Function<RpslAttribute, RpslAttribute> transformFunction = TRANSFORM_FUNCTIONS.get(ciString(attribute.getKey())); if (transformFunction != null) { attribute = transformFunction.apply(attribute); } final AttributeType attributeType = attribute.getType(); if (attributeType == null) { continue; } else if (AttributeType.INETNUM.equals(attributeType) || AttributeType.INET6NUM.equals(attributeType)) { newAttributes.add(0, attribute); } else { newAttributes.add(attribute); } } return newAttributes; } @Nullable private String findAttributeValue(final List<RpslAttribute> attributes, final String key) { for (RpslAttribute attribute : attributes) { if (attribute.getKey().equals(key)) { return attribute.getCleanValue().toString(); } } return null; } }); } finally { if (zipFile != null) { zipFile.close(); } } } | ArinGrsSource extends GrsSource { @Override public void handleObjects(final File file, final ObjectHandler handler) throws IOException { ZipFile zipFile = null; try { zipFile = new ZipFile(file, ZipFile.OPEN_READ); final ZipEntry zipEntry = zipFile.getEntry(zipEntryName); if (zipEntry == null) { logger.error("Zipfile {} does not contain dump {}", file, zipEntryName); return; } final BufferedReader reader = new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry), StandardCharsets.UTF_8)); handleLines(reader, new LineHandler() { @Override public void handleLines(final List<String> lines) { if (lines.isEmpty() || IGNORED_OBJECTS.contains(ciString(StringUtils.substringBefore(lines.get(0), ":")))) { logger.debug("Ignoring:\n\n{}\n", lines); return; } final RpslObjectBuilder rpslObjectBuilder = new RpslObjectBuilder(Joiner.on("").join(lines)); for (RpslObject next : expand(rpslObjectBuilder.getAttributes())) { handler.handle(next); } } private List<RpslObject> expand(final List<RpslAttribute> attributes) { if (attributes.get(0).getKey().equals("ashandle")) { final String asnumber = findAttributeValue(attributes, "asnumber"); if (asnumber != null) { final Matcher rangeMatcher = AS_NUMBER_RANGE.matcher(asnumber); if (rangeMatcher.find()) { final List<RpslObject> objects = Lists.newArrayList(); final int begin = Integer.parseInt(rangeMatcher.group(1)); final int end = Integer.parseInt(rangeMatcher.group(2)); for (int index = begin; index <= end; index++) { attributes.set(0, new RpslAttribute(AttributeType.AUT_NUM, String.format("AS%d", index))); objects.add(new RpslObject(transform(attributes))); } return objects; } } } return Lists.newArrayList(new RpslObject(transform(attributes))); } private List<RpslAttribute> transform(final List<RpslAttribute> attributes) { final List<RpslAttribute> newAttributes = Lists.newArrayList(); for (RpslAttribute attribute : attributes) { final Function<RpslAttribute, RpslAttribute> transformFunction = TRANSFORM_FUNCTIONS.get(ciString(attribute.getKey())); if (transformFunction != null) { attribute = transformFunction.apply(attribute); } final AttributeType attributeType = attribute.getType(); if (attributeType == null) { continue; } else if (AttributeType.INETNUM.equals(attributeType) || AttributeType.INET6NUM.equals(attributeType)) { newAttributes.add(0, attribute); } else { newAttributes.add(attribute); } } return newAttributes; } @Nullable private String findAttributeValue(final List<RpslAttribute> attributes, final String key) { for (RpslAttribute attribute : attributes) { if (attribute.getKey().equals(key)) { return attribute.getCleanValue().toString(); } } return null; } }); } finally { if (zipFile != null) { zipFile.close(); } } } } | ArinGrsSource extends GrsSource { @Override public void handleObjects(final File file, final ObjectHandler handler) throws IOException { ZipFile zipFile = null; try { zipFile = new ZipFile(file, ZipFile.OPEN_READ); final ZipEntry zipEntry = zipFile.getEntry(zipEntryName); if (zipEntry == null) { logger.error("Zipfile {} does not contain dump {}", file, zipEntryName); return; } final BufferedReader reader = new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry), StandardCharsets.UTF_8)); handleLines(reader, new LineHandler() { @Override public void handleLines(final List<String> lines) { if (lines.isEmpty() || IGNORED_OBJECTS.contains(ciString(StringUtils.substringBefore(lines.get(0), ":")))) { logger.debug("Ignoring:\n\n{}\n", lines); return; } final RpslObjectBuilder rpslObjectBuilder = new RpslObjectBuilder(Joiner.on("").join(lines)); for (RpslObject next : expand(rpslObjectBuilder.getAttributes())) { handler.handle(next); } } private List<RpslObject> expand(final List<RpslAttribute> attributes) { if (attributes.get(0).getKey().equals("ashandle")) { final String asnumber = findAttributeValue(attributes, "asnumber"); if (asnumber != null) { final Matcher rangeMatcher = AS_NUMBER_RANGE.matcher(asnumber); if (rangeMatcher.find()) { final List<RpslObject> objects = Lists.newArrayList(); final int begin = Integer.parseInt(rangeMatcher.group(1)); final int end = Integer.parseInt(rangeMatcher.group(2)); for (int index = begin; index <= end; index++) { attributes.set(0, new RpslAttribute(AttributeType.AUT_NUM, String.format("AS%d", index))); objects.add(new RpslObject(transform(attributes))); } return objects; } } } return Lists.newArrayList(new RpslObject(transform(attributes))); } private List<RpslAttribute> transform(final List<RpslAttribute> attributes) { final List<RpslAttribute> newAttributes = Lists.newArrayList(); for (RpslAttribute attribute : attributes) { final Function<RpslAttribute, RpslAttribute> transformFunction = TRANSFORM_FUNCTIONS.get(ciString(attribute.getKey())); if (transformFunction != null) { attribute = transformFunction.apply(attribute); } final AttributeType attributeType = attribute.getType(); if (attributeType == null) { continue; } else if (AttributeType.INETNUM.equals(attributeType) || AttributeType.INET6NUM.equals(attributeType)) { newAttributes.add(0, attribute); } else { newAttributes.add(attribute); } } return newAttributes; } @Nullable private String findAttributeValue(final List<RpslAttribute> attributes, final String key) { for (RpslAttribute attribute : attributes) { if (attribute.getKey().equals(key)) { return attribute.getCleanValue().toString(); } } return null; } }); } finally { if (zipFile != null) { zipFile.close(); } } } @Autowired ArinGrsSource(
@Value("${grs.import.arin.source:}") final String source,
final SourceContext sourceContext,
final DateTimeProvider dateTimeProvider,
final AuthoritativeResourceData authoritativeResourceData,
final Downloader downloader,
@Value("${grs.import.arin.download:}") final String download,
@Value("${grs.import.arin.zipEntryName:}") final String zipEntryName); } | ArinGrsSource extends GrsSource { @Override public void handleObjects(final File file, final ObjectHandler handler) throws IOException { ZipFile zipFile = null; try { zipFile = new ZipFile(file, ZipFile.OPEN_READ); final ZipEntry zipEntry = zipFile.getEntry(zipEntryName); if (zipEntry == null) { logger.error("Zipfile {} does not contain dump {}", file, zipEntryName); return; } final BufferedReader reader = new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry), StandardCharsets.UTF_8)); handleLines(reader, new LineHandler() { @Override public void handleLines(final List<String> lines) { if (lines.isEmpty() || IGNORED_OBJECTS.contains(ciString(StringUtils.substringBefore(lines.get(0), ":")))) { logger.debug("Ignoring:\n\n{}\n", lines); return; } final RpslObjectBuilder rpslObjectBuilder = new RpslObjectBuilder(Joiner.on("").join(lines)); for (RpslObject next : expand(rpslObjectBuilder.getAttributes())) { handler.handle(next); } } private List<RpslObject> expand(final List<RpslAttribute> attributes) { if (attributes.get(0).getKey().equals("ashandle")) { final String asnumber = findAttributeValue(attributes, "asnumber"); if (asnumber != null) { final Matcher rangeMatcher = AS_NUMBER_RANGE.matcher(asnumber); if (rangeMatcher.find()) { final List<RpslObject> objects = Lists.newArrayList(); final int begin = Integer.parseInt(rangeMatcher.group(1)); final int end = Integer.parseInt(rangeMatcher.group(2)); for (int index = begin; index <= end; index++) { attributes.set(0, new RpslAttribute(AttributeType.AUT_NUM, String.format("AS%d", index))); objects.add(new RpslObject(transform(attributes))); } return objects; } } } return Lists.newArrayList(new RpslObject(transform(attributes))); } private List<RpslAttribute> transform(final List<RpslAttribute> attributes) { final List<RpslAttribute> newAttributes = Lists.newArrayList(); for (RpslAttribute attribute : attributes) { final Function<RpslAttribute, RpslAttribute> transformFunction = TRANSFORM_FUNCTIONS.get(ciString(attribute.getKey())); if (transformFunction != null) { attribute = transformFunction.apply(attribute); } final AttributeType attributeType = attribute.getType(); if (attributeType == null) { continue; } else if (AttributeType.INETNUM.equals(attributeType) || AttributeType.INET6NUM.equals(attributeType)) { newAttributes.add(0, attribute); } else { newAttributes.add(attribute); } } return newAttributes; } @Nullable private String findAttributeValue(final List<RpslAttribute> attributes, final String key) { for (RpslAttribute attribute : attributes) { if (attribute.getKey().equals(key)) { return attribute.getCleanValue().toString(); } } return null; } }); } finally { if (zipFile != null) { zipFile.close(); } } } @Autowired ArinGrsSource(
@Value("${grs.import.arin.source:}") final String source,
final SourceContext sourceContext,
final DateTimeProvider dateTimeProvider,
final AuthoritativeResourceData authoritativeResourceData,
final Downloader downloader,
@Value("${grs.import.arin.download:}") final String download,
@Value("${grs.import.arin.zipEntryName:}") final String zipEntryName); @Override void acquireDump(final Path path); @Override void handleObjects(final File file, final ObjectHandler handler); } | ArinGrsSource extends GrsSource { @Override public void handleObjects(final File file, final ObjectHandler handler) throws IOException { ZipFile zipFile = null; try { zipFile = new ZipFile(file, ZipFile.OPEN_READ); final ZipEntry zipEntry = zipFile.getEntry(zipEntryName); if (zipEntry == null) { logger.error("Zipfile {} does not contain dump {}", file, zipEntryName); return; } final BufferedReader reader = new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry), StandardCharsets.UTF_8)); handleLines(reader, new LineHandler() { @Override public void handleLines(final List<String> lines) { if (lines.isEmpty() || IGNORED_OBJECTS.contains(ciString(StringUtils.substringBefore(lines.get(0), ":")))) { logger.debug("Ignoring:\n\n{}\n", lines); return; } final RpslObjectBuilder rpslObjectBuilder = new RpslObjectBuilder(Joiner.on("").join(lines)); for (RpslObject next : expand(rpslObjectBuilder.getAttributes())) { handler.handle(next); } } private List<RpslObject> expand(final List<RpslAttribute> attributes) { if (attributes.get(0).getKey().equals("ashandle")) { final String asnumber = findAttributeValue(attributes, "asnumber"); if (asnumber != null) { final Matcher rangeMatcher = AS_NUMBER_RANGE.matcher(asnumber); if (rangeMatcher.find()) { final List<RpslObject> objects = Lists.newArrayList(); final int begin = Integer.parseInt(rangeMatcher.group(1)); final int end = Integer.parseInt(rangeMatcher.group(2)); for (int index = begin; index <= end; index++) { attributes.set(0, new RpslAttribute(AttributeType.AUT_NUM, String.format("AS%d", index))); objects.add(new RpslObject(transform(attributes))); } return objects; } } } return Lists.newArrayList(new RpslObject(transform(attributes))); } private List<RpslAttribute> transform(final List<RpslAttribute> attributes) { final List<RpslAttribute> newAttributes = Lists.newArrayList(); for (RpslAttribute attribute : attributes) { final Function<RpslAttribute, RpslAttribute> transformFunction = TRANSFORM_FUNCTIONS.get(ciString(attribute.getKey())); if (transformFunction != null) { attribute = transformFunction.apply(attribute); } final AttributeType attributeType = attribute.getType(); if (attributeType == null) { continue; } else if (AttributeType.INETNUM.equals(attributeType) || AttributeType.INET6NUM.equals(attributeType)) { newAttributes.add(0, attribute); } else { newAttributes.add(attribute); } } return newAttributes; } @Nullable private String findAttributeValue(final List<RpslAttribute> attributes, final String key) { for (RpslAttribute attribute : attributes) { if (attribute.getKey().equals(key)) { return attribute.getCleanValue().toString(); } } return null; } }); } finally { if (zipFile != null) { zipFile.close(); } } } @Autowired ArinGrsSource(
@Value("${grs.import.arin.source:}") final String source,
final SourceContext sourceContext,
final DateTimeProvider dateTimeProvider,
final AuthoritativeResourceData authoritativeResourceData,
final Downloader downloader,
@Value("${grs.import.arin.download:}") final String download,
@Value("${grs.import.arin.zipEntryName:}") final String zipEntryName); @Override void acquireDump(final Path path); @Override void handleObjects(final File file, final ObjectHandler handler); } |
@Test public void convert_rpsl_with_supplement() { assertThat( Latin1Conversion.convert("person: test\nnic-hdl: TP1-TEST\ndescr: " + SUPPLEMENT).getRpslObject(), is(RpslObject.parse("person: test\nnic-hdl: TP1-TEST\ndescr: " + SUPPLEMENT)) ); } | private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } private Latin1Conversion(); } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } |
@Test public void convert_control_characters_string() { final String control = new String(new byte[]{0x0, 0x0a}, StandardCharsets.ISO_8859_1); assertThat(Latin1Conversion.convertString(control), is("?\n")); } | public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } |
@Test public void convert_non_break_space_string() { final String control = new String(new byte[]{(byte)0xa0}, StandardCharsets.ISO_8859_1); assertThat(Latin1Conversion.convertString(control), is(" ")); } | public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } |
@Test public void convert_silent_hyphen_string() { final String control = new String(new byte[]{(byte)0xad}, StandardCharsets.ISO_8859_1); assertThat(Latin1Conversion.convertString(control), is("-")); } | public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } |
@Test public void convert_non_latin1_string() { assertThat(Latin1Conversion.convertString("ΣΔ"), is("??") ); assertThat(Latin1Conversion.convertString("привет"), is("??????") ); assertThat(Latin1Conversion.convertString("مرحبا"), is("?????") ); assertThat(Latin1Conversion.convertString("你好ا"), is("???") ); } | public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } |
@Test public void convert_empty_input_string() { assertThat(Latin1Conversion.convertString(""), is("") ); } | public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } | Latin1Conversion { public static String convertString(@Nonnull final String value) { final CharsetEncoder charsetEncoder = StandardCharsets.ISO_8859_1.newEncoder(); charsetEncoder.onMalformedInput(CodingErrorAction.REPLACE); charsetEncoder.onUnmappableCharacter(CodingErrorAction.REPLACE); try { final ByteBuffer encoded = charsetEncoder.encode(CharBuffer.wrap(value)); convert(encoded); return new String(encoded.array(), StandardCharsets.ISO_8859_1); } catch (CharacterCodingException e) { LOGGER.error(value, e); throw new IllegalStateException(e); } } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } |
@Test public void convert_control_characters_rpsl() { assertThat( Latin1Conversion.convert( "person: Test\u0000 Person\nnic-hdl: TP1-TEST\nsource: TEST").getRpslObject(), is( RpslObject.parse("person: Test? Person\nnic-hdl: TP1-TEST\nsource: TEST"))); } | private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } private Latin1Conversion(); } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } |
@Test public void convert_non_break_space_rpsl() { assertThat( Latin1Conversion.convert( "person: Test\u00a0Person\nnic-hdl: TP1-TEST\nsource: TEST").getRpslObject(), is( RpslObject.parse("person: Test Person\nnic-hdl: TP1-TEST\nsource: TEST"))); } | private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } private Latin1Conversion(); } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } |
@Test public void unicode_umlaut_substituted_correctly() { assertThat( Latin1Conversion.convert( "person: Test P\u00FCrson\nnic-hdl: TP1-TEST\nsource: TEST").getRpslObject(), is( RpslObject.parse("person: Test Pürson\nnic-hdl: TP1-TEST\nsource: TEST"))); } | private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } private Latin1Conversion(); } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } |
@Test public void utf16_umlaut_not_substituted_rpsl() { assertThat( Latin1Conversion.convert( "person: Test Pürson\nnic-hdl: TP1-TEST\nsource: TEST").getRpslObject(), is( RpslObject.parse("person: Test Pürson\nnic-hdl: TP1-TEST\nsource: TEST"))); } | private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } private Latin1Conversion(); } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } | Latin1Conversion { private static byte[] convert(@Nonnull final byte[] input) { for (int offset = 0; offset < input.length; offset++) { input[offset] = SUBSTITUTIONS[((int) input[offset]) & 0xff]; } return input; } private Latin1Conversion(); static Latin1ConversionResult convert(@Nonnull final String value); static String convertString(@Nonnull final String value); } |
@Test public void as_number_without_range() throws Exception { File zipFile = FileHelper.addToZipFile("arin.test", "arin_db.txt", "ASHandle: AS701\n" + "OrgID: MCICS\n" + "ASName: UUNET\n" + "RegDate: 1990-08-03\n" + "Updated: 2012-03-20\n" + "Source: ARIN\n"); try { subject.handleObjects(zipFile, objectHandler); assertThat(objectHandler.getLines(), hasSize(0)); assertThat(objectHandler.getObjects(), hasSize(1)); assertThat(objectHandler.getObjects(), contains( RpslObject.parse( "aut-num: AS701\n" + "org: MCICS\n" + "as-name: UUNET\n" + "source: ARIN"))); } finally { zipFile.delete(); } } | @Override public void handleObjects(final File file, final ObjectHandler handler) throws IOException { ZipFile zipFile = null; try { zipFile = new ZipFile(file, ZipFile.OPEN_READ); final ZipEntry zipEntry = zipFile.getEntry(zipEntryName); if (zipEntry == null) { logger.error("Zipfile {} does not contain dump {}", file, zipEntryName); return; } final BufferedReader reader = new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry), StandardCharsets.UTF_8)); handleLines(reader, new LineHandler() { @Override public void handleLines(final List<String> lines) { if (lines.isEmpty() || IGNORED_OBJECTS.contains(ciString(StringUtils.substringBefore(lines.get(0), ":")))) { logger.debug("Ignoring:\n\n{}\n", lines); return; } final RpslObjectBuilder rpslObjectBuilder = new RpslObjectBuilder(Joiner.on("").join(lines)); for (RpslObject next : expand(rpslObjectBuilder.getAttributes())) { handler.handle(next); } } private List<RpslObject> expand(final List<RpslAttribute> attributes) { if (attributes.get(0).getKey().equals("ashandle")) { final String asnumber = findAttributeValue(attributes, "asnumber"); if (asnumber != null) { final Matcher rangeMatcher = AS_NUMBER_RANGE.matcher(asnumber); if (rangeMatcher.find()) { final List<RpslObject> objects = Lists.newArrayList(); final int begin = Integer.parseInt(rangeMatcher.group(1)); final int end = Integer.parseInt(rangeMatcher.group(2)); for (int index = begin; index <= end; index++) { attributes.set(0, new RpslAttribute(AttributeType.AUT_NUM, String.format("AS%d", index))); objects.add(new RpslObject(transform(attributes))); } return objects; } } } return Lists.newArrayList(new RpslObject(transform(attributes))); } private List<RpslAttribute> transform(final List<RpslAttribute> attributes) { final List<RpslAttribute> newAttributes = Lists.newArrayList(); for (RpslAttribute attribute : attributes) { final Function<RpslAttribute, RpslAttribute> transformFunction = TRANSFORM_FUNCTIONS.get(ciString(attribute.getKey())); if (transformFunction != null) { attribute = transformFunction.apply(attribute); } final AttributeType attributeType = attribute.getType(); if (attributeType == null) { continue; } else if (AttributeType.INETNUM.equals(attributeType) || AttributeType.INET6NUM.equals(attributeType)) { newAttributes.add(0, attribute); } else { newAttributes.add(attribute); } } return newAttributes; } @Nullable private String findAttributeValue(final List<RpslAttribute> attributes, final String key) { for (RpslAttribute attribute : attributes) { if (attribute.getKey().equals(key)) { return attribute.getCleanValue().toString(); } } return null; } }); } finally { if (zipFile != null) { zipFile.close(); } } } | ArinGrsSource extends GrsSource { @Override public void handleObjects(final File file, final ObjectHandler handler) throws IOException { ZipFile zipFile = null; try { zipFile = new ZipFile(file, ZipFile.OPEN_READ); final ZipEntry zipEntry = zipFile.getEntry(zipEntryName); if (zipEntry == null) { logger.error("Zipfile {} does not contain dump {}", file, zipEntryName); return; } final BufferedReader reader = new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry), StandardCharsets.UTF_8)); handleLines(reader, new LineHandler() { @Override public void handleLines(final List<String> lines) { if (lines.isEmpty() || IGNORED_OBJECTS.contains(ciString(StringUtils.substringBefore(lines.get(0), ":")))) { logger.debug("Ignoring:\n\n{}\n", lines); return; } final RpslObjectBuilder rpslObjectBuilder = new RpslObjectBuilder(Joiner.on("").join(lines)); for (RpslObject next : expand(rpslObjectBuilder.getAttributes())) { handler.handle(next); } } private List<RpslObject> expand(final List<RpslAttribute> attributes) { if (attributes.get(0).getKey().equals("ashandle")) { final String asnumber = findAttributeValue(attributes, "asnumber"); if (asnumber != null) { final Matcher rangeMatcher = AS_NUMBER_RANGE.matcher(asnumber); if (rangeMatcher.find()) { final List<RpslObject> objects = Lists.newArrayList(); final int begin = Integer.parseInt(rangeMatcher.group(1)); final int end = Integer.parseInt(rangeMatcher.group(2)); for (int index = begin; index <= end; index++) { attributes.set(0, new RpslAttribute(AttributeType.AUT_NUM, String.format("AS%d", index))); objects.add(new RpslObject(transform(attributes))); } return objects; } } } return Lists.newArrayList(new RpslObject(transform(attributes))); } private List<RpslAttribute> transform(final List<RpslAttribute> attributes) { final List<RpslAttribute> newAttributes = Lists.newArrayList(); for (RpslAttribute attribute : attributes) { final Function<RpslAttribute, RpslAttribute> transformFunction = TRANSFORM_FUNCTIONS.get(ciString(attribute.getKey())); if (transformFunction != null) { attribute = transformFunction.apply(attribute); } final AttributeType attributeType = attribute.getType(); if (attributeType == null) { continue; } else if (AttributeType.INETNUM.equals(attributeType) || AttributeType.INET6NUM.equals(attributeType)) { newAttributes.add(0, attribute); } else { newAttributes.add(attribute); } } return newAttributes; } @Nullable private String findAttributeValue(final List<RpslAttribute> attributes, final String key) { for (RpslAttribute attribute : attributes) { if (attribute.getKey().equals(key)) { return attribute.getCleanValue().toString(); } } return null; } }); } finally { if (zipFile != null) { zipFile.close(); } } } } | ArinGrsSource extends GrsSource { @Override public void handleObjects(final File file, final ObjectHandler handler) throws IOException { ZipFile zipFile = null; try { zipFile = new ZipFile(file, ZipFile.OPEN_READ); final ZipEntry zipEntry = zipFile.getEntry(zipEntryName); if (zipEntry == null) { logger.error("Zipfile {} does not contain dump {}", file, zipEntryName); return; } final BufferedReader reader = new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry), StandardCharsets.UTF_8)); handleLines(reader, new LineHandler() { @Override public void handleLines(final List<String> lines) { if (lines.isEmpty() || IGNORED_OBJECTS.contains(ciString(StringUtils.substringBefore(lines.get(0), ":")))) { logger.debug("Ignoring:\n\n{}\n", lines); return; } final RpslObjectBuilder rpslObjectBuilder = new RpslObjectBuilder(Joiner.on("").join(lines)); for (RpslObject next : expand(rpslObjectBuilder.getAttributes())) { handler.handle(next); } } private List<RpslObject> expand(final List<RpslAttribute> attributes) { if (attributes.get(0).getKey().equals("ashandle")) { final String asnumber = findAttributeValue(attributes, "asnumber"); if (asnumber != null) { final Matcher rangeMatcher = AS_NUMBER_RANGE.matcher(asnumber); if (rangeMatcher.find()) { final List<RpslObject> objects = Lists.newArrayList(); final int begin = Integer.parseInt(rangeMatcher.group(1)); final int end = Integer.parseInt(rangeMatcher.group(2)); for (int index = begin; index <= end; index++) { attributes.set(0, new RpslAttribute(AttributeType.AUT_NUM, String.format("AS%d", index))); objects.add(new RpslObject(transform(attributes))); } return objects; } } } return Lists.newArrayList(new RpslObject(transform(attributes))); } private List<RpslAttribute> transform(final List<RpslAttribute> attributes) { final List<RpslAttribute> newAttributes = Lists.newArrayList(); for (RpslAttribute attribute : attributes) { final Function<RpslAttribute, RpslAttribute> transformFunction = TRANSFORM_FUNCTIONS.get(ciString(attribute.getKey())); if (transformFunction != null) { attribute = transformFunction.apply(attribute); } final AttributeType attributeType = attribute.getType(); if (attributeType == null) { continue; } else if (AttributeType.INETNUM.equals(attributeType) || AttributeType.INET6NUM.equals(attributeType)) { newAttributes.add(0, attribute); } else { newAttributes.add(attribute); } } return newAttributes; } @Nullable private String findAttributeValue(final List<RpslAttribute> attributes, final String key) { for (RpslAttribute attribute : attributes) { if (attribute.getKey().equals(key)) { return attribute.getCleanValue().toString(); } } return null; } }); } finally { if (zipFile != null) { zipFile.close(); } } } @Autowired ArinGrsSource(
@Value("${grs.import.arin.source:}") final String source,
final SourceContext sourceContext,
final DateTimeProvider dateTimeProvider,
final AuthoritativeResourceData authoritativeResourceData,
final Downloader downloader,
@Value("${grs.import.arin.download:}") final String download,
@Value("${grs.import.arin.zipEntryName:}") final String zipEntryName); } | ArinGrsSource extends GrsSource { @Override public void handleObjects(final File file, final ObjectHandler handler) throws IOException { ZipFile zipFile = null; try { zipFile = new ZipFile(file, ZipFile.OPEN_READ); final ZipEntry zipEntry = zipFile.getEntry(zipEntryName); if (zipEntry == null) { logger.error("Zipfile {} does not contain dump {}", file, zipEntryName); return; } final BufferedReader reader = new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry), StandardCharsets.UTF_8)); handleLines(reader, new LineHandler() { @Override public void handleLines(final List<String> lines) { if (lines.isEmpty() || IGNORED_OBJECTS.contains(ciString(StringUtils.substringBefore(lines.get(0), ":")))) { logger.debug("Ignoring:\n\n{}\n", lines); return; } final RpslObjectBuilder rpslObjectBuilder = new RpslObjectBuilder(Joiner.on("").join(lines)); for (RpslObject next : expand(rpslObjectBuilder.getAttributes())) { handler.handle(next); } } private List<RpslObject> expand(final List<RpslAttribute> attributes) { if (attributes.get(0).getKey().equals("ashandle")) { final String asnumber = findAttributeValue(attributes, "asnumber"); if (asnumber != null) { final Matcher rangeMatcher = AS_NUMBER_RANGE.matcher(asnumber); if (rangeMatcher.find()) { final List<RpslObject> objects = Lists.newArrayList(); final int begin = Integer.parseInt(rangeMatcher.group(1)); final int end = Integer.parseInt(rangeMatcher.group(2)); for (int index = begin; index <= end; index++) { attributes.set(0, new RpslAttribute(AttributeType.AUT_NUM, String.format("AS%d", index))); objects.add(new RpslObject(transform(attributes))); } return objects; } } } return Lists.newArrayList(new RpslObject(transform(attributes))); } private List<RpslAttribute> transform(final List<RpslAttribute> attributes) { final List<RpslAttribute> newAttributes = Lists.newArrayList(); for (RpslAttribute attribute : attributes) { final Function<RpslAttribute, RpslAttribute> transformFunction = TRANSFORM_FUNCTIONS.get(ciString(attribute.getKey())); if (transformFunction != null) { attribute = transformFunction.apply(attribute); } final AttributeType attributeType = attribute.getType(); if (attributeType == null) { continue; } else if (AttributeType.INETNUM.equals(attributeType) || AttributeType.INET6NUM.equals(attributeType)) { newAttributes.add(0, attribute); } else { newAttributes.add(attribute); } } return newAttributes; } @Nullable private String findAttributeValue(final List<RpslAttribute> attributes, final String key) { for (RpslAttribute attribute : attributes) { if (attribute.getKey().equals(key)) { return attribute.getCleanValue().toString(); } } return null; } }); } finally { if (zipFile != null) { zipFile.close(); } } } @Autowired ArinGrsSource(
@Value("${grs.import.arin.source:}") final String source,
final SourceContext sourceContext,
final DateTimeProvider dateTimeProvider,
final AuthoritativeResourceData authoritativeResourceData,
final Downloader downloader,
@Value("${grs.import.arin.download:}") final String download,
@Value("${grs.import.arin.zipEntryName:}") final String zipEntryName); @Override void acquireDump(final Path path); @Override void handleObjects(final File file, final ObjectHandler handler); } | ArinGrsSource extends GrsSource { @Override public void handleObjects(final File file, final ObjectHandler handler) throws IOException { ZipFile zipFile = null; try { zipFile = new ZipFile(file, ZipFile.OPEN_READ); final ZipEntry zipEntry = zipFile.getEntry(zipEntryName); if (zipEntry == null) { logger.error("Zipfile {} does not contain dump {}", file, zipEntryName); return; } final BufferedReader reader = new BufferedReader(new InputStreamReader(zipFile.getInputStream(zipEntry), StandardCharsets.UTF_8)); handleLines(reader, new LineHandler() { @Override public void handleLines(final List<String> lines) { if (lines.isEmpty() || IGNORED_OBJECTS.contains(ciString(StringUtils.substringBefore(lines.get(0), ":")))) { logger.debug("Ignoring:\n\n{}\n", lines); return; } final RpslObjectBuilder rpslObjectBuilder = new RpslObjectBuilder(Joiner.on("").join(lines)); for (RpslObject next : expand(rpslObjectBuilder.getAttributes())) { handler.handle(next); } } private List<RpslObject> expand(final List<RpslAttribute> attributes) { if (attributes.get(0).getKey().equals("ashandle")) { final String asnumber = findAttributeValue(attributes, "asnumber"); if (asnumber != null) { final Matcher rangeMatcher = AS_NUMBER_RANGE.matcher(asnumber); if (rangeMatcher.find()) { final List<RpslObject> objects = Lists.newArrayList(); final int begin = Integer.parseInt(rangeMatcher.group(1)); final int end = Integer.parseInt(rangeMatcher.group(2)); for (int index = begin; index <= end; index++) { attributes.set(0, new RpslAttribute(AttributeType.AUT_NUM, String.format("AS%d", index))); objects.add(new RpslObject(transform(attributes))); } return objects; } } } return Lists.newArrayList(new RpslObject(transform(attributes))); } private List<RpslAttribute> transform(final List<RpslAttribute> attributes) { final List<RpslAttribute> newAttributes = Lists.newArrayList(); for (RpslAttribute attribute : attributes) { final Function<RpslAttribute, RpslAttribute> transformFunction = TRANSFORM_FUNCTIONS.get(ciString(attribute.getKey())); if (transformFunction != null) { attribute = transformFunction.apply(attribute); } final AttributeType attributeType = attribute.getType(); if (attributeType == null) { continue; } else if (AttributeType.INETNUM.equals(attributeType) || AttributeType.INET6NUM.equals(attributeType)) { newAttributes.add(0, attribute); } else { newAttributes.add(attribute); } } return newAttributes; } @Nullable private String findAttributeValue(final List<RpslAttribute> attributes, final String key) { for (RpslAttribute attribute : attributes) { if (attribute.getKey().equals(key)) { return attribute.getCleanValue().toString(); } } return null; } }); } finally { if (zipFile != null) { zipFile.close(); } } } @Autowired ArinGrsSource(
@Value("${grs.import.arin.source:}") final String source,
final SourceContext sourceContext,
final DateTimeProvider dateTimeProvider,
final AuthoritativeResourceData authoritativeResourceData,
final Downloader downloader,
@Value("${grs.import.arin.download:}") final String download,
@Value("${grs.import.arin.zipEntryName:}") final String zipEntryName); @Override void acquireDump(final Path path); @Override void handleObjects(final File file, final ObjectHandler handler); } |
@Test public void test_run_temporary_blocks_already_denied() throws Exception { when(accessControlListDao.getTemporaryBlocks(now.minusDays(30))).thenReturn(Arrays.asList(createBlockEvents(IPV4_PREFIX, 20))); when(ipResourceConfiguration.isDenied(any(InetAddress.class))).thenReturn(true); subject.run(); verify(ipResourceConfiguration).isDenied(any(InetAddress.class)); verify(accessControlListDao, never()).savePermanentBlock(any(IpInterval.class), any(LocalDate.class), anyInt(), anyString()); } | @Override @Scheduled(cron = "0 0 0 * * *") @SchedulerLock(name = "AutomaticPermanentBlocks") public void run() { final LocalDate now = dateTimeProvider.getCurrentDate(); final LocalDate checkTemporaryBlockTime = now.minusDays(30); final List<BlockEvents> temporaryBlocks = accessControlListDao.getTemporaryBlocks(checkTemporaryBlockTime); for (final BlockEvents blockEvents : temporaryBlocks) { handleBlockEvents(now, blockEvents); } } | AutomaticPermanentBlocks implements DailyScheduledTask { @Override @Scheduled(cron = "0 0 0 * * *") @SchedulerLock(name = "AutomaticPermanentBlocks") public void run() { final LocalDate now = dateTimeProvider.getCurrentDate(); final LocalDate checkTemporaryBlockTime = now.minusDays(30); final List<BlockEvents> temporaryBlocks = accessControlListDao.getTemporaryBlocks(checkTemporaryBlockTime); for (final BlockEvents blockEvents : temporaryBlocks) { handleBlockEvents(now, blockEvents); } } } | AutomaticPermanentBlocks implements DailyScheduledTask { @Override @Scheduled(cron = "0 0 0 * * *") @SchedulerLock(name = "AutomaticPermanentBlocks") public void run() { final LocalDate now = dateTimeProvider.getCurrentDate(); final LocalDate checkTemporaryBlockTime = now.minusDays(30); final List<BlockEvents> temporaryBlocks = accessControlListDao.getTemporaryBlocks(checkTemporaryBlockTime); for (final BlockEvents blockEvents : temporaryBlocks) { handleBlockEvents(now, blockEvents); } } @Autowired AutomaticPermanentBlocks(final DateTimeProvider dateTimeProvider,
final AccessControlListDao accessControlListDao,
final IpResourceConfiguration ipResourceConfiguration); } | AutomaticPermanentBlocks implements DailyScheduledTask { @Override @Scheduled(cron = "0 0 0 * * *") @SchedulerLock(name = "AutomaticPermanentBlocks") public void run() { final LocalDate now = dateTimeProvider.getCurrentDate(); final LocalDate checkTemporaryBlockTime = now.minusDays(30); final List<BlockEvents> temporaryBlocks = accessControlListDao.getTemporaryBlocks(checkTemporaryBlockTime); for (final BlockEvents blockEvents : temporaryBlocks) { handleBlockEvents(now, blockEvents); } } @Autowired AutomaticPermanentBlocks(final DateTimeProvider dateTimeProvider,
final AccessControlListDao accessControlListDao,
final IpResourceConfiguration ipResourceConfiguration); @Override @Scheduled(cron = "0 0 0 * * *") @SchedulerLock(name = "AutomaticPermanentBlocks") void run(); } | AutomaticPermanentBlocks implements DailyScheduledTask { @Override @Scheduled(cron = "0 0 0 * * *") @SchedulerLock(name = "AutomaticPermanentBlocks") public void run() { final LocalDate now = dateTimeProvider.getCurrentDate(); final LocalDate checkTemporaryBlockTime = now.minusDays(30); final List<BlockEvents> temporaryBlocks = accessControlListDao.getTemporaryBlocks(checkTemporaryBlockTime); for (final BlockEvents blockEvents : temporaryBlocks) { handleBlockEvents(now, blockEvents); } } @Autowired AutomaticPermanentBlocks(final DateTimeProvider dateTimeProvider,
final AccessControlListDao accessControlListDao,
final IpResourceConfiguration ipResourceConfiguration); @Override @Scheduled(cron = "0 0 0 * * *") @SchedulerLock(name = "AutomaticPermanentBlocks") void run(); } |
@Test(expected=IllegalArgumentException.class) public void ipv4_with_prefix_21_fails() { subject = Ipv4Resource.parse("151.64.0.1/21\r\n"); } | public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test(expected=IllegalArgumentException.class) public void ipv4_with_prefix_23_fails() { subject = Ipv4Resource.parse("109.73.65.0/23\r\n"); } | public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test(expected=IllegalArgumentException.class) public void ipv4_with_prefix_28_fails() { subject = Ipv4Resource.parse("62.219.43.72/28\r\n"); } | public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test(expected=IllegalArgumentException.class) public void ipv4_with_huge_prefix_fails() { subject = Ipv4Resource.parse("128.0.0.0/0\r\n"); } | public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test(expected=IllegalArgumentException.class) public void ipv4_with_tiny_prefix_fails() { subject = Ipv4Resource.parse("192.192.192.1/31\r\n"); } | public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test(expected=IllegalArgumentException.class) public void ipv4_with_prefix_21() { subject = Ipv4Resource.parse("151.64.0.1/21\r\n"); } | public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void invalidResource() { Ipv4Resource.parse("invalid resource"); } | public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void invalidResourceType() { Ipv4Resource.parse("::0"); } | public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parse(final CIString resource) { return parse(resource.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test public void singletonIntervalAtLowerBound() { assertEquals(Ipv4Resource.parse("127.0.0.0/32"), Ipv4Resource.parse("127.0.0.0/8").singletonIntervalAtLowerBound()); } | @Override public Ipv4Resource singletonIntervalAtLowerBound() { return new Ipv4Resource(this.begin(), this.begin()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { @Override public Ipv4Resource singletonIntervalAtLowerBound() { return new Ipv4Resource(this.begin(), this.begin()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { @Override public Ipv4Resource singletonIntervalAtLowerBound() { return new Ipv4Resource(this.begin(), this.begin()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { @Override public Ipv4Resource singletonIntervalAtLowerBound() { return new Ipv4Resource(this.begin(), this.begin()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { @Override public Ipv4Resource singletonIntervalAtLowerBound() { return new Ipv4Resource(this.begin(), this.begin()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test public void compareWorks() { subject = new Ipv4Resource(10, 20); assertThat(0, eq(subject.compareTo(subject))); assertThat(1, eq(subject.compareTo(new Ipv4Resource(0, 9)))); assertThat(-1, eq(subject.compareTo(new Ipv4Resource(21, 30)))); assertThat(1, eq(subject.compareTo(new Ipv4Resource(0, 15)))); assertThat(-1, eq(subject.compareTo(new Ipv4Resource(15, 30)))); assertThat(1, eq(subject.compareTo(new Ipv4Resource(0, 20)))); assertThat(1, eq(subject.compareTo(new Ipv4Resource(10, 30)))); assertThat(-1, eq(subject.compareTo(new Ipv4Resource(11, 30)))); assertThat(-1, eq(subject.compareTo(new Ipv4Resource(10, 19)))); assertThat(-1, eq(subject.compareTo(new Ipv4Resource(11, 20)))); } | @Override public int compareTo(final Ipv4Resource that) { if (this.begin() < that.begin()) { return -1; } else if (this.begin() > that.begin()) { return 1; } else if (that.end() < this.end()) { return -1; } else if (that.end() > this.end()) { return 1; } else { return 0; } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { @Override public int compareTo(final Ipv4Resource that) { if (this.begin() < that.begin()) { return -1; } else if (this.begin() > that.begin()) { return 1; } else if (that.end() < this.end()) { return -1; } else if (that.end() > this.end()) { return 1; } else { return 0; } } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { @Override public int compareTo(final Ipv4Resource that) { if (this.begin() < that.begin()) { return -1; } else if (this.begin() > that.begin()) { return 1; } else if (that.end() < this.end()) { return -1; } else if (that.end() > this.end()) { return 1; } else { return 0; } } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { @Override public int compareTo(final Ipv4Resource that) { if (this.begin() < that.begin()) { return -1; } else if (this.begin() > that.begin()) { return 1; } else if (that.end() < this.end()) { return -1; } else if (that.end() > this.end()) { return 1; } else { return 0; } } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { @Override public int compareTo(final Ipv4Resource that) { if (this.begin() < that.begin()) { return -1; } else if (this.begin() > that.begin()) { return 1; } else if (that.end() < this.end()) { return -1; } else if (that.end() > this.end()) { return 1; } else { return 0; } } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test public void tagObjects() { subject.tagObjects(grsSource); verify(sourceContext).setCurrent(any(Source.class)); verify(sourceContext).removeCurrentSource(); verify(tagsDao).updateTags(any(Iterable.class), any(List.class), any(List.class)); verify(tagsDao).deleteOrphanedTags(); } | void tagObjects(final GrsSource grsSource) { final Stopwatch stopwatch = Stopwatch.createStarted(); try { sourceContext.setCurrent(Source.master(grsSource.getName())); if (sourceContext.isTagRoutes()) { tagRouteObjectsInContext(grsSource); } tagsDao.deleteOrphanedTags(); } finally { sourceContext.removeCurrentSource(); grsSource.getLogger().info("Tagging objects complete in {}", stopwatch.stop()); } } | ResourceTagger { void tagObjects(final GrsSource grsSource) { final Stopwatch stopwatch = Stopwatch.createStarted(); try { sourceContext.setCurrent(Source.master(grsSource.getName())); if (sourceContext.isTagRoutes()) { tagRouteObjectsInContext(grsSource); } tagsDao.deleteOrphanedTags(); } finally { sourceContext.removeCurrentSource(); grsSource.getLogger().info("Tagging objects complete in {}", stopwatch.stop()); } } } | ResourceTagger { void tagObjects(final GrsSource grsSource) { final Stopwatch stopwatch = Stopwatch.createStarted(); try { sourceContext.setCurrent(Source.master(grsSource.getName())); if (sourceContext.isTagRoutes()) { tagRouteObjectsInContext(grsSource); } tagsDao.deleteOrphanedTags(); } finally { sourceContext.removeCurrentSource(); grsSource.getLogger().info("Tagging objects complete in {}", stopwatch.stop()); } } @Autowired ResourceTagger(final SourceContext sourceContext, final TagsDao tagsDao); } | ResourceTagger { void tagObjects(final GrsSource grsSource) { final Stopwatch stopwatch = Stopwatch.createStarted(); try { sourceContext.setCurrent(Source.master(grsSource.getName())); if (sourceContext.isTagRoutes()) { tagRouteObjectsInContext(grsSource); } tagsDao.deleteOrphanedTags(); } finally { sourceContext.removeCurrentSource(); grsSource.getLogger().info("Tagging objects complete in {}", stopwatch.stop()); } } @Autowired ResourceTagger(final SourceContext sourceContext, final TagsDao tagsDao); } | ResourceTagger { void tagObjects(final GrsSource grsSource) { final Stopwatch stopwatch = Stopwatch.createStarted(); try { sourceContext.setCurrent(Source.master(grsSource.getName())); if (sourceContext.isTagRoutes()) { tagRouteObjectsInContext(grsSource); } tagsDao.deleteOrphanedTags(); } finally { sourceContext.removeCurrentSource(); grsSource.getLogger().info("Tagging objects complete in {}", stopwatch.stop()); } } @Autowired ResourceTagger(final SourceContext sourceContext, final TagsDao tagsDao); } |
@Test public void verifyIntersects() { subject = new Ipv4Resource(10, 20); assertTrue(subject.intersects(subject)); assertTrue(subject.intersects(Ipv4Resource.MAX_RANGE)); assertFalse(subject.intersects(new Ipv4Resource(9, 9))); assertTrue(subject.intersects(new Ipv4Resource(9, 10))); assertTrue(subject.intersects(new Ipv4Resource(10, 11))); assertTrue(subject.intersects(new Ipv4Resource(5, 15))); assertFalse(subject.intersects(new Ipv4Resource(21, 21))); assertTrue(subject.intersects(new Ipv4Resource(19, 20))); assertTrue(subject.intersects(new Ipv4Resource(20, 21))); assertTrue(subject.intersects(new Ipv4Resource(15, 25))); } | @Override public boolean intersects(final Ipv4Resource that) { return (isIPWithinRange(this.begin(), that) || isIPWithinRange(this.end(), that) || isIPWithinRange(that.begin(), this)); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { @Override public boolean intersects(final Ipv4Resource that) { return (isIPWithinRange(this.begin(), that) || isIPWithinRange(this.end(), that) || isIPWithinRange(that.begin(), this)); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { @Override public boolean intersects(final Ipv4Resource that) { return (isIPWithinRange(this.begin(), that) || isIPWithinRange(this.end(), that) || isIPWithinRange(that.begin(), this)); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { @Override public boolean intersects(final Ipv4Resource that) { return (isIPWithinRange(this.begin(), that) || isIPWithinRange(this.end(), that) || isIPWithinRange(that.begin(), this)); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { @Override public boolean intersects(final Ipv4Resource that) { return (isIPWithinRange(this.begin(), that) || isIPWithinRange(this.end(), that) || isIPWithinRange(that.begin(), this)); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void reverse_empty() { Ipv4Resource.parseReverseDomain(""); } | public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void reverse_null() { Ipv4Resource.parseReverseDomain(null); } | public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void reverse_no_inaddrarpa() { Ipv4Resource.parseReverseDomain("1.2.3.4"); } | public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void reverse_no_octets() { Ipv4Resource.parseReverseDomain(".in-addr.arpa"); } | public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void reverse_more_than_four_octets() { Ipv4Resource.parseReverseDomain("8.7.6.5.4.3.2.1.in-addr.arpa"); } | public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void reverse_dash_not_in_fourth_octet() { Ipv4Resource.parseReverseDomain("1-1.1.1.in-addr.arpa"); } | public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void reverse_non_numeric_input() { Ipv4Resource.parseReverseDomain("1-1.b.a.in-addr.arpa"); } | public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void reverse_multiple_dashes() { Ipv4Resource.parseReverseDomain("1-1.2-2.3-3.4-4.in-addr.arpa"); } | public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void reverse_inverse_range() { Ipv4Resource.parseReverseDomain("80-28.79.198.195.in-addr.arpa"); } | public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parseReverseDomain(final String address) { Validate.notEmpty(address); String cleanAddress = removeTrailingDot(address.trim()); Validate.isTrue(cleanAddress.toLowerCase().endsWith(IPV4_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV4_REVERSE_DOMAIN.length()); final ArrayList<String> reverseParts = Lists.newArrayList(SPLIT_ON_DOT.split(cleanAddress)); Validate.isTrue(!reverseParts.isEmpty() && reverseParts.size() <= 4, "Reverse address doesn't have between 1 and 4 octets: ", address); final List<String> parts = Lists.reverse(reverseParts); boolean hasDash = false; if (cleanAddress.contains("-")) { Validate.isTrue(reverseParts.size() == 4 && reverseParts.get(0).contains("-"), "Dash notation not in 4th octet: ", address); Validate.isTrue(cleanAddress.indexOf('-') == cleanAddress.lastIndexOf('-'), "Only one dash allowed: ", address); hasDash = true; } final StringBuilder builder = new StringBuilder(); for (String part : parts) { if (builder.length() > 0) { builder.append('.'); } Validate.isTrue(OCTET_PATTERN.matcher(part).matches(), "Invalid octet: ", part); builder.append(part); } if (hasDash) { int range = builder.indexOf("-"); if (range != -1) { builder.insert(range + 1, builder.substring(0, builder.lastIndexOf(".") + 1)); } } if (parts.size() < 4) { builder.append('/').append(parts.size() * 8); } return parse(builder.toString()); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test public void string() { assertThat(subject.toString(), is("SOME-GRS")); } | @Override public String toString() { return name.toString(); } | GrsSource implements InitializingBean { @Override public String toString() { return name.toString(); } } | GrsSource implements InitializingBean { @Override public String toString() { return name.toString(); } GrsSource(final String name, final SourceContext sourceContext, final DateTimeProvider dateTimeProvider, final AuthoritativeResourceData authoritativeResourceData, final Downloader downloader); } | GrsSource implements InitializingBean { @Override public String toString() { return name.toString(); } GrsSource(final String name, final SourceContext sourceContext, final DateTimeProvider dateTimeProvider, final AuthoritativeResourceData authoritativeResourceData, final Downloader downloader); @Override void afterPropertiesSet(); Logger getLogger(); @Override String toString(); } | GrsSource implements InitializingBean { @Override public String toString() { return name.toString(); } GrsSource(final String name, final SourceContext sourceContext, final DateTimeProvider dateTimeProvider, final AuthoritativeResourceData authoritativeResourceData, final Downloader downloader); @Override void afterPropertiesSet(); Logger getLogger(); @Override String toString(); } |
@Test public void parsePrefixWithLength() { assertThat(Ipv4Resource.parsePrefixWithLength(0, 0).toString(), is("0.0.0.0/0")); assertThat(Ipv4Resource.parsePrefixWithLength(0xffffffff, 0).toString(), is("0.0.0.0/0")); assertThat(Ipv4Resource.parsePrefixWithLength(0, 32).toString(), is("0.0.0.0/32")); assertThat(Ipv4Resource.parsePrefixWithLength(0xffffffff, 32).toString(), is("255.255.255.255/32")); assertThat(Ipv4Resource.parsePrefixWithLength(0xDEADBEEF, 13).toString(), is("222.168.0.0/13")); assertThat(Ipv4Resource.parsePrefixWithLength(0xCAFEBABE, 26).toString(), is("202.254.186.128/26")); } | public static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength) { final long mask = (1L << (32 - prefixLength)) - 1; return new Ipv4Resource((prefix & ~mask) & 0xFFFFFFFFL, (prefix | mask) & 0xFFFFFFFFL); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength) { final long mask = (1L << (32 - prefixLength)) - 1; return new Ipv4Resource((prefix & ~mask) & 0xFFFFFFFFL, (prefix | mask) & 0xFFFFFFFFL); } } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength) { final long mask = (1L << (32 - prefixLength)) - 1; return new Ipv4Resource((prefix & ~mask) & 0xFFFFFFFFL, (prefix | mask) & 0xFFFFFFFFL); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength) { final long mask = (1L << (32 - prefixLength)) - 1; return new Ipv4Resource((prefix & ~mask) & 0xFFFFFFFFL, (prefix | mask) & 0xFFFFFFFFL); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); } | Ipv4Resource extends IpInterval<Ipv4Resource> implements Comparable<Ipv4Resource> { public static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength) { final long mask = (1L << (32 - prefixLength)) - 1; return new Ipv4Resource((prefix & ~mask) & 0xFFFFFFFFL, (prefix | mask) & 0xFFFFFFFFL); } private Ipv4Resource(final int begin, final int end); Ipv4Resource(final long begin, final long end); Ipv4Resource(final InetAddress inetAddress); static Ipv4Resource parse(final CIString resource); static Ipv4Resource parse(final String resource); static Ipv4Resource parseIPv4Resource(final String resource); static Ipv4Resource parsePrefixWithLength(final long prefix, final int prefixLength); static Ipv4Resource parseReverseDomain(final String address); @Override AttributeType getAttributeType(); long begin(); long end(); @Override boolean contains(final Ipv4Resource that); @Override boolean intersects(final Ipv4Resource that); @Override int hashCode(); @Override boolean equals(final Object obj); @Override String toString(); String toRangeString(); @Override int compareTo(final Ipv4Resource that); @Override Ipv4Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv4Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); static final String IPV4_REVERSE_DOMAIN; static final Ipv4Resource MAX_RANGE; } |
@Test public void parseReverseDomain() { assertThat(IpInterval.parseReverseDomain("0.0.193.in-ADDR.arpA").toString(), is("193.0.0.0/24")); assertThat(IpInterval.parseReverseDomain("a.b.0.0.1.iP6.arpA").toString(), is("100b:a000::/20")); assertThat(IpInterval.parseReverseDomain("0.0.193.in-ADDR.arpA.").toString(), is("193.0.0.0/24")); assertThat(IpInterval.parseReverseDomain("a.b.0.0.1.iP6.arpA.").toString(), is("100b:a000::/20")); } | public static IpInterval<?> parseReverseDomain(final String reverse) { final String result = removeTrailingDot(reverse).toLowerCase(); if (result.endsWith(Ipv4Resource.IPV4_REVERSE_DOMAIN)) { return Ipv4Resource.parseReverseDomain(result); } return Ipv6Resource.parseReverseDomain(result); } | IpInterval implements Interval<K> { public static IpInterval<?> parseReverseDomain(final String reverse) { final String result = removeTrailingDot(reverse).toLowerCase(); if (result.endsWith(Ipv4Resource.IPV4_REVERSE_DOMAIN)) { return Ipv4Resource.parseReverseDomain(result); } return Ipv6Resource.parseReverseDomain(result); } } | IpInterval implements Interval<K> { public static IpInterval<?> parseReverseDomain(final String reverse) { final String result = removeTrailingDot(reverse).toLowerCase(); if (result.endsWith(Ipv4Resource.IPV4_REVERSE_DOMAIN)) { return Ipv4Resource.parseReverseDomain(result); } return Ipv6Resource.parseReverseDomain(result); } } | IpInterval implements Interval<K> { public static IpInterval<?> parseReverseDomain(final String reverse) { final String result = removeTrailingDot(reverse).toLowerCase(); if (result.endsWith(Ipv4Resource.IPV4_REVERSE_DOMAIN)) { return Ipv4Resource.parseReverseDomain(result); } return Ipv6Resource.parseReverseDomain(result); } static String removeTrailingDot(final String address); abstract AttributeType getAttributeType(); static IpInterval<?> parse(final CIString prefix); static IpInterval<?> parse(final String prefix); static IpInterval<?> parseReverseDomain(final String reverse); static IpInterval<?> asIpInterval(final InetAddress address); abstract InetAddress beginAsInetAddress(); abstract InetAddress endAsInetAddress(); abstract int getPrefixLength(); } | IpInterval implements Interval<K> { public static IpInterval<?> parseReverseDomain(final String reverse) { final String result = removeTrailingDot(reverse).toLowerCase(); if (result.endsWith(Ipv4Resource.IPV4_REVERSE_DOMAIN)) { return Ipv4Resource.parseReverseDomain(result); } return Ipv6Resource.parseReverseDomain(result); } static String removeTrailingDot(final String address); abstract AttributeType getAttributeType(); static IpInterval<?> parse(final CIString prefix); static IpInterval<?> parse(final String prefix); static IpInterval<?> parseReverseDomain(final String reverse); static IpInterval<?> asIpInterval(final InetAddress address); abstract InetAddress beginAsInetAddress(); abstract InetAddress endAsInetAddress(); abstract int getPrefixLength(); } |
@Test public void parse() { assertThat(IpInterval.parse("193.0.0/24").toString(), is("193.0.0.0/24")); assertThat(IpInterval.parse("00ab:cd::").toString(), is("ab:cd::/128")); } | public static IpInterval<?> parse(final CIString prefix) { return parse(prefix.toString()); } | IpInterval implements Interval<K> { public static IpInterval<?> parse(final CIString prefix) { return parse(prefix.toString()); } } | IpInterval implements Interval<K> { public static IpInterval<?> parse(final CIString prefix) { return parse(prefix.toString()); } } | IpInterval implements Interval<K> { public static IpInterval<?> parse(final CIString prefix) { return parse(prefix.toString()); } static String removeTrailingDot(final String address); abstract AttributeType getAttributeType(); static IpInterval<?> parse(final CIString prefix); static IpInterval<?> parse(final String prefix); static IpInterval<?> parseReverseDomain(final String reverse); static IpInterval<?> asIpInterval(final InetAddress address); abstract InetAddress beginAsInetAddress(); abstract InetAddress endAsInetAddress(); abstract int getPrefixLength(); } | IpInterval implements Interval<K> { public static IpInterval<?> parse(final CIString prefix) { return parse(prefix.toString()); } static String removeTrailingDot(final String address); abstract AttributeType getAttributeType(); static IpInterval<?> parse(final CIString prefix); static IpInterval<?> parse(final String prefix); static IpInterval<?> parseReverseDomain(final String reverse); static IpInterval<?> asIpInterval(final InetAddress address); abstract InetAddress beginAsInetAddress(); abstract InetAddress endAsInetAddress(); abstract int getPrefixLength(); } |
@Ignore @Test public void ipv4_mapped_ipv6_address() { subject = Ipv6Resource.parse("::ffff:c16e:370c/128"); } | public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void parseIpv6MappedIpv4Fails() { subject = Ipv6Resource.parse("::ffff:192.0.2.128"); } | public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void invalidResource() { Ipv6Resource.parse("invalid resource"); } | public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void invalidResourceType() { Ipv6Resource.parse("12.0.0.1"); } | public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void Ipv6RangeThrowsIllegalArgumentException() { Ipv6Resource.parse("2001:: - 2020::"); } | public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test public void singletonIntervalAtLowerBound() { assertEquals(Ipv6Resource.parse("2001::/128"), Ipv6Resource.parse("2001::/77").singletonIntervalAtLowerBound()); } | @Override public Ipv6Resource singletonIntervalAtLowerBound() { return new Ipv6Resource(beginMsb, beginLsb, IPV6_BITCOUNT); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { @Override public Ipv6Resource singletonIntervalAtLowerBound() { return new Ipv6Resource(beginMsb, beginLsb, IPV6_BITCOUNT); } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { @Override public Ipv6Resource singletonIntervalAtLowerBound() { return new Ipv6Resource(beginMsb, beginLsb, IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { @Override public Ipv6Resource singletonIntervalAtLowerBound() { return new Ipv6Resource(beginMsb, beginLsb, IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { @Override public Ipv6Resource singletonIntervalAtLowerBound() { return new Ipv6Resource(beginMsb, beginLsb, IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test public void compareWorks() { subject = resource(10, 20); assertThat(0, is(subject.compareTo(subject))); assertThat(1, is(subject.compareTo(resource(0, 9)))); assertThat(-1, is(subject.compareTo(resource(21, 30)))); assertThat(1, is(subject.compareTo(resource(0, 15)))); assertThat(-1, is(subject.compareTo(resource(15, 30)))); assertThat(1, is(subject.compareTo(resource(0, 20)))); assertThat(1, is(subject.compareTo(resource(10, 30)))); assertThat(-1, is(subject.compareTo(resource(11, 30)))); assertThat(-1, is(subject.compareTo(resource(10, 19)))); assertThat(-1, is(subject.compareTo(resource(11, 20)))); } | @Override public int compareTo(final Ipv6Resource that) { int comp = compare(beginMsb, beginLsb, that.beginMsb, that.beginLsb); if (comp == 0) { comp = compare(that.endMsb, that.endLsb, endMsb, endLsb); } return comp; } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { @Override public int compareTo(final Ipv6Resource that) { int comp = compare(beginMsb, beginLsb, that.beginMsb, that.beginLsb); if (comp == 0) { comp = compare(that.endMsb, that.endLsb, endMsb, endLsb); } return comp; } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { @Override public int compareTo(final Ipv6Resource that) { int comp = compare(beginMsb, beginLsb, that.beginMsb, that.beginLsb); if (comp == 0) { comp = compare(that.endMsb, that.endLsb, endMsb, endLsb); } return comp; } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { @Override public int compareTo(final Ipv6Resource that) { int comp = compare(beginMsb, beginLsb, that.beginMsb, that.beginLsb); if (comp == 0) { comp = compare(that.endMsb, that.endLsb, endMsb, endLsb); } return comp; } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { @Override public int compareTo(final Ipv6Resource that) { int comp = compare(beginMsb, beginLsb, that.beginMsb, that.beginLsb); if (comp == 0) { comp = compare(that.endMsb, that.endLsb, endMsb, endLsb); } return comp; } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test public void handleLines_empty() throws IOException { final BufferedReader reader = new BufferedReader(new StringReader("")); final GrsSource.LineHandler lineHandler = mock(GrsSource.LineHandler.class); subject.handleLines(reader, lineHandler); verifyZeroInteractions(lineHandler); } | void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } | GrsSource implements InitializingBean { void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } } | GrsSource implements InitializingBean { void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } GrsSource(final String name, final SourceContext sourceContext, final DateTimeProvider dateTimeProvider, final AuthoritativeResourceData authoritativeResourceData, final Downloader downloader); } | GrsSource implements InitializingBean { void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } GrsSource(final String name, final SourceContext sourceContext, final DateTimeProvider dateTimeProvider, final AuthoritativeResourceData authoritativeResourceData, final Downloader downloader); @Override void afterPropertiesSet(); Logger getLogger(); @Override String toString(); } | GrsSource implements InitializingBean { void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } GrsSource(final String name, final SourceContext sourceContext, final DateTimeProvider dateTimeProvider, final AuthoritativeResourceData authoritativeResourceData, final Downloader downloader); @Override void afterPropertiesSet(); Logger getLogger(); @Override String toString(); } |
@Test public void verifyIntersects() { subject = resource(10, 20); assertTrue(subject.intersects(subject)); assertTrue(subject.intersects(Ipv6Resource.MAX_RANGE)); assertFalse(subject.intersects(resource(9, 9))); assertTrue(subject.intersects(resource(9, 10))); assertTrue(subject.intersects(resource(9, 15))); assertTrue(subject.intersects(resource(9, 20))); assertTrue(subject.intersects(resource(9, 21))); assertTrue(subject.intersects(resource(10, 10))); assertTrue(subject.intersects(resource(10, 15))); assertTrue(subject.intersects(resource(10, 20))); assertTrue(subject.intersects(resource(10, 21))); assertTrue(subject.intersects(resource(15, 15))); assertTrue(subject.intersects(resource(15, 20))); assertTrue(subject.intersects(resource(15, 21))); assertTrue(subject.intersects(resource(20, 20))); assertTrue(subject.intersects(resource(20, 21))); assertFalse(subject.intersects(resource(21, 21))); } | @Override public boolean intersects(final Ipv6Resource that) { return (compare(beginMsb, beginLsb, that.beginMsb, that.beginLsb) >= 0 && compare(beginMsb, beginLsb, that.endMsb, that.endLsb) <= 0) || (compare(endMsb, endLsb, that.beginMsb, that.beginLsb) >= 0 && compare(endMsb, endLsb, that.endMsb, that.endLsb) <= 0) || contains(that); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { @Override public boolean intersects(final Ipv6Resource that) { return (compare(beginMsb, beginLsb, that.beginMsb, that.beginLsb) >= 0 && compare(beginMsb, beginLsb, that.endMsb, that.endLsb) <= 0) || (compare(endMsb, endLsb, that.beginMsb, that.beginLsb) >= 0 && compare(endMsb, endLsb, that.endMsb, that.endLsb) <= 0) || contains(that); } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { @Override public boolean intersects(final Ipv6Resource that) { return (compare(beginMsb, beginLsb, that.beginMsb, that.beginLsb) >= 0 && compare(beginMsb, beginLsb, that.endMsb, that.endLsb) <= 0) || (compare(endMsb, endLsb, that.beginMsb, that.beginLsb) >= 0 && compare(endMsb, endLsb, that.endMsb, that.endLsb) <= 0) || contains(that); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { @Override public boolean intersects(final Ipv6Resource that) { return (compare(beginMsb, beginLsb, that.beginMsb, that.beginLsb) >= 0 && compare(beginMsb, beginLsb, that.endMsb, that.endLsb) <= 0) || (compare(endMsb, endLsb, that.beginMsb, that.beginLsb) >= 0 && compare(endMsb, endLsb, that.endMsb, that.endLsb) <= 0) || contains(that); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { @Override public boolean intersects(final Ipv6Resource that) { return (compare(beginMsb, beginLsb, that.beginMsb, that.beginLsb) >= 0 && compare(beginMsb, beginLsb, that.endMsb, that.endLsb) <= 0) || (compare(endMsb, endLsb, that.beginMsb, that.beginLsb) >= 0 && compare(endMsb, endLsb, that.endMsb, that.endLsb) <= 0) || contains(that); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test public void doubleLongUnsignedComparison() { assertThat(compare( 0, 0, 0, 0), is(0)); assertThat(compare( 0, 0, 0, -1), is(-1)); assertThat(compare( 0, 0, 0, 1), is(-1)); assertThat(compare( 0, 0, -1, 0), is(-1)); assertThat(compare( 0, 0, -1, -1), is(-1)); assertThat(compare( 0, 0, -1, 1), is(-1)); assertThat(compare( 0, 0, 1, 0), is(-1)); assertThat(compare( 0, 0, 1, -1), is(-1)); assertThat(compare( 0, 0, 1, 1), is(-1)); assertThat(compare( 0, -1, 0, 0), is(1)); assertThat(compare( 0, -1, 0, -1), is(0)); assertThat(compare( 0, -1, 0, 1), is(1)); assertThat(compare( 0, -1, -1, 0), is(-1)); assertThat(compare( 0, -1, -1, -1), is(-1)); assertThat(compare( 0, -1, -1, 1), is(-1)); assertThat(compare( 0, -1, 1, 0), is(-1)); assertThat(compare( 0, -1, 1, -1), is(-1)); assertThat(compare( 0, -1, 1, 1), is(-1)); assertThat(compare( 0, 1, 0, 0), is(1)); assertThat(compare( 0, 1, 0, -1), is(-1)); assertThat(compare( 0, 1, 0, 1), is(0)); assertThat(compare( 0, 1, -1, 0), is(-1)); assertThat(compare( 0, 1, -1, -1), is(-1)); assertThat(compare( 0, 1, -1, 1), is(-1)); assertThat(compare( 0, 1, 1, 0), is(-1)); assertThat(compare( 0, 1, 1, -1), is(-1)); assertThat(compare( 0, 1, 1, 1), is(-1)); assertThat(compare(-1, 0, 0, 0), is(1)); assertThat(compare(-1, 0, 0, -1), is(1)); assertThat(compare(-1, 0, 0, 1), is(1)); assertThat(compare(-1, 0, -1, 0), is(0)); assertThat(compare(-1, 0, -1, -1), is(-1)); assertThat(compare(-1, 0, -1, 1), is(-1)); assertThat(compare(-1, 0, 1, 0), is(1)); assertThat(compare(-1, 0, 1, -1), is(1)); assertThat(compare(-1, 0, 1, 1), is(1)); assertThat(compare(-1, -1, 0, 0), is(1)); assertThat(compare(-1, -1, 0, -1), is(1)); assertThat(compare(-1, -1, 0, 1), is(1)); assertThat(compare(-1, -1, -1, 0), is(1)); assertThat(compare(-1, -1, -1, -1), is(0)); assertThat(compare(-1, -1, -1, 1), is(1)); assertThat(compare(-1, -1, 1, 0), is(1)); assertThat(compare(-1, -1, 1, -1), is(1)); assertThat(compare(-1, -1, 1, 1), is(1)); assertThat(compare(-1, 1, 0, 0), is(1)); assertThat(compare(-1, 1, 0, -1), is(1)); assertThat(compare(-1, 1, 0, 1), is(1)); assertThat(compare(-1, 1, -1, 0), is(1)); assertThat(compare(-1, 1, -1, -1), is(-1)); assertThat(compare(-1, 1, -1, 1), is(0)); assertThat(compare(-1, 1, 1, 0), is(1)); assertThat(compare(-1, 1, 1, -1), is(1)); assertThat(compare(-1, 1, 1, 1), is(1)); assertThat(compare( 1, 0, 0, 0), is(1)); assertThat(compare( 1, 0, 0, -1), is(1)); assertThat(compare( 1, 0, 0, 1), is(1)); assertThat(compare( 1, 0, -1, 0), is(-1)); assertThat(compare( 1, 0, -1, -1), is(-1)); assertThat(compare( 1, 0, -1, 1), is(-1)); assertThat(compare( 1, 0, 1, 0), is(0)); assertThat(compare( 1, 0, 1, -1), is(-1)); assertThat(compare( 1, 0, 1, 1), is(-1)); assertThat(compare( 1, -1, 0, 0), is(1)); assertThat(compare( 1, -1, 0, -1), is(1)); assertThat(compare( 1, -1, 0, 1), is(1)); assertThat(compare( 1, -1, -1, 0), is(-1)); assertThat(compare( 1, -1, -1, -1), is(-1)); assertThat(compare( 1, -1, -1, 1), is(-1)); assertThat(compare( 1, -1, 1, 0), is(1)); assertThat(compare( 1, -1, 1, -1), is(0)); assertThat(compare( 1, -1, 1, 1), is(1)); assertThat(compare( 1, 1, 0, 0), is(1)); assertThat(compare( 1, 1, 0, -1), is(1)); assertThat(compare( 1, 1, 0, 1), is(1)); assertThat(compare( 1, 1, -1, 0), is(-1)); assertThat(compare( 1, 1, -1, -1), is(-1)); assertThat(compare( 1, 1, -1, 1), is(-1)); assertThat(compare( 1, 1, 1, 0), is(1)); assertThat(compare( 1, 1, 1, -1), is(-1)); assertThat(compare( 1, 1, 1, 1), is(0)); } | public static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb) { if (aMsb == bMsb) { if (aLsb == bLsb) { return 0; } if ((aLsb < bLsb) ^ (aLsb < 0) ^ (bLsb < 0)) { return -1; } } else if ((aMsb < bMsb) ^ (aMsb < 0) ^ (bMsb < 0)) { return -1; } return 1; } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb) { if (aMsb == bMsb) { if (aLsb == bLsb) { return 0; } if ((aLsb < bLsb) ^ (aLsb < 0) ^ (bLsb < 0)) { return -1; } } else if ((aMsb < bMsb) ^ (aMsb < 0) ^ (bMsb < 0)) { return -1; } return 1; } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb) { if (aMsb == bMsb) { if (aLsb == bLsb) { return 0; } if ((aLsb < bLsb) ^ (aLsb < 0) ^ (bLsb < 0)) { return -1; } } else if ((aMsb < bMsb) ^ (aMsb < 0) ^ (bMsb < 0)) { return -1; } return 1; } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb) { if (aMsb == bMsb) { if (aLsb == bLsb) { return 0; } if ((aLsb < bLsb) ^ (aLsb < 0) ^ (bLsb < 0)) { return -1; } } else if ((aMsb < bMsb) ^ (aMsb < 0) ^ (bMsb < 0)) { return -1; } return 1; } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb) { if (aMsb == bMsb) { if (aLsb == bLsb) { return 0; } if ((aLsb < bLsb) ^ (aLsb < 0) ^ (bLsb < 0)) { return -1; } } else if ((aMsb < bMsb) ^ (aMsb < 0) ^ (bMsb < 0)) { return -1; } return 1; } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void reverse_empty() { Ipv6Resource.parseReverseDomain(""); } | public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void reverse_null() { Ipv6Resource.parseReverseDomain(null); } | public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void reverse_no_ip6arpa() { Ipv6Resource.parseReverseDomain("1.2.3.4"); } | public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void reverse_no_octets() { Ipv6Resource.parseReverseDomain(".ip6.arpa"); } | public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void reverse_more_than_four_octets() { Ipv6Resource.parseReverseDomain("8.7.6.5.4.3.2.1.in-addr.arpa"); } | public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void reverse_invalid_nibbles_dash() { Ipv6Resource.parseReverseDomain("1-1.1.a.ip6.arpa"); } | public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void reverse_invalid_nibbles_non_hex() { Ipv6Resource.parseReverseDomain("g.ip6.arpa"); } | public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parseReverseDomain(final String address) { Validate.notEmpty(address, "Address cannot be empty"); String cleanAddress = removeTrailingDot(address.trim()).toLowerCase(); Validate.isTrue(cleanAddress.endsWith(IPV6_REVERSE_DOMAIN), "Invalid reverse domain: ", address); cleanAddress = cleanAddress.substring(0, cleanAddress.length() - IPV6_REVERSE_DOMAIN.length()); Validate.isTrue(REVERSE_PATTERN.matcher(cleanAddress).matches(), "Invalid reverse domain: ", address); final StringBuilder builder = new StringBuilder(); int netmask = 0; for (int index = cleanAddress.length() - 1; index >= 0; index -= 2) { builder.append(cleanAddress.charAt(index)); netmask += 4; if (netmask % 16 == 0 && index > 0) { builder.append(':'); } } if (netmask % 16 != 0) { for (int i = 4 - ((netmask / 4) % 4); i > 0; i--) { builder.append('0'); } } if (netmask <= 112) { builder.append("::"); } builder.append('/'); builder.append(netmask); return parse(builder.toString()); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test(expected = IllegalArgumentException.class) public void invalid_prefix_length() { Ipv6Resource.parse("2001::/129"); } | public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); } | Ipv6Resource extends IpInterval<Ipv6Resource> implements Comparable<Ipv6Resource> { public static Ipv6Resource parse(final InetAddress ipv6Address) { final long[] res = byteArrayToLongArray(ipv6Address.getAddress()); return new Ipv6Resource(res[0], res[1], IPV6_BITCOUNT); } private Ipv6Resource(final long msb, final long lsb, final int prefixLength); Ipv6Resource(final BigInteger begin, final BigInteger end); static long lsb(final BigInteger begin); static long msb(final BigInteger begin); static Ipv6Resource parseFromStrings(final String msb, final String lsb, final int len); static Ipv6Resource parse(final InetAddress ipv6Address); static Ipv6Resource parse(final CIString prefixOrAddress); static Ipv6Resource parse(final String prefixOrAddress); static Ipv6Resource parseReverseDomain(final String address); @Override final AttributeType getAttributeType(); BigInteger begin(); BigInteger end(); static int compare(final long aMsb, final long aLsb, final long bMsb, final long bLsb); @Override int compareTo(final Ipv6Resource that); @Override boolean contains(final Ipv6Resource that); @Override boolean intersects(final Ipv6Resource that); @Override Ipv6Resource singletonIntervalAtLowerBound(); @Override int compareUpperBound(final Ipv6Resource that); @Override InetAddress beginAsInetAddress(); @Override InetAddress endAsInetAddress(); @Override int getPrefixLength(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); static Ipv6Resource parseIPv6Resource(final String resource); static final String IPV6_REVERSE_DOMAIN; static final Ipv6Resource MAX_RANGE; } |
@Test public void handleLines_throws_exception() throws IOException { final BufferedReader reader = new BufferedReader(new StringReader("line1\n\nline2")); final GrsSource.LineHandler lineHandler = mock(GrsSource.LineHandler.class); doThrow(NullPointerException.class).when(lineHandler).handleLines(anyListOf(String.class)); subject.handleLines(reader, lineHandler); verify(lineHandler).handleLines(Lists.newArrayList("line1\n")); verify(lineHandler).handleLines(Lists.newArrayList("line2\n")); } | void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } | GrsSource implements InitializingBean { void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } } | GrsSource implements InitializingBean { void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } GrsSource(final String name, final SourceContext sourceContext, final DateTimeProvider dateTimeProvider, final AuthoritativeResourceData authoritativeResourceData, final Downloader downloader); } | GrsSource implements InitializingBean { void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } GrsSource(final String name, final SourceContext sourceContext, final DateTimeProvider dateTimeProvider, final AuthoritativeResourceData authoritativeResourceData, final Downloader downloader); @Override void afterPropertiesSet(); Logger getLogger(); @Override String toString(); } | GrsSource implements InitializingBean { void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } GrsSource(final String name, final SourceContext sourceContext, final DateTimeProvider dateTimeProvider, final AuthoritativeResourceData authoritativeResourceData, final Downloader downloader); @Override void afterPropertiesSet(); Logger getLogger(); @Override String toString(); } |
@Test public void convert_email() { final String value = "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail: no-reply@zürich.example\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail: [email protected]\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void convert_email_local_part_only() { final String value = "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail: no-reply\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail: no-reply\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void convert_email_double_at_address() { final String value = "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail: no-reply@@zürich.example\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail: no-reply@[email protected]\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void convert_email_dots() { final String value = "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail: [email protected]ürich..example...\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail: [email protected]ürich..example...\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void convert_email_name_and_address() { final String value = "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail: Example Usër <example@zürich.example>\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail: Example Usër <[email protected]>\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void convert_email_domain_only_not_local_part() { final String value = "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail: no-rëply@zürich.example\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail: no-rë[email protected]\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void convert_email_cyrillic() { final String value = "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail: no-reply@москва.ru\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail: [email protected]\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void convert_email_with_tabs() { final String value = "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail:\t\tno-reply@zürich.example\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail:\t\[email protected]\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void convert_email_with_tabs_and_spaces() { final String value = "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail:\t \t no-reply@zürich.example\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "role: Test Role\n" + "nic-hdl: TR1-TEST\n" + "e-mail:\t \t [email protected]\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void convert_multiple_email() { final String value = "role: Test Role\n" + "nic-hdl: AR1-TEST\n" + "e-mail: user@zürich.example\n" + "e-mail: no-reply@zürich.example\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "role: Test Role\n" + "nic-hdl: AR1-TEST\n" + "e-mail: [email protected]\n" + "e-mail: [email protected]\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void handleLines_start_of_line_comment() throws IOException { final BufferedReader reader = new BufferedReader(new StringReader("line1\n#line2\nline3\n%line4\nline5")); final GrsSource.LineHandler lineHandler = mock(GrsSource.LineHandler.class); subject.handleLines(reader, lineHandler); verify(lineHandler).handleLines(Lists.newArrayList("line1\n", "line3\n", "line5\n")); verifyNoMoreInteractions(lineHandler); } | void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } | GrsSource implements InitializingBean { void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } } | GrsSource implements InitializingBean { void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } GrsSource(final String name, final SourceContext sourceContext, final DateTimeProvider dateTimeProvider, final AuthoritativeResourceData authoritativeResourceData, final Downloader downloader); } | GrsSource implements InitializingBean { void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } GrsSource(final String name, final SourceContext sourceContext, final DateTimeProvider dateTimeProvider, final AuthoritativeResourceData authoritativeResourceData, final Downloader downloader); @Override void afterPropertiesSet(); Logger getLogger(); @Override String toString(); } | GrsSource implements InitializingBean { void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } GrsSource(final String name, final SourceContext sourceContext, final DateTimeProvider dateTimeProvider, final AuthoritativeResourceData authoritativeResourceData, final Downloader downloader); @Override void afterPropertiesSet(); Logger getLogger(); @Override String toString(); } |
@Test public void convert_multiple_trailing_email() { final String value = "role: Test Role\n" + "nic-hdl: AR1-TEST\n" + "source: TEST\n" + "e-mail: user@zürich.example\n" + "e-mail: no-reply@zürich.example"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "role: Test Role\n" + "nic-hdl: AR1-TEST\n" + "source: TEST\n" + "e-mail: [email protected]\n" + "e-mail: [email protected]")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void convert_multiple_email_with_separator_remark() { final String value = "role: Test Role\n" + "nic-hdl: AR1-TEST\n" + "e-mail: user@zürich.example\n" + "remarks: separator\n" + "e-mail: no-reply@zürich.example\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "role: Test Role\n" + "nic-hdl: AR1-TEST\n" + "e-mail: [email protected]\n" + "remarks: separator\n" + "e-mail: [email protected]\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void convert_abuse_mailbox() { final String value = "role: Abuse Role\n" + "nic-hdl: AR1-TEST\n" + "abuse-mailbox: abuse@zürich.example\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "role: Abuse Role\n" + "nic-hdl: AR1-TEST\n" + "abuse-mailbox: [email protected]\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void convert_irt_nfy() { final String value = "irt: IRT-EXAMPLE\n" + "irt-nfy: irt@zürich.example\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "irt: IRT-EXAMPLE\n" + "irt-nfy: [email protected]\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void convert_mnt_nfy() { final String value = "mntner: EXAMPLE-MNT\n" + "mnt-nfy: notify@zürich.example\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "mntner: EXAMPLE-MNT\n" + "mnt-nfy: [email protected]\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void convert_notify() { final String value = "mntner: EXAMPLE-MNT\n" + "notify: notify@zürich.example\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "mntner: EXAMPLE-MNT\n" + "notify: [email protected]\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void convert_ref_nfy() { final String value = "organisation: ORG-EX1-TEST\n" + "ref-nfy: notify@zürich.example\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "organisation: ORG-EX1-TEST\n" + "ref-nfy: [email protected]\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void convert_upd_to() { final String value = "mntner: EXAMPLE-MNT\n" + "upd-to: notify@zürich.example\n" + "source: TEST\n"; final String result = PunycodeConversion.convert(value); assertThat(result, is( "mntner: EXAMPLE-MNT\n" + "upd-to: [email protected]\n" + "source: TEST\n")); } | public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } | PunycodeConversion { public static String convert(final String value) { final Matcher matcher = EMAIL_ADDRESS_PATTERN.matcher(value); while (matcher.find()) { final String key = matcher.group(1); final String space = matcher.group(2); final String address = matcher.group(3); final String newline = matcher.group(4); final String convertedAddress = toAscii(address); if (!convertedAddress.equals(address)) { final String originalMatch = matcher.group(0); final String convertedMatch = String.format("%s:%s%s%s", key, space, convertedAddress, newline); return convert(value.replace(originalMatch, convertedMatch)); } } return value; } private PunycodeConversion(); static String convert(final String value); } |
@Test public void create_null() { assertNull(ciString(null)); } | @Nullable public static CIString ciString(final String value) { if (value == null) { return null; } return new CIString(value); } | CIString implements Comparable<CIString>, CharSequence { @Nullable public static CIString ciString(final String value) { if (value == null) { return null; } return new CIString(value); } } | CIString implements Comparable<CIString>, CharSequence { @Nullable public static CIString ciString(final String value) { if (value == null) { return null; } return new CIString(value); } private CIString(final String value); } | CIString implements Comparable<CIString>, CharSequence { @Nullable public static CIString ciString(final String value) { if (value == null) { return null; } return new CIString(value); } private CIString(final String value); @Nullable static CIString ciString(final String value); static Set<CIString> ciSet(final String... values); static Set<CIString> ciImmutableSet(final String... values); static Set<CIString> ciSet(final Iterable<String> values); static Set<CIString> ciImmutableSet(final Iterable<String> values); static boolean isBlank(final CIString ciString); @Override boolean equals(@Nullable final Object o); @Override int hashCode(); @Override int compareTo(@Nonnull final CIString o); @Override @Nonnull String toString(); String toLowerCase(); String toUpperCase(); int toInt(); @Override int length(); @Override char charAt(final int index); @Override CharSequence subSequence(final int start, final int end); boolean startsWith(final CIString value); boolean startsWith(final String value); boolean contains(final CIString value); boolean contains(final String value); boolean endsWith(final CIString value); boolean endsWith(final String value); CIString append(final CIString other); } | CIString implements Comparable<CIString>, CharSequence { @Nullable public static CIString ciString(final String value) { if (value == null) { return null; } return new CIString(value); } private CIString(final String value); @Nullable static CIString ciString(final String value); static Set<CIString> ciSet(final String... values); static Set<CIString> ciImmutableSet(final String... values); static Set<CIString> ciSet(final Iterable<String> values); static Set<CIString> ciImmutableSet(final Iterable<String> values); static boolean isBlank(final CIString ciString); @Override boolean equals(@Nullable final Object o); @Override int hashCode(); @Override int compareTo(@Nonnull final CIString o); @Override @Nonnull String toString(); String toLowerCase(); String toUpperCase(); int toInt(); @Override int length(); @Override char charAt(final int index); @Override CharSequence subSequence(final int start, final int end); boolean startsWith(final CIString value); boolean startsWith(final String value); boolean contains(final CIString value); boolean contains(final String value); boolean endsWith(final CIString value); boolean endsWith(final String value); CIString append(final CIString other); } |
@Test public void equals() { assertThat(ciString("ABC"), is(ciString("ABC"))); assertThat(ciString("ABC"), is(ciString("abc"))); assertThat(ciString("ABC"), is(ciString("aBc"))); final CIString ripe = CIString.ciString("RIPE"); assertFalse(ripe.equals(null)); assertTrue(ripe.equals(ripe)); assertTrue(ripe.equals(CIString.ciString("RIPE"))); assertTrue(ripe.equals("ripe")); assertTrue(ripe.equals("RIPE")); } | @Override public boolean equals(@Nullable final Object o) { if (this == o) { return true; } if (o == null) { return false; } if (o instanceof String) { return value.equalsIgnoreCase((String) o); } return getClass() == o.getClass() && lcValue.equals(((CIString) o).lcValue); } | CIString implements Comparable<CIString>, CharSequence { @Override public boolean equals(@Nullable final Object o) { if (this == o) { return true; } if (o == null) { return false; } if (o instanceof String) { return value.equalsIgnoreCase((String) o); } return getClass() == o.getClass() && lcValue.equals(((CIString) o).lcValue); } } | CIString implements Comparable<CIString>, CharSequence { @Override public boolean equals(@Nullable final Object o) { if (this == o) { return true; } if (o == null) { return false; } if (o instanceof String) { return value.equalsIgnoreCase((String) o); } return getClass() == o.getClass() && lcValue.equals(((CIString) o).lcValue); } private CIString(final String value); } | CIString implements Comparable<CIString>, CharSequence { @Override public boolean equals(@Nullable final Object o) { if (this == o) { return true; } if (o == null) { return false; } if (o instanceof String) { return value.equalsIgnoreCase((String) o); } return getClass() == o.getClass() && lcValue.equals(((CIString) o).lcValue); } private CIString(final String value); @Nullable static CIString ciString(final String value); static Set<CIString> ciSet(final String... values); static Set<CIString> ciImmutableSet(final String... values); static Set<CIString> ciSet(final Iterable<String> values); static Set<CIString> ciImmutableSet(final Iterable<String> values); static boolean isBlank(final CIString ciString); @Override boolean equals(@Nullable final Object o); @Override int hashCode(); @Override int compareTo(@Nonnull final CIString o); @Override @Nonnull String toString(); String toLowerCase(); String toUpperCase(); int toInt(); @Override int length(); @Override char charAt(final int index); @Override CharSequence subSequence(final int start, final int end); boolean startsWith(final CIString value); boolean startsWith(final String value); boolean contains(final CIString value); boolean contains(final String value); boolean endsWith(final CIString value); boolean endsWith(final String value); CIString append(final CIString other); } | CIString implements Comparable<CIString>, CharSequence { @Override public boolean equals(@Nullable final Object o) { if (this == o) { return true; } if (o == null) { return false; } if (o instanceof String) { return value.equalsIgnoreCase((String) o); } return getClass() == o.getClass() && lcValue.equals(((CIString) o).lcValue); } private CIString(final String value); @Nullable static CIString ciString(final String value); static Set<CIString> ciSet(final String... values); static Set<CIString> ciImmutableSet(final String... values); static Set<CIString> ciSet(final Iterable<String> values); static Set<CIString> ciImmutableSet(final Iterable<String> values); static boolean isBlank(final CIString ciString); @Override boolean equals(@Nullable final Object o); @Override int hashCode(); @Override int compareTo(@Nonnull final CIString o); @Override @Nonnull String toString(); String toLowerCase(); String toUpperCase(); int toInt(); @Override int length(); @Override char charAt(final int index); @Override CharSequence subSequence(final int start, final int end); boolean startsWith(final CIString value); boolean startsWith(final String value); boolean contains(final CIString value); boolean contains(final String value); boolean endsWith(final CIString value); boolean endsWith(final String value); CIString append(final CIString other); } |
@Test public void handleLines_multiple_newlines() throws IOException { final BufferedReader reader = new BufferedReader(new StringReader("line1\n\n\n\n\n\nline2\n\n\n\n\n")); final GrsSource.LineHandler lineHandler = mock(GrsSource.LineHandler.class); subject.handleLines(reader, lineHandler); verify(lineHandler).handleLines(Lists.newArrayList("line1\n")); verify(lineHandler).handleLines(Lists.newArrayList("line2\n")); verifyNoMoreInteractions(lineHandler); } | void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } | GrsSource implements InitializingBean { void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } } | GrsSource implements InitializingBean { void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } GrsSource(final String name, final SourceContext sourceContext, final DateTimeProvider dateTimeProvider, final AuthoritativeResourceData authoritativeResourceData, final Downloader downloader); } | GrsSource implements InitializingBean { void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } GrsSource(final String name, final SourceContext sourceContext, final DateTimeProvider dateTimeProvider, final AuthoritativeResourceData authoritativeResourceData, final Downloader downloader); @Override void afterPropertiesSet(); Logger getLogger(); @Override String toString(); } | GrsSource implements InitializingBean { void handleLines(final BufferedReader reader, final LineHandler lineHandler) throws IOException { List<String> lines = Lists.newArrayList(); StringBuilder lineBuilder = new StringBuilder(); for (String line = reader.readLine(); line != null; line = reader.readLine()) { if (line.length() == 0) { lineBuilder = addLine(lines, lineBuilder); handleLines(lineHandler, lines); lines = Lists.newArrayList(); continue; } final char firstChar = line.charAt(0); if (firstChar == '#' || firstChar == '%') { continue; } if (firstChar != ' ' && firstChar != '+') { lineBuilder = addLine(lines, lineBuilder); } lineBuilder.append(line).append('\n'); } addLine(lines, lineBuilder); handleLines(lineHandler, lines); } GrsSource(final String name, final SourceContext sourceContext, final DateTimeProvider dateTimeProvider, final AuthoritativeResourceData authoritativeResourceData, final Downloader downloader); @Override void afterPropertiesSet(); Logger getLogger(); @Override String toString(); } |
@Test public void ciset() { assertThat(ciSet("a", "b"), is(ciSet("A", "b"))); assertThat(ciSet("a", "b").contains(ciString("A")), is(true)); assertThat(ciSet("a", "b").contains(ciString("c")), is(false)); } | public static Set<CIString> ciSet(final String... values) { final Set<CIString> result = Sets.newLinkedHashSetWithExpectedSize(values.length); for (final String value : values) { result.add(ciString(value)); } return result; } | CIString implements Comparable<CIString>, CharSequence { public static Set<CIString> ciSet(final String... values) { final Set<CIString> result = Sets.newLinkedHashSetWithExpectedSize(values.length); for (final String value : values) { result.add(ciString(value)); } return result; } } | CIString implements Comparable<CIString>, CharSequence { public static Set<CIString> ciSet(final String... values) { final Set<CIString> result = Sets.newLinkedHashSetWithExpectedSize(values.length); for (final String value : values) { result.add(ciString(value)); } return result; } private CIString(final String value); } | CIString implements Comparable<CIString>, CharSequence { public static Set<CIString> ciSet(final String... values) { final Set<CIString> result = Sets.newLinkedHashSetWithExpectedSize(values.length); for (final String value : values) { result.add(ciString(value)); } return result; } private CIString(final String value); @Nullable static CIString ciString(final String value); static Set<CIString> ciSet(final String... values); static Set<CIString> ciImmutableSet(final String... values); static Set<CIString> ciSet(final Iterable<String> values); static Set<CIString> ciImmutableSet(final Iterable<String> values); static boolean isBlank(final CIString ciString); @Override boolean equals(@Nullable final Object o); @Override int hashCode(); @Override int compareTo(@Nonnull final CIString o); @Override @Nonnull String toString(); String toLowerCase(); String toUpperCase(); int toInt(); @Override int length(); @Override char charAt(final int index); @Override CharSequence subSequence(final int start, final int end); boolean startsWith(final CIString value); boolean startsWith(final String value); boolean contains(final CIString value); boolean contains(final String value); boolean endsWith(final CIString value); boolean endsWith(final String value); CIString append(final CIString other); } | CIString implements Comparable<CIString>, CharSequence { public static Set<CIString> ciSet(final String... values) { final Set<CIString> result = Sets.newLinkedHashSetWithExpectedSize(values.length); for (final String value : values) { result.add(ciString(value)); } return result; } private CIString(final String value); @Nullable static CIString ciString(final String value); static Set<CIString> ciSet(final String... values); static Set<CIString> ciImmutableSet(final String... values); static Set<CIString> ciSet(final Iterable<String> values); static Set<CIString> ciImmutableSet(final Iterable<String> values); static boolean isBlank(final CIString ciString); @Override boolean equals(@Nullable final Object o); @Override int hashCode(); @Override int compareTo(@Nonnull final CIString o); @Override @Nonnull String toString(); String toLowerCase(); String toUpperCase(); int toInt(); @Override int length(); @Override char charAt(final int index); @Override CharSequence subSequence(final int start, final int end); boolean startsWith(final CIString value); boolean startsWith(final String value); boolean contains(final CIString value); boolean contains(final String value); boolean endsWith(final CIString value); boolean endsWith(final String value); CIString append(final CIString other); } |
@Test public void tostring() { assertThat(ciString("SoMe WeIrd CasIng").toString(), is("SoMe WeIrd CasIng")); } | @Override @Nonnull public String toString() { return value; } | CIString implements Comparable<CIString>, CharSequence { @Override @Nonnull public String toString() { return value; } } | CIString implements Comparable<CIString>, CharSequence { @Override @Nonnull public String toString() { return value; } private CIString(final String value); } | CIString implements Comparable<CIString>, CharSequence { @Override @Nonnull public String toString() { return value; } private CIString(final String value); @Nullable static CIString ciString(final String value); static Set<CIString> ciSet(final String... values); static Set<CIString> ciImmutableSet(final String... values); static Set<CIString> ciSet(final Iterable<String> values); static Set<CIString> ciImmutableSet(final Iterable<String> values); static boolean isBlank(final CIString ciString); @Override boolean equals(@Nullable final Object o); @Override int hashCode(); @Override int compareTo(@Nonnull final CIString o); @Override @Nonnull String toString(); String toLowerCase(); String toUpperCase(); int toInt(); @Override int length(); @Override char charAt(final int index); @Override CharSequence subSequence(final int start, final int end); boolean startsWith(final CIString value); boolean startsWith(final String value); boolean contains(final CIString value); boolean contains(final String value); boolean endsWith(final CIString value); boolean endsWith(final String value); CIString append(final CIString other); } | CIString implements Comparable<CIString>, CharSequence { @Override @Nonnull public String toString() { return value; } private CIString(final String value); @Nullable static CIString ciString(final String value); static Set<CIString> ciSet(final String... values); static Set<CIString> ciImmutableSet(final String... values); static Set<CIString> ciSet(final Iterable<String> values); static Set<CIString> ciImmutableSet(final Iterable<String> values); static boolean isBlank(final CIString ciString); @Override boolean equals(@Nullable final Object o); @Override int hashCode(); @Override int compareTo(@Nonnull final CIString o); @Override @Nonnull String toString(); String toLowerCase(); String toUpperCase(); int toInt(); @Override int length(); @Override char charAt(final int index); @Override CharSequence subSequence(final int start, final int end); boolean startsWith(final CIString value); boolean startsWith(final String value); boolean contains(final CIString value); boolean contains(final String value); boolean endsWith(final CIString value); boolean endsWith(final String value); CIString append(final CIString other); } |
@Test public void subsequence() { assertThat(ciString("abcdef").subSequence(1, 3), is((CharSequence) "bc")); assertThat(ciString("ABCDEF").subSequence(1, 3), is((CharSequence) "BC")); } | @Override public CharSequence subSequence(final int start, final int end) { return value.subSequence(start, end); } | CIString implements Comparable<CIString>, CharSequence { @Override public CharSequence subSequence(final int start, final int end) { return value.subSequence(start, end); } } | CIString implements Comparable<CIString>, CharSequence { @Override public CharSequence subSequence(final int start, final int end) { return value.subSequence(start, end); } private CIString(final String value); } | CIString implements Comparable<CIString>, CharSequence { @Override public CharSequence subSequence(final int start, final int end) { return value.subSequence(start, end); } private CIString(final String value); @Nullable static CIString ciString(final String value); static Set<CIString> ciSet(final String... values); static Set<CIString> ciImmutableSet(final String... values); static Set<CIString> ciSet(final Iterable<String> values); static Set<CIString> ciImmutableSet(final Iterable<String> values); static boolean isBlank(final CIString ciString); @Override boolean equals(@Nullable final Object o); @Override int hashCode(); @Override int compareTo(@Nonnull final CIString o); @Override @Nonnull String toString(); String toLowerCase(); String toUpperCase(); int toInt(); @Override int length(); @Override char charAt(final int index); @Override CharSequence subSequence(final int start, final int end); boolean startsWith(final CIString value); boolean startsWith(final String value); boolean contains(final CIString value); boolean contains(final String value); boolean endsWith(final CIString value); boolean endsWith(final String value); CIString append(final CIString other); } | CIString implements Comparable<CIString>, CharSequence { @Override public CharSequence subSequence(final int start, final int end) { return value.subSequence(start, end); } private CIString(final String value); @Nullable static CIString ciString(final String value); static Set<CIString> ciSet(final String... values); static Set<CIString> ciImmutableSet(final String... values); static Set<CIString> ciSet(final Iterable<String> values); static Set<CIString> ciImmutableSet(final Iterable<String> values); static boolean isBlank(final CIString ciString); @Override boolean equals(@Nullable final Object o); @Override int hashCode(); @Override int compareTo(@Nonnull final CIString o); @Override @Nonnull String toString(); String toLowerCase(); String toUpperCase(); int toInt(); @Override int length(); @Override char charAt(final int index); @Override CharSequence subSequence(final int start, final int end); boolean startsWith(final CIString value); boolean startsWith(final String value); boolean contains(final CIString value); boolean contains(final String value); boolean endsWith(final CIString value); boolean endsWith(final String value); CIString append(final CIString other); } |
@Test public void charAt() { assertThat(ciString("abcdef").charAt(1), is('b')); assertThat(ciString("ABCDEF").charAt(1), is('B')); } | @Override public char charAt(final int index) { return value.charAt(index); } | CIString implements Comparable<CIString>, CharSequence { @Override public char charAt(final int index) { return value.charAt(index); } } | CIString implements Comparable<CIString>, CharSequence { @Override public char charAt(final int index) { return value.charAt(index); } private CIString(final String value); } | CIString implements Comparable<CIString>, CharSequence { @Override public char charAt(final int index) { return value.charAt(index); } private CIString(final String value); @Nullable static CIString ciString(final String value); static Set<CIString> ciSet(final String... values); static Set<CIString> ciImmutableSet(final String... values); static Set<CIString> ciSet(final Iterable<String> values); static Set<CIString> ciImmutableSet(final Iterable<String> values); static boolean isBlank(final CIString ciString); @Override boolean equals(@Nullable final Object o); @Override int hashCode(); @Override int compareTo(@Nonnull final CIString o); @Override @Nonnull String toString(); String toLowerCase(); String toUpperCase(); int toInt(); @Override int length(); @Override char charAt(final int index); @Override CharSequence subSequence(final int start, final int end); boolean startsWith(final CIString value); boolean startsWith(final String value); boolean contains(final CIString value); boolean contains(final String value); boolean endsWith(final CIString value); boolean endsWith(final String value); CIString append(final CIString other); } | CIString implements Comparable<CIString>, CharSequence { @Override public char charAt(final int index) { return value.charAt(index); } private CIString(final String value); @Nullable static CIString ciString(final String value); static Set<CIString> ciSet(final String... values); static Set<CIString> ciImmutableSet(final String... values); static Set<CIString> ciSet(final Iterable<String> values); static Set<CIString> ciImmutableSet(final Iterable<String> values); static boolean isBlank(final CIString ciString); @Override boolean equals(@Nullable final Object o); @Override int hashCode(); @Override int compareTo(@Nonnull final CIString o); @Override @Nonnull String toString(); String toLowerCase(); String toUpperCase(); int toInt(); @Override int length(); @Override char charAt(final int index); @Override CharSequence subSequence(final int start, final int end); boolean startsWith(final CIString value); boolean startsWith(final String value); boolean contains(final CIString value); boolean contains(final String value); boolean endsWith(final CIString value); boolean endsWith(final String value); CIString append(final CIString other); } |
Subsets and Splits