| @@ -539,15 +539,11 @@ public class AntClassLoader extends ClassLoader implements SubBuildListener, Clo | |||
| */ | |||
| public String getClasspath() { | |||
| final StringBuilder sb = new StringBuilder(); | |||
| boolean firstPass = true; | |||
| final Enumeration<File> componentEnum = pathComponents.elements(); | |||
| while (componentEnum.hasMoreElements()) { | |||
| if (!firstPass) { | |||
| sb.append(System.getProperty("path.separator")); | |||
| } else { | |||
| firstPass = false; | |||
| for (final File component : pathComponents) { | |||
| if (sb.length() > 0) { | |||
| sb.append(File.pathSeparator); | |||
| } | |||
| sb.append(componentEnum.nextElement().getAbsolutePath()); | |||
| sb.append(component.getAbsolutePath()); | |||
| } | |||
| return sb.toString(); | |||
| } | |||
| @@ -1407,8 +1403,8 @@ public class AntClassLoader extends ClassLoader implements SubBuildListener, Clo | |||
| * files are closed. | |||
| */ | |||
| public synchronized void cleanup() { | |||
| for (final Enumeration<JarFile> e = jarFiles.elements(); e.hasMoreElements();) { | |||
| FileUtils.close(e.nextElement()); | |||
| for (final JarFile jarFile : jarFiles.values()) { | |||
| FileUtils.close(jarFile); | |||
| } | |||
| jarFiles = new Hashtable<>(); | |||
| if (project != null) { | |||
| @@ -58,6 +58,7 @@ public class DefaultLogger implements BuildLogger { | |||
| // CheckStyle:ConstantNameCheck OFF - bc | |||
| /** Line separator */ | |||
| @Deprecated | |||
| protected static final String lSep = StringUtils.LINE_SEP; | |||
| // CheckStyle:ConstantNameCheck ON | |||
| @@ -149,7 +150,7 @@ public class DefaultLogger implements BuildLogger { | |||
| if (verbose || !(error instanceof BuildException)) { | |||
| m.append(StringUtils.getStackTrace(error)); | |||
| } else { | |||
| m.append(error).append(lSep); | |||
| m.append(error).append(StringUtils.LINE_SEP); | |||
| } | |||
| } | |||
| @@ -613,6 +613,7 @@ public class DirectoryScanner | |||
| * | |||
| * @since Ant 1.6 | |||
| */ | |||
| @SuppressWarnings("deprecated") | |||
| public static void resetDefaultExcludes() { | |||
| synchronized (defaultExcludes) { | |||
| defaultExcludes.clear(); | |||
| @@ -1269,7 +1269,7 @@ public class Main implements AntMain { | |||
| final String heading, | |||
| final int maxlen) { | |||
| // now, start printing the targets and their descriptions | |||
| final String lSep = System.getProperty("line.separator"); | |||
| final String lSep = System.lineSeparator(); | |||
| // got a bit annoyed that I couldn't find a pad function | |||
| StringBuilder spaces = new StringBuilder(" "); | |||
| while (spaces.length() <= maxlen) { | |||
| @@ -83,11 +83,7 @@ public class PathTokenizer { | |||
| * in the string after the current position; <code>false</code> otherwise. | |||
| */ | |||
| public boolean hasMoreTokens() { | |||
| if (lookahead != null) { | |||
| return true; | |||
| } | |||
| return tokenizer.hasMoreTokens(); | |||
| return lookahead != null || tokenizer.hasMoreTokens(); | |||
| } | |||
| /** | |||
| @@ -1828,10 +1828,10 @@ public class Project implements ResourceFactory { | |||
| + root); | |||
| } | |||
| } | |||
| final StringBuilder buf = new StringBuilder("Build sequence for target(s)"); | |||
| for (int j = 0; j < roots.length; j++) { | |||
| buf.append((j == 0) ? " `" : ", `").append(roots[j]).append('\''); | |||
| final StringBuilder buf = new StringBuilder(); | |||
| for (String root : roots) { | |||
| buf.append((buf.length() == 0) ? "Build sequence for target(s) `" | |||
| : ", `").append(root).append('\''); | |||
| } | |||
| buf.append(" is ").append(ret); | |||
| log(buf.toString(), MSG_VERBOSE); | |||
| @@ -556,10 +556,8 @@ public class ProjectHelper { | |||
| return ex; | |||
| } | |||
| String errorMessage | |||
| = "The following error occurred while executing this line:" | |||
| + System.getProperty("line.separator") | |||
| + ex.getLocation().toString() | |||
| + ex.getMessage(); | |||
| = String.format("The following error occurred while executing this line:%n%s%s", | |||
| ex.getLocation().toString(), ex.getMessage()); | |||
| if (ex instanceof ExitStatusException) { | |||
| int exitStatus = ((ExitStatusException) ex).getStatus(); | |||
| if (newLocation == null) { | |||
| @@ -20,10 +20,10 @@ package org.apache.tools.ant; | |||
| import java.util.ArrayList; | |||
| import java.util.Collection; | |||
| import java.util.Collections; | |||
| import java.util.Enumeration; | |||
| import java.util.HashSet; | |||
| import java.util.Hashtable; | |||
| import java.util.List; | |||
| import java.util.Map; | |||
| import java.util.Set; | |||
| import java.util.Vector; | |||
| @@ -974,14 +974,11 @@ public class PropertyHelper implements GetProperty { | |||
| public void copyInheritedProperties(Project other) { | |||
| //avoid concurrent modification: | |||
| synchronized (inheritedProperties) { | |||
| Enumeration<String> e = inheritedProperties.keys(); | |||
| while (e.hasMoreElements()) { | |||
| String arg = e.nextElement(); | |||
| if (other.getUserProperty(arg) != null) { | |||
| continue; | |||
| for (Map.Entry<String, Object> entry : inheritedProperties.entrySet()) { | |||
| String arg = entry.getKey(); | |||
| if (other.getUserProperty(arg) == null) { | |||
| other.setInheritedProperty(arg, entry.getValue().toString()); | |||
| } | |||
| Object value = inheritedProperties.get(arg); | |||
| other.setInheritedProperty(arg, value.toString()); | |||
| } | |||
| } | |||
| } | |||
| @@ -1004,14 +1001,11 @@ public class PropertyHelper implements GetProperty { | |||
| public void copyUserProperties(Project other) { | |||
| //avoid concurrent modification: | |||
| synchronized (userProperties) { | |||
| Enumeration<String> e = userProperties.keys(); | |||
| while (e.hasMoreElements()) { | |||
| Object arg = e.nextElement(); | |||
| if (inheritedProperties.containsKey(arg)) { | |||
| continue; | |||
| for (Map.Entry<String, Object> entry : userProperties.entrySet()) { | |||
| String arg = entry.getKey(); | |||
| if (!inheritedProperties.containsKey(arg)) { | |||
| other.setUserProperty(arg, entry.getValue().toString()); | |||
| } | |||
| Object value = userProperties.get(arg); | |||
| other.setUserProperty(arg.toString(), value.toString()); | |||
| } | |||
| } | |||
| } | |||
| @@ -1123,16 +1117,14 @@ public class PropertyHelper implements GetProperty { | |||
| * @return Set<Class> | |||
| * @since Ant 1.8.0 | |||
| */ | |||
| @SuppressWarnings("unchecked") | |||
| protected static Set<Class<? extends Delegate>> getDelegateInterfaces(Delegate d) { | |||
| final HashSet<Class<? extends Delegate>> result = new HashSet<>(); | |||
| Class<?> c = d.getClass(); | |||
| while (c != null) { | |||
| for (Class<?> ifc : c.getInterfaces()) { | |||
| if (Delegate.class.isAssignableFrom(ifc)) { | |||
| @SuppressWarnings("unchecked") | |||
| final Class<? extends Delegate> delegateInterface = | |||
| (Class<? extends Delegate>) ifc; | |||
| result.add(delegateInterface); | |||
| result.add((Class<? extends Delegate>) ifc); | |||
| } | |||
| } | |||
| c = c.getSuperclass(); | |||
| @@ -531,23 +531,22 @@ public class RuntimeConfigurable implements Serializable { | |||
| ih.setAttribute(p, target, name, attrValue); | |||
| } catch (UnsupportedAttributeException be) { | |||
| // id attribute must be set externally | |||
| if ("id".equals(name)) { | |||
| // Do nothing | |||
| } else if (getElementTag() == null) { | |||
| throw be; | |||
| } else { | |||
| throw new BuildException( | |||
| getElementTag() + " doesn't support the \"" | |||
| + be.getAttribute() + "\" attribute", be); | |||
| if (!"id".equals(name)) { | |||
| if (getElementTag() == null) { | |||
| throw be; | |||
| } else { | |||
| throw new BuildException( | |||
| getElementTag() + " doesn't support the \"" | |||
| + be.getAttribute() + "\" attribute", be); | |||
| } | |||
| } | |||
| } catch (BuildException be) { | |||
| if ("id".equals(name)) { | |||
| // Assume that this is an not supported attribute type | |||
| // thrown for example by a dynamic attribute task | |||
| // Do nothing | |||
| } else { | |||
| if (!"id".equals(name)) { | |||
| throw be; | |||
| } | |||
| // Assume that this is an not supported attribute type | |||
| // thrown for example by a dynamic attribute task -- | |||
| // do nothing | |||
| } | |||
| } | |||
| } | |||
| @@ -94,14 +94,10 @@ public class TaskConfigurationChecker { | |||
| */ | |||
| public void checkErrors() throws BuildException { | |||
| if (!errors.isEmpty()) { | |||
| StringBuilder sb = new StringBuilder("Configuration error on <"); | |||
| sb.append(task.getTaskName()); | |||
| sb.append(">:"); | |||
| sb.append(System.getProperty("line.separator")); | |||
| StringBuilder sb = new StringBuilder(String.format("Configuration error on <%s>:%n", | |||
| task.getTaskName())); | |||
| for (String msg : errors) { | |||
| sb.append("- "); | |||
| sb.append(msg); | |||
| sb.append(System.getProperty("line.separator")); | |||
| sb.append(String.format("- %s%n", msg)); | |||
| } | |||
| throw new BuildException(sb.toString(), task.getLocation()); | |||
| } | |||
| @@ -207,12 +207,11 @@ public class XmlLogger implements BuildLogger { | |||
| * @return the stack of timed elements for the current thread | |||
| */ | |||
| private Stack<TimedElement> getStack() { | |||
| Stack<TimedElement> threadStack = threadStacks.computeIfAbsent(Thread.currentThread(), k -> new Stack<>()); | |||
| /* For debugging purposes uncomment: | |||
| org.w3c.dom.Comment s = doc.createComment("stack=" + threadStack); | |||
| buildElement.element.appendChild(s); | |||
| */ | |||
| return threadStack; | |||
| return threadStacks.computeIfAbsent(Thread.currentThread(), k -> new Stack<>()); | |||
| } | |||
| /** | |||
| @@ -73,11 +73,10 @@ public abstract class BaseIfAttribute | |||
| Hashtable<String, Object> attributes = rc.getAttributeMap(); // This does a copy! | |||
| for (Map.Entry<String, Object> entry : attributes.entrySet()) { | |||
| String key = entry.getKey(); | |||
| String value = (String) entry.getValue(); | |||
| if (key.startsWith("ant-attribute:param")) { | |||
| int pos = key.lastIndexOf(':'); | |||
| ret.put(key.substring(pos + 1), | |||
| el.getProject().replaceProperties(value)); | |||
| el.getProject().replaceProperties((String) entry.getValue())); | |||
| } | |||
| } | |||
| return ret; | |||
| @@ -86,41 +86,27 @@ public final class ClassConstants | |||
| * be read (for example due to the class not being found). | |||
| */ | |||
| public int read() throws IOException { | |||
| int ch = -1; | |||
| if (queuedData != null && queuedData.length() == 0) { | |||
| queuedData = null; | |||
| } | |||
| if (queuedData != null) { | |||
| ch = queuedData.charAt(0); | |||
| queuedData = queuedData.substring(1); | |||
| if (queuedData.length() == 0) { | |||
| queuedData = null; | |||
| } | |||
| } else { | |||
| if (queuedData == null) { | |||
| final String clazz = readFully(); | |||
| if (clazz == null || clazz.length() == 0) { | |||
| ch = -1; | |||
| } else { | |||
| final byte[] bytes = clazz.getBytes(ResourceUtils.ISO_8859_1); | |||
| try { | |||
| final Class<?> javaClassHelper = | |||
| Class.forName(JAVA_CLASS_HELPER); | |||
| final Class<?> javaClassHelper = Class.forName(JAVA_CLASS_HELPER); | |||
| if (javaClassHelper != null) { | |||
| final Class<?>[] params = { | |||
| byte[].class | |||
| }; | |||
| final Method getConstants = | |||
| javaClassHelper.getMethod("getConstants", params); | |||
| final Object[] args = { | |||
| bytes | |||
| }; | |||
| javaClassHelper.getMethod("getConstants", byte[].class); | |||
| // getConstants is a static method, no need to | |||
| // pass in the object | |||
| final StringBuffer sb = (StringBuffer) | |||
| getConstants.invoke(null, args); | |||
| getConstants.invoke(null, (Object) bytes); | |||
| if (sb.length() > 0) { | |||
| queuedData = sb.toString(); | |||
| return read(); | |||
| @@ -141,6 +127,12 @@ public final class ClassConstants | |||
| throw new BuildException(ex); | |||
| } | |||
| } | |||
| } else { | |||
| ch = queuedData.charAt(0); | |||
| queuedData = queuedData.substring(1); | |||
| if (queuedData.length() == 0) { | |||
| queuedData = null; | |||
| } | |||
| } | |||
| return ch; | |||
| } | |||
| @@ -156,7 +148,6 @@ public final class ClassConstants | |||
| * the specified reader | |||
| */ | |||
| public Reader chain(final Reader rdr) { | |||
| ClassConstants newFilter = new ClassConstants(rdr); | |||
| return newFilter; | |||
| return new ClassConstants(rdr); | |||
| } | |||
| } | |||
| @@ -192,13 +192,11 @@ public final class ConcatFilter extends BaseParamFilterReader | |||
| final Parameter[] params = getParameters(); | |||
| if (params != null) { | |||
| for (Parameter param : params) { | |||
| if ("prepend".equals(param.getName())) { | |||
| final String paramName = param.getName(); | |||
| if ("prepend".equals(paramName)) { | |||
| setPrepend(new File(param.getValue())); | |||
| continue; | |||
| } | |||
| if ("append".equals(param.getName())) { | |||
| } else if ("append".equals(paramName)) { | |||
| setAppend(new File(param.getValue())); | |||
| continue; | |||
| } | |||
| } | |||
| } | |||
| @@ -19,7 +19,6 @@ package org.apache.tools.ant.filters; | |||
| import java.io.IOException; | |||
| import java.io.Reader; | |||
| import java.util.Properties; | |||
| import org.apache.tools.ant.BuildException; | |||
| import org.apache.tools.ant.Project; | |||
| @@ -98,8 +97,7 @@ public final class ExpandProperties | |||
| if (propertySet == null) { | |||
| getProperty = PropertyHelper.getPropertyHelper(project); | |||
| } else { | |||
| final Properties props = propertySet.getProperties(); | |||
| getProperty = props::getProperty; | |||
| getProperty = propertySet.getProperties()::getProperty; | |||
| } | |||
| Object expanded = new ParseProperties(project, PropertyHelper | |||
| .getPropertyHelper(project) | |||
| @@ -188,13 +188,11 @@ public final class HeadFilter extends BaseParamFilterReader | |||
| Parameter[] params = getParameters(); | |||
| if (params != null) { | |||
| for (Parameter param : params) { | |||
| if (LINES_KEY.equals(param.getName())) { | |||
| final String paramName = param.getName(); | |||
| if (LINES_KEY.equals(paramName)) { | |||
| lines = Long.parseLong(param.getValue()); | |||
| continue; | |||
| } | |||
| if (SKIP_KEY.equals(param.getName())) { | |||
| } else if (SKIP_KEY.equals(paramName)) { | |||
| skip = Long.parseLong(param.getValue()); | |||
| continue; | |||
| } | |||
| } | |||
| } | |||
| @@ -186,10 +186,8 @@ public final class LineContainsRegExp | |||
| LineContainsRegExp newFilter = new LineContainsRegExp(rdr); | |||
| newFilter.setRegexps(getRegexps()); | |||
| newFilter.setNegate(isNegated()); | |||
| newFilter | |||
| .setCaseSensitive(!RegexpUtil.hasFlag(regexpOptions, | |||
| Regexp.MATCH_CASE_INSENSITIVE) | |||
| ); | |||
| newFilter.setCaseSensitive(!RegexpUtil.hasFlag(regexpOptions, | |||
| Regexp.MATCH_CASE_INSENSITIVE)); | |||
| return newFilter; | |||
| } | |||
| @@ -318,16 +318,13 @@ public final class SortFilter extends BaseParamFilterReader | |||
| final String paramName = param.getName(); | |||
| if (REVERSE_KEY.equals(paramName)) { | |||
| setReverse(Boolean.valueOf(param.getValue())); | |||
| continue; | |||
| } | |||
| if (COMPARATOR_KEY.equals(paramName)) { | |||
| } else if (COMPARATOR_KEY.equals(paramName)) { | |||
| try { | |||
| String className = param.getValue(); | |||
| @SuppressWarnings("unchecked") | |||
| final Comparator<? super String> comparatorInstance | |||
| = (Comparator<? super String>) (Class.forName(className).newInstance()); | |||
| setComparator(comparatorInstance); | |||
| continue; | |||
| } catch (InstantiationException | ClassNotFoundException | IllegalAccessException e) { | |||
| /* | |||
| * IAE probably means an inner non-static class, that case is not considered | |||
| @@ -139,7 +139,6 @@ public final class StripJavaComments | |||
| */ | |||
| public Reader chain(final Reader rdr) { | |||
| StripJavaComments newFilter = new StripJavaComments(rdr); | |||
| return newFilter; | |||
| return new StripJavaComments(rdr); | |||
| } | |||
| } | |||
| @@ -188,13 +188,11 @@ public final class TailFilter extends BaseParamFilterReader | |||
| Parameter[] params = getParameters(); | |||
| if (params != null) { | |||
| for (Parameter param : params) { | |||
| if (LINES_KEY.equals(param.getName())) { | |||
| final String paramName = param.getName(); | |||
| if (LINES_KEY.equals(paramName)) { | |||
| setLines(Long.parseLong(param.getValue())); | |||
| continue; | |||
| } | |||
| if (SKIP_KEY.equals(param.getName())) { | |||
| } else if (SKIP_KEY.equals(paramName)) { | |||
| skip = Long.parseLong(param.getValue()); | |||
| continue; | |||
| } | |||
| } | |||
| } | |||
| @@ -23,7 +23,6 @@ import java.io.IOException; | |||
| import org.apache.bcel.classfile.ClassParser; | |||
| import org.apache.bcel.classfile.ConstantValue; | |||
| import org.apache.bcel.classfile.Field; | |||
| import org.apache.bcel.classfile.JavaClass; | |||
| // CheckStyle:HideUtilityClassConstructorCheck OFF - bc | |||
| /** | |||
| @@ -31,9 +30,6 @@ import org.apache.bcel.classfile.JavaClass; | |||
| * | |||
| */ | |||
| public final class JavaClassHelper { | |||
| /** System specific line separator. */ | |||
| private static final String LS = System.getProperty("line.separator"); | |||
| /** | |||
| * Get the constants declared in a file as name=value | |||
| * | |||
| @@ -46,21 +42,16 @@ public final class JavaClassHelper { | |||
| final StringBuffer sb = new StringBuffer(); | |||
| final ByteArrayInputStream bis = new ByteArrayInputStream(bytes); | |||
| final ClassParser parser = new ClassParser(bis, ""); | |||
| final JavaClass javaClass = parser.parse(); | |||
| final Field[] fields = javaClass.getFields(); | |||
| for (final Field field : fields) { | |||
| for (final Field field : parser.parse().getFields()) { | |||
| if (field != null) { | |||
| final ConstantValue cv = field.getConstantValue(); | |||
| if (cv != null) { | |||
| String cvs = cv.toString(); | |||
| //Remove start and end quotes if field is a String | |||
| // Remove start and end quotes if field is a String | |||
| if (cvs.startsWith("\"") && cvs.endsWith("\"")) { | |||
| cvs = cvs.substring(1, cvs.length() - 1); | |||
| } | |||
| sb.append(field.getName()); | |||
| sb.append('='); | |||
| sb.append(cvs); | |||
| sb.append(LS); | |||
| sb.append(String.format("%s=%s%n", field.getName(), cvs)); | |||
| } | |||
| } | |||
| } | |||
| @@ -274,12 +274,10 @@ public class ProjectHelper2 extends ProjectHelper { | |||
| + uri + (zf != null ? " from a zip file" : ""), | |||
| Project.MSG_VERBOSE); | |||
| DefaultHandler hb = handler; | |||
| parser.setContentHandler(hb); | |||
| parser.setEntityResolver(hb); | |||
| parser.setErrorHandler(hb); | |||
| parser.setDTDHandler(hb); | |||
| parser.setContentHandler(handler); | |||
| parser.setEntityResolver(handler); | |||
| parser.setErrorHandler(handler); | |||
| parser.setDTDHandler(handler); | |||
| parser.parse(inputSource); | |||
| } catch (SAXParseException exc) { | |||
| Location location = new Location(exc.getSystemId(), exc.getLineNumber(), exc | |||
| @@ -603,8 +601,7 @@ public class ProjectHelper2 extends ProjectHelper { | |||
| @Override | |||
| public void endElement(String uri, String name, String qName) throws SAXException { | |||
| currentHandler.onEndElement(uri, name, context); | |||
| AntHandler prev = antHandlers.pop(); | |||
| currentHandler = prev; | |||
| currentHandler = antHandlers.pop(); | |||
| if (currentHandler != null) { | |||
| currentHandler.onEndChild(uri, name, qName, context); | |||
| } | |||
| @@ -729,45 +726,49 @@ public class ProjectHelper2 extends ProjectHelper { | |||
| if (attrUri != null && !attrUri.isEmpty() && !attrUri.equals(uri)) { | |||
| continue; // Ignore attributes from unknown uris | |||
| } | |||
| String key = attrs.getLocalName(i); | |||
| String value = attrs.getValue(i); | |||
| if ("default".equals(key)) { | |||
| if (value != null && !value.isEmpty()) { | |||
| if (!context.isIgnoringProjectTag()) { | |||
| project.setDefault(value); | |||
| switch (attrs.getLocalName(i)) { | |||
| case "default": | |||
| if (value != null && !value.isEmpty()) { | |||
| if (!context.isIgnoringProjectTag()) { | |||
| project.setDefault(value); | |||
| } | |||
| } | |||
| } | |||
| } else if ("name".equals(key)) { | |||
| if (value != null) { | |||
| context.setCurrentProjectName(value); | |||
| nameAttributeSet = true; | |||
| if (!context.isIgnoringProjectTag()) { | |||
| project.setName(value); | |||
| project.addReference(value, project); | |||
| } else if (isInIncludeMode()) { | |||
| if (!"".equals(value) && getCurrentTargetPrefix()!= null && getCurrentTargetPrefix().endsWith(ProjectHelper.USE_PROJECT_NAME_AS_TARGET_PREFIX)) { | |||
| String newTargetPrefix = getCurrentTargetPrefix().replace(ProjectHelper.USE_PROJECT_NAME_AS_TARGET_PREFIX, value); | |||
| // help nested include tasks | |||
| setCurrentTargetPrefix(newTargetPrefix); | |||
| break; | |||
| case "name": | |||
| if (value != null) { | |||
| context.setCurrentProjectName(value); | |||
| nameAttributeSet = true; | |||
| if (!context.isIgnoringProjectTag()) { | |||
| project.setName(value); | |||
| project.addReference(value, project); | |||
| } else if (isInIncludeMode()) { | |||
| if (!value.isEmpty() && getCurrentTargetPrefix() != null | |||
| && getCurrentTargetPrefix().endsWith(ProjectHelper.USE_PROJECT_NAME_AS_TARGET_PREFIX)) { | |||
| String newTargetPrefix = getCurrentTargetPrefix().replace(ProjectHelper.USE_PROJECT_NAME_AS_TARGET_PREFIX, value); | |||
| // help nested include tasks | |||
| setCurrentTargetPrefix(newTargetPrefix); | |||
| } | |||
| } | |||
| } | |||
| } | |||
| } else if ("id".equals(key)) { | |||
| if (value != null) { | |||
| // What's the difference between id and name ? | |||
| break; | |||
| case "id": | |||
| if (value != null) { | |||
| // What's the difference between id and name ? | |||
| if (!context.isIgnoringProjectTag()) { | |||
| project.addReference(value, project); | |||
| } | |||
| } | |||
| break; | |||
| case "basedir": | |||
| if (!context.isIgnoringProjectTag()) { | |||
| project.addReference(value, project); | |||
| baseDir = value; | |||
| } | |||
| } | |||
| } else if ("basedir".equals(key)) { | |||
| if (!context.isIgnoringProjectTag()) { | |||
| baseDir = value; | |||
| } | |||
| } else { | |||
| // TODO ignore attributes in a different NS ( maybe store them ? ) | |||
| throw new SAXParseException("Unexpected attribute \"" + attrs.getQName(i) | |||
| + "\"", context.getLocator()); | |||
| break; | |||
| default: | |||
| // TODO ignore attributes in a different NS ( maybe store them ? ) | |||
| throw new SAXParseException("Unexpected attribute \"" + attrs.getQName(i) | |||
| + "\"", context.getLocator()); | |||
| } | |||
| } | |||
| @@ -914,37 +915,44 @@ public class ProjectHelper2 extends ProjectHelper { | |||
| if (attrUri != null && !attrUri.isEmpty() && !attrUri.equals(uri)) { | |||
| continue; // Ignore attributes from unknown uris | |||
| } | |||
| String key = attrs.getLocalName(i); | |||
| String value = attrs.getValue(i); | |||
| if ("name".equals(key)) { | |||
| name = value; | |||
| if (name.isEmpty()) { | |||
| throw new BuildException("name attribute must " + "not be empty"); | |||
| } | |||
| } else if ("depends".equals(key)) { | |||
| depends = value; | |||
| } else if ("if".equals(key)) { | |||
| target.setIf(value); | |||
| } else if ("unless".equals(key)) { | |||
| target.setUnless(value); | |||
| } else if ("id".equals(key)) { | |||
| if (value != null && !value.isEmpty()) { | |||
| context.getProject().addReference(value, target); | |||
| } | |||
| } else if ("description".equals(key)) { | |||
| target.setDescription(value); | |||
| } else if ("extensionOf".equals(key)) { | |||
| extensionPoint = value; | |||
| } else if ("onMissingExtensionPoint".equals(key)) { | |||
| try { | |||
| extensionPointMissing = OnMissingExtensionPoint.valueOf(value); | |||
| } catch (IllegalArgumentException e) { | |||
| throw new BuildException("Invalid onMissingExtensionPoint " + value); | |||
| } | |||
| } else { | |||
| throw new SAXParseException("Unexpected attribute \"" + key + "\"", context | |||
| .getLocator()); | |||
| switch (attrs.getLocalName(i)) { | |||
| case "name": | |||
| name = value; | |||
| if (name.isEmpty()) { | |||
| throw new BuildException("name attribute must not be empty"); | |||
| } | |||
| break; | |||
| case "depends": | |||
| depends = value; | |||
| break; | |||
| case "if": | |||
| target.setIf(value); | |||
| break; | |||
| case "unless": | |||
| target.setUnless(value); | |||
| break; | |||
| case "id": | |||
| if (value != null && !value.isEmpty()) { | |||
| context.getProject().addReference(value, target); | |||
| } | |||
| break; | |||
| case "description": | |||
| target.setDescription(value); | |||
| break; | |||
| case "extensionOf": | |||
| extensionPoint = value; | |||
| break; | |||
| case "onMissingExtensionPoint": | |||
| try { | |||
| extensionPointMissing = OnMissingExtensionPoint.valueOf(value); | |||
| } catch (IllegalArgumentException e) { | |||
| throw new BuildException("Invalid onMissingExtensionPoint " + value); | |||
| } | |||
| break; | |||
| default: | |||
| throw new SAXParseException("Unexpected attribute \"" + attrs.getQName(i) | |||
| + "\"", context.getLocator()); | |||
| } | |||
| } | |||
| @@ -389,19 +389,22 @@ public class ProjectHelperImpl extends ProjectHelper { | |||
| for (int i = 0; i < attrs.getLength(); i++) { | |||
| String key = attrs.getName(i); | |||
| String value = attrs.getValue(i); | |||
| if ("default".equals(key)) { | |||
| def = value; | |||
| } else if ("name".equals(key)) { | |||
| name = value; | |||
| } else if ("id".equals(key)) { | |||
| id = value; | |||
| } else if ("basedir".equals(key)) { | |||
| baseDir = value; | |||
| } else { | |||
| throw new SAXParseException( | |||
| "Unexpected attribute \"" + attrs.getName(i) | |||
| + "\"", helperImpl.locator); | |||
| switch (key) { | |||
| case "default": | |||
| def = value; | |||
| break; | |||
| case "name": | |||
| name = value; | |||
| break; | |||
| case "id": | |||
| id = value; | |||
| break; | |||
| case "basedir": | |||
| baseDir = value; | |||
| break; | |||
| default: | |||
| throw new SAXParseException("Unexpected attribute \"" + attrs.getName(i) | |||
| + "\"", helperImpl.locator); | |||
| } | |||
| } | |||
| @@ -525,26 +528,32 @@ public class ProjectHelperImpl extends ProjectHelper { | |||
| for (int i = 0; i < attrs.getLength(); i++) { | |||
| String key = attrs.getName(i); | |||
| String value = attrs.getValue(i); | |||
| if ("name".equals(key)) { | |||
| name = value; | |||
| if (name.isEmpty()) { | |||
| throw new BuildException("name attribute must not" + " be empty", | |||
| new Location(helperImpl.locator)); | |||
| } | |||
| } else if ("depends".equals(key)) { | |||
| depends = value; | |||
| } else if ("if".equals(key)) { | |||
| ifCond = value; | |||
| } else if ("unless".equals(key)) { | |||
| unlessCond = value; | |||
| } else if ("id".equals(key)) { | |||
| id = value; | |||
| } else if ("description".equals(key)) { | |||
| description = value; | |||
| } else { | |||
| throw new SAXParseException("Unexpected attribute \"" + key + "\"", | |||
| helperImpl.locator); | |||
| switch (key) { | |||
| case "name": | |||
| name = value; | |||
| if (name.isEmpty()) { | |||
| throw new BuildException("name attribute must not be empty", | |||
| new Location(helperImpl.locator)); | |||
| } | |||
| break; | |||
| case "depends": | |||
| depends = value; | |||
| break; | |||
| case "if": | |||
| ifCond = value; | |||
| break; | |||
| case "unless": | |||
| unlessCond = value; | |||
| break; | |||
| case "id": | |||
| id = value; | |||
| break; | |||
| case "description": | |||
| description = value; | |||
| break; | |||
| default: | |||
| throw new SAXParseException("Unexpected attribute \"" + key + "\"", | |||
| helperImpl.locator); | |||
| } | |||
| } | |||
| @@ -472,7 +472,7 @@ public final class Locator { | |||
| */ | |||
| public static URL[] getLocationURLs(File location, | |||
| final String... extensions) | |||
| throws MalformedURLException { | |||
| throws MalformedURLException { | |||
| URL[] urls = new URL[0]; | |||
| if (!location.exists()) { | |||
| @@ -54,9 +54,6 @@ import org.apache.tools.ant.util.FileUtils; | |||
| */ | |||
| public class AntStructure extends Task { | |||
| private static final String LINE_SEP | |||
| = System.getProperty("line.separator"); | |||
| private File output; | |||
| private StructurePrinter printer = new DTDPrinter(); | |||
| @@ -293,15 +290,12 @@ public class AntStructure extends Task { | |||
| return; | |||
| } | |||
| StringBuilder sb = | |||
| new StringBuilder("<!ELEMENT ").append(name).append(" "); | |||
| StringBuilder sb = new StringBuilder("<!ELEMENT ").append(name).append(" "); | |||
| if (Reference.class.equals(element)) { | |||
| sb.append("EMPTY>").append(LINE_SEP); | |||
| sb.append("<!ATTLIST ").append(name); | |||
| sb.append(LINE_SEP).append(" id ID #IMPLIED"); | |||
| sb.append(LINE_SEP).append(" refid IDREF #IMPLIED"); | |||
| sb.append(">").append(LINE_SEP); | |||
| sb.append(String.format("EMPTY>%n<!ATTLIST %s%n" | |||
| + " id ID #IMPLIED%n refid IDREF #IMPLIED>%n", | |||
| name)); | |||
| out.println(sb); | |||
| return; | |||
| } | |||
| @@ -334,9 +328,8 @@ public class AntStructure extends Task { | |||
| sb.append(">"); | |||
| out.println(sb); | |||
| sb = new StringBuilder("<!ATTLIST "); | |||
| sb.append(name); | |||
| sb.append(LINE_SEP).append(" id ID #IMPLIED"); | |||
| sb = new StringBuilder(); | |||
| sb.append(String.format("<!ATTLIST %s%n id ID #IMPLIED", name)); | |||
| e = ih.getAttributes(); | |||
| while (e.hasMoreElements()) { | |||
| @@ -345,22 +338,18 @@ public class AntStructure extends Task { | |||
| continue; | |||
| } | |||
| sb.append(LINE_SEP).append(" ") | |||
| .append(attrName).append(" "); | |||
| sb.append(String.format("%n %s ", attrName)); | |||
| final Class<?> type = ih.getAttributeType(attrName); | |||
| if (type.equals(Boolean.class) | |||
| || type.equals(Boolean.TYPE)) { | |||
| if (type.equals(Boolean.class) || type.equals(Boolean.TYPE)) { | |||
| sb.append(BOOLEAN).append(" "); | |||
| } else if (Reference.class.isAssignableFrom(type)) { | |||
| sb.append("IDREF "); | |||
| } else if (EnumeratedAttribute.class.isAssignableFrom(type)) { | |||
| try { | |||
| final EnumeratedAttribute ea = | |||
| type.asSubclass(EnumeratedAttribute.class) | |||
| .newInstance(); | |||
| type.asSubclass(EnumeratedAttribute.class).newInstance(); | |||
| final String[] values = ea.getValues(); | |||
| if (values == null | |||
| || values.length == 0 | |||
| if (values == null || values.length == 0 | |||
| || !areNmtokens(values)) { | |||
| sb.append("CDATA "); | |||
| } else { | |||
| @@ -387,7 +376,7 @@ public class AntStructure extends Task { | |||
| } | |||
| sb.append("#IMPLIED"); | |||
| } | |||
| sb.append(">").append(LINE_SEP); | |||
| sb.append(">").append(System.lineSeparator()); | |||
| out.println(sb); | |||
| for (String nestedName : v) { | |||
| @@ -595,7 +595,7 @@ public class Concat extends Task implements ResourceCollection { | |||
| */ | |||
| @Deprecated | |||
| public void setForce(boolean forceOverwrite) { | |||
| this.forceOverwrite = forceOverwrite; | |||
| setOverwrite(forceOverwrite); | |||
| } | |||
| /** | |||
| @@ -606,7 +606,7 @@ public class Concat extends Task implements ResourceCollection { | |||
| * @since Ant 1.8.2 | |||
| */ | |||
| public void setOverwrite(boolean forceOverwrite) { | |||
| setForce(forceOverwrite); | |||
| this.forceOverwrite = forceOverwrite; | |||
| } | |||
| /** | |||
| @@ -923,11 +923,8 @@ public class Concat extends Task implements ResourceCollection { | |||
| } | |||
| private boolean isUpToDate(ResourceCollection c) { | |||
| if (dest == null || forceOverwrite) { | |||
| return false; | |||
| } | |||
| return c.stream().noneMatch(r -> SelectorUtils.isOutOfDate(r, dest, | |||
| FILE_UTILS.getFileTimestampGranularity())); | |||
| return dest != null && !forceOverwrite | |||
| && c.stream().noneMatch(r -> SelectorUtils.isOutOfDate(r, dest, FILE_UTILS.getFileTimestampGranularity())); | |||
| } | |||
| /** | |||
| @@ -50,6 +50,7 @@ import org.apache.tools.ant.util.IdentityMapper; | |||
| import org.apache.tools.ant.util.LinkedHashtable; | |||
| import org.apache.tools.ant.util.ResourceUtils; | |||
| import org.apache.tools.ant.util.SourceFileScanner; | |||
| import org.apache.tools.ant.util.StringUtils; | |||
| /** | |||
| * <p>Copies a file or directory to a new file | |||
| @@ -70,8 +71,9 @@ public class Copy extends Task { | |||
| private static final String MSG_WHEN_COPYING_EMPTY_RC_TO_FILE = | |||
| "Cannot perform operation from directory to file."; | |||
| @Deprecated | |||
| static final String LINE_SEPARATOR = StringUtils.LINE_SEP; | |||
| static final File NULL_FILE_PLACEHOLDER = new File("/NULL_FILE"); | |||
| static final String LINE_SEPARATOR = System.getProperty("line.separator"); | |||
| // CheckStyle:VisibilityModifier OFF - bc | |||
| protected File file = null; // the source file | |||
| protected File destFile = null; // the destination file | |||
| @@ -1083,15 +1085,13 @@ public class Copy extends Task { | |||
| message.append(ex.getMessage()); | |||
| } | |||
| if (ex.getClass().getName().contains("MalformedInput")) { | |||
| message.append(LINE_SEPARATOR); | |||
| message.append( | |||
| "This is normally due to the input file containing invalid"); | |||
| message.append(LINE_SEPARATOR); | |||
| message.append("bytes for the character encoding used : "); | |||
| message.append(String.format( | |||
| "%nThis is normally due to the input file containing invalid" | |||
| + "%nbytes for the character encoding used : ")); | |||
| message.append( | |||
| (inputEncoding == null | |||
| ? fileUtils.getDefaultEncoding() : inputEncoding)); | |||
| message.append(LINE_SEPARATOR); | |||
| message.append(System.lineSeparator()); | |||
| } | |||
| return message.toString(); | |||
| } | |||
| @@ -57,7 +57,7 @@ public class EchoXML extends XMLFragment { | |||
| /** | |||
| * Set the namespace policy for the xml file | |||
| * @param n namespace policy: "ignore," "elementsOnly," or "all" | |||
| * @param n namespace policy: "ignore", "elementsOnly", or "all" | |||
| * @see org.apache.tools.ant.util.DOMElementWriter.XmlNamespacePolicy | |||
| */ | |||
| public void setNamespacePolicy(NamespacePolicy n) { | |||
| @@ -27,7 +27,6 @@ import java.nio.file.Files; | |||
| import java.util.Date; | |||
| import java.util.Enumeration; | |||
| import java.util.HashSet; | |||
| import java.util.Iterator; | |||
| import java.util.List; | |||
| import java.util.Set; | |||
| import java.util.Vector; | |||
| @@ -270,7 +269,6 @@ public class Expand extends Task { | |||
| String name = entryName.replace('/', File.separatorChar) | |||
| .replace('\\', File.separatorChar); | |||
| boolean included = false; | |||
| Set<String> includePatterns = new HashSet<>(); | |||
| Set<String> excludePatterns = new HashSet<>(); | |||
| for (PatternSet p : patternsets) { | |||
| @@ -302,20 +300,23 @@ public class Expand extends Task { | |||
| } | |||
| } | |||
| for (Iterator<String> iter = includePatterns.iterator(); | |||
| !included && iter.hasNext();) { | |||
| String pattern = iter.next(); | |||
| included = SelectorUtils.matchPath(pattern, name); | |||
| boolean included = false; | |||
| for (String pattern : includePatterns) { | |||
| if (SelectorUtils.matchPath(pattern, name)) { | |||
| included = true; | |||
| break; | |||
| } | |||
| } | |||
| for (Iterator<String> iter = excludePatterns.iterator(); | |||
| included && iter.hasNext();) { | |||
| String pattern = iter.next(); | |||
| included = !SelectorUtils.matchPath(pattern, name); | |||
| for (String pattern : excludePatterns) { | |||
| if (SelectorUtils.matchPath(pattern, name)) { | |||
| included = false; | |||
| break; | |||
| } | |||
| } | |||
| if (!included) { | |||
| //Do not process this file | |||
| // Do not process this file | |||
| log("skipping " + entryName | |||
| + " as it is excluded or not included.", | |||
| Project.MSG_VERBOSE); | |||
| @@ -28,6 +28,8 @@ import java.net.URL; | |||
| import java.net.URLConnection; | |||
| import java.nio.file.Files; | |||
| import java.util.Date; | |||
| import java.util.LinkedHashMap; | |||
| import java.util.Map; | |||
| import java.util.zip.GZIPInputStream; | |||
| import org.apache.tools.ant.BuildException; | |||
| @@ -46,9 +48,6 @@ import org.apache.tools.ant.util.FileNameMapper; | |||
| import org.apache.tools.ant.util.FileUtils; | |||
| import org.apache.tools.ant.util.StringUtils; | |||
| import java.util.LinkedHashMap; | |||
| import java.util.Map; | |||
| /** | |||
| * Gets a particular file from a URL source. | |||
| * Options include verbose reporting, timestamp based fetches and controlling | |||
| @@ -181,13 +180,9 @@ public class Get extends Task { | |||
| public boolean doGet(final int logLevel, final DownloadProgress progress) | |||
| throws IOException { | |||
| checkAttributes(); | |||
| for (final Resource r : sources) { | |||
| final URLProvider up = r.as(URLProvider.class); | |||
| final URL source = up.getURL(); | |||
| return doGet(source, destination, logLevel, progress); | |||
| } | |||
| /*NOTREACHED*/ | |||
| return false; | |||
| return doGet(sources.iterator().next().as(URLProvider.class).getURL(), | |||
| destination, logLevel, progress); | |||
| } | |||
| /** | |||
| @@ -906,7 +906,6 @@ public class Jar extends Zip { | |||
| */ | |||
| // CheckStyle:LineLength ON | |||
| private void checkJarSpec() { | |||
| String br = System.getProperty("line.separator"); | |||
| StringBuilder message = new StringBuilder(); | |||
| Section mainSection = (configuredManifest == null) | |||
| ? null | |||
| @@ -929,9 +928,7 @@ public class Jar extends Zip { | |||
| } | |||
| if (message.length() > 0) { | |||
| message.append(br); | |||
| message.append("Location: ").append(getLocation()); | |||
| message.append(br); | |||
| message.append(String.format("%nLocation: %s%n", getLocation())); | |||
| if ("fail".equalsIgnoreCase(strict.getValue())) { | |||
| throw new BuildException(message.toString(), getLocation()); | |||
| } | |||
| @@ -834,7 +834,7 @@ public class Javac extends MatchingTask { | |||
| * @return whether or not the ant classpath is to be included in the classpath | |||
| */ | |||
| public boolean getIncludeantruntime() { | |||
| return includeAntRuntime != null ? includeAntRuntime : true; | |||
| return includeAntRuntime == null || includeAntRuntime; | |||
| } | |||
| /** | |||
| @@ -1509,10 +1509,10 @@ public class Javac extends MatchingTask { | |||
| * @return a mapping from module name to module source roots | |||
| * @since 1.9.7 | |||
| */ | |||
| private static Map<String,Collection<File>> resolveModuleSourcePathElement( | |||
| private static Map<String, Collection<File>> resolveModuleSourcePathElement( | |||
| final File projectDir, | |||
| final String element) { | |||
| final Map<String,Collection<File>> result = new TreeMap<>(); | |||
| final Map<String, Collection<File>> result = new TreeMap<>(); | |||
| for (CharSequence resolvedElement : expandGroups(element)) { | |||
| findModules(projectDir, resolvedElement.toString(), result); | |||
| } | |||
| @@ -193,12 +193,8 @@ public class Manifest { | |||
| Attribute rhsAttribute = (Attribute) rhs; | |||
| String lhsKey = getKey(); | |||
| String rhsKey = rhsAttribute.getKey(); | |||
| if ((lhsKey == null && rhsKey != null) | |||
| || (lhsKey != null && !lhsKey.equals(rhsKey))) { | |||
| return false; | |||
| } | |||
| return values.equals(rhsAttribute.values); | |||
| return (lhsKey != null || rhsKey == null) | |||
| && (lhsKey == null || lhsKey.equals(rhsKey)) && values.equals(rhsAttribute.values); | |||
| } | |||
| /** | |||
| @@ -243,10 +239,7 @@ public class Manifest { | |||
| * @return the attribute's key. | |||
| */ | |||
| public String getKey() { | |||
| if (name == null) { | |||
| return null; | |||
| } | |||
| return name.toLowerCase(Locale.ENGLISH); | |||
| return name == null ? null : name.toLowerCase(Locale.ENGLISH); | |||
| } | |||
| /** | |||
| @@ -302,8 +295,7 @@ public class Manifest { | |||
| * @param line the continuation line. | |||
| */ | |||
| public void addContinuation(String line) { | |||
| String currentValue = values.elementAt(currentIndex); | |||
| setValue(currentValue + line.substring(1)); | |||
| setValue(values.elementAt(currentIndex) + line.substring(1)); | |||
| } | |||
| /** | |||
| @@ -607,10 +599,7 @@ public class Manifest { | |||
| */ | |||
| public String getAttributeValue(String attributeName) { | |||
| Attribute attribute = getAttribute(attributeName.toLowerCase(Locale.ENGLISH)); | |||
| if (attribute == null) { | |||
| return null; | |||
| } | |||
| return attribute.getValue(); | |||
| return attribute == null ? null : attribute.getValue(); | |||
| } | |||
| /** | |||
| @@ -723,8 +712,7 @@ public class Manifest { | |||
| if (attribute == null) { | |||
| return; | |||
| } | |||
| String attributeKey = attribute.getKey(); | |||
| attributes.put(attributeKey, attribute); | |||
| attributes.put(attribute.getKey(), attribute); | |||
| } | |||
| /** | |||
| @@ -1113,11 +1101,8 @@ public class Manifest { | |||
| return false; | |||
| } | |||
| if (!mainSection.equals(rhsManifest.mainSection)) { | |||
| return false; | |||
| } | |||
| return mainSection.equals(rhsManifest.mainSection) && sections.equals(rhsManifest.sections); | |||
| return sections.equals(rhsManifest.sections); | |||
| } | |||
| /** | |||
| @@ -310,8 +310,7 @@ public class Recorder extends Task implements SubBuildListener { | |||
| Hashtable<String, RecorderEntry> entries | |||
| = (Hashtable<String, RecorderEntry>) recorderEntries.clone(); | |||
| for (Map.Entry<String, RecorderEntry> entry : entries.entrySet()) { | |||
| RecorderEntry re = entry.getValue(); | |||
| if (re.getProject() == getProject()) { | |||
| if (entry.getValue().getProject() == getProject()) { | |||
| recorderEntries.remove(entry.getKey()); | |||
| } | |||
| } | |||
| @@ -286,7 +286,7 @@ public class Replace extends MatchingTask { | |||
| * The filter expects from the component providing the input that data | |||
| * is only added by that component to the end of this StringBuffer. | |||
| * This StringBuffer will be modified by this filter, and expects that | |||
| * another component will only added to this StringBuffer. | |||
| * another component will only append to this StringBuffer. | |||
| * @param input The input for this filter. | |||
| */ | |||
| void setInputBuffer(StringBuffer input) { | |||
| @@ -775,10 +775,7 @@ public class Rmic extends MatchingTask { | |||
| try { | |||
| Class<?> testClass = loader.loadClass(classname); | |||
| // One cannot RMIC an interface for "classic" RMI (JRMP) | |||
| if (testClass.isInterface() && !iiop && !idl) { | |||
| return false; | |||
| } | |||
| return isValidRmiRemote(testClass); | |||
| return (!testClass.isInterface() || iiop || idl) && isValidRmiRemote(testClass); | |||
| } catch (ClassNotFoundException e) { | |||
| log(ERROR_UNABLE_TO_VERIFY_CLASS + classname + ERROR_NOT_FOUND, | |||
| Project.MSG_WARN); | |||
| @@ -461,9 +461,9 @@ public class Tar extends MatchingTask { | |||
| if (r instanceof TarResource) { | |||
| final TarResource tr = (TarResource) r; | |||
| te.setUserName(tr.getUserName()); | |||
| te.setUserId(tr.getUid()); | |||
| te.setUserId(tr.getLongUid()); | |||
| te.setGroupName(tr.getGroup()); | |||
| te.setGroupId(tr.getGid()); | |||
| te.setGroupId(tr.getLongGid()); | |||
| } | |||
| } | |||
| @@ -19,12 +19,10 @@ | |||
| package org.apache.tools.ant.taskdefs; | |||
| import java.io.File; | |||
| import java.util.Iterator; | |||
| import java.util.List; | |||
| import java.util.Vector; | |||
| import org.apache.tools.ant.BuildException; | |||
| import org.apache.tools.ant.DirectoryScanner; | |||
| import org.apache.tools.ant.Project; | |||
| import org.apache.tools.ant.Task; | |||
| import org.apache.tools.ant.taskdefs.condition.Condition; | |||
| @@ -205,11 +203,12 @@ public class UpToDate extends Task implements Condition { | |||
| // scan all filesets, even if we know the target is out of | |||
| // date after the first test. | |||
| Iterator<FileSet> iter = sourceFileSets.iterator(); | |||
| while (upToDate && iter.hasNext()) { | |||
| FileSet fs = iter.next(); | |||
| DirectoryScanner ds = fs.getDirectoryScanner(getProject()); | |||
| upToDate = scanDir(fs.getDir(getProject()), ds.getIncludedFiles()); | |||
| for (FileSet fs : sourceFileSets) { | |||
| if (!scanDir(fs.getDir(getProject()), | |||
| fs.getDirectoryScanner(getProject()).getIncludedFiles())) { | |||
| upToDate = false; | |||
| break; | |||
| } | |||
| } | |||
| if (upToDate) { | |||
| @@ -63,6 +63,7 @@ public abstract class DefaultCompilerAdapter | |||
| //must keep for subclass BC, though unused: | |||
| // CheckStyle:ConstantNameCheck OFF - bc | |||
| @Deprecated | |||
| protected static final String lSep = StringUtils.LINE_SEP; | |||
| // CheckStyle:ConstantNameCheck ON | |||
| @@ -696,8 +697,7 @@ public abstract class DefaultCompilerAdapter | |||
| */ | |||
| @Deprecated | |||
| protected boolean assumeJava19() { | |||
| return assumeJavaXY("javac1.9", JavaEnvUtils.JAVA_9) | |||
| || assumeJavaXY("javac9", JavaEnvUtils.JAVA_9); | |||
| return assumeJava9(); | |||
| } | |||
| /** | |||
| @@ -706,7 +706,8 @@ public abstract class DefaultCompilerAdapter | |||
| * @since Ant 1.9.8 | |||
| */ | |||
| protected boolean assumeJava9() { | |||
| return assumeJava19(); | |||
| return assumeJavaXY("javac1.9", JavaEnvUtils.JAVA_9) | |||
| || assumeJavaXY("javac9", JavaEnvUtils.JAVA_9); | |||
| } | |||
| /** | |||
| @@ -60,31 +60,26 @@ public class IsReference extends ProjectComponent implements Condition { | |||
| public boolean eval() throws BuildException { | |||
| if (ref == null) { | |||
| throw new BuildException( | |||
| "No reference specified for isreference condition"); | |||
| "No reference specified for isreference condition"); | |||
| } | |||
| String key = ref.getRefId(); | |||
| if (!getProject().hasReference(key)) { | |||
| return false; | |||
| } | |||
| if (type == null) { | |||
| return true; | |||
| } | |||
| Object o = getProject().getReference(key); | |||
| Class<?> typeClass = | |||
| getProject().getDataTypeDefinitions().get(type); | |||
| Class<?> typeClass = getProject().getDataTypeDefinitions().get(type); | |||
| if (typeClass == null) { | |||
| typeClass = | |||
| getProject().getTaskDefinitions().get(type); | |||
| typeClass = getProject().getTaskDefinitions().get(type); | |||
| } | |||
| if (typeClass == null) { | |||
| // don't know the type, should throw exception instead? | |||
| return false; | |||
| } | |||
| // if the type is unknown, throw exception instead? | |||
| return typeClass != null | |||
| && typeClass.isAssignableFrom(getProject().getReference(key).getClass()); | |||
| return typeClass.isAssignableFrom(o.getClass()); | |||
| } | |||
| } | |||
| @@ -18,6 +18,7 @@ | |||
| package org.apache.tools.ant.taskdefs.condition; | |||
| import java.io.File; | |||
| import java.util.Locale; | |||
| import org.apache.tools.ant.BuildException; | |||
| @@ -34,8 +35,7 @@ public class Os implements Condition { | |||
| System.getProperty("os.arch").toLowerCase(Locale.ENGLISH); | |||
| private static final String OS_VERSION = | |||
| System.getProperty("os.version").toLowerCase(Locale.ENGLISH); | |||
| private static final String PATH_SEP = | |||
| System.getProperty("path.separator"); | |||
| private static final String PATH_SEP = File.pathSeparator; | |||
| /** | |||
| * OS family that can be tested for. {@value} | |||
| @@ -31,6 +31,7 @@ import java.util.TimeZone; | |||
| import org.apache.tools.ant.taskdefs.AbstractCvsTask; | |||
| import org.apache.tools.ant.taskdefs.AbstractCvsTask.Module; | |||
| import org.apache.tools.ant.util.StringUtils; | |||
| /** | |||
| * A class used to parse the output of the CVS log command. | |||
| @@ -146,23 +147,22 @@ class ChangeLogParser { | |||
| * @param line the line | |||
| */ | |||
| private void processComment(final String line) { | |||
| final String lineSeparator = System.getProperty("line.separator"); | |||
| if ("=============================================================================" | |||
| .equals(line)) { | |||
| //We have ended changelog for that particular file | |||
| //so we can save it | |||
| final int end | |||
| = comment.length() - lineSeparator.length(); //was -1 | |||
| = comment.length() - StringUtils.LINE_SEP.length(); //was -1 | |||
| comment = comment.substring(0, end); | |||
| saveEntry(); | |||
| status = GET_FILE; | |||
| } else if ("----------------------------".equals(line)) { | |||
| final int end | |||
| = comment.length() - lineSeparator.length(); //was -1 | |||
| = comment.length() - StringUtils.LINE_SEP.length(); //was -1 | |||
| comment = comment.substring(0, end); | |||
| status = GET_PREVIOUS_REV; | |||
| } else { | |||
| comment += line + lineSeparator; | |||
| comment += line + StringUtils.LINE_SEP; | |||
| } | |||
| } | |||
| @@ -125,7 +125,7 @@ public class VmsCommandLauncher extends Java13CommandLauncher { | |||
| new Thread(() -> { | |||
| try { | |||
| p.waitFor(); | |||
| } catch(InterruptedException e) { | |||
| } catch (InterruptedException e) { | |||
| // ignore | |||
| } | |||
| FileUtils.delete(f); | |||
| @@ -777,9 +777,7 @@ public class NetRexxC extends MatchingTask { | |||
| log("Files to be compiled:", Project.MSG_VERBOSE); | |||
| final String eol = System.getProperty("line.separator"); | |||
| log( | |||
| compileList.stream().map(s -> " " + s).collect(Collectors.joining(eol)), | |||
| log(compileList.stream().map(s -> " " + s).collect(Collectors.joining(System.lineSeparator())), | |||
| Project.MSG_VERBOSE); | |||
| // create a single array of arguments for the compiler | |||
| @@ -924,7 +922,7 @@ public class NetRexxC extends MatchingTask { | |||
| */ | |||
| private void addExistingToClasspath(StringBuilder target, String source) { | |||
| StringTokenizer tok = new StringTokenizer(source, | |||
| System.getProperty("path.separator"), false); | |||
| File.pathSeparator, false); | |||
| while (tok.hasMoreTokens()) { | |||
| File f = getProject().resolveFile(tok.nextToken()); | |||
| @@ -43,6 +43,7 @@ import org.apache.tools.ant.types.Mapper; | |||
| * @deprecated since 1.5.x. | |||
| * Use <move> instead | |||
| */ | |||
| @Deprecated | |||
| public class RenameExtensions extends MatchingTask { | |||
| private String fromExtension = ""; | |||
| @@ -467,14 +467,9 @@ public class SchemaValidate extends XMLValidateTask { | |||
| final SchemaLocation schemaLocation = (SchemaLocation) o; | |||
| if (file != null ? !file.equals(schemaLocation.file) : schemaLocation.file != null) { | |||
| return false; | |||
| } | |||
| if (namespace != null ? !namespace.equals(schemaLocation.namespace) | |||
| : schemaLocation.namespace != null) { | |||
| return false; | |||
| } | |||
| return url != null ? url.equals(schemaLocation.url) : schemaLocation.url == null; | |||
| return (file == null ? schemaLocation.file == null : file.equals(schemaLocation.file)) | |||
| && (namespace == null ? schemaLocation.namespace == null : namespace.equals(schemaLocation.namespace)) | |||
| && (url == null ? schemaLocation.url == null : url.equals(schemaLocation.url)); | |||
| } | |||
| /** | |||
| @@ -485,9 +480,9 @@ public class SchemaValidate extends XMLValidateTask { | |||
| public int hashCode() { | |||
| int result; | |||
| // CheckStyle:MagicNumber OFF | |||
| result = (namespace != null ? namespace.hashCode() : 0); | |||
| result = 29 * result + (file != null ? file.hashCode() : 0); | |||
| result = 29 * result + (url != null ? url.hashCode() : 0); | |||
| result = (namespace == null ? 0 : namespace.hashCode()); | |||
| result = 29 * result + (file == null ? 0 : file.hashCode()); | |||
| result = 29 * result + (url == null ? 0 : url.hashCode()); | |||
| // CheckStyle:MagicNumber OFF | |||
| return result; | |||
| } | |||
| @@ -499,10 +494,9 @@ public class SchemaValidate extends XMLValidateTask { | |||
| */ | |||
| @Override | |||
| public String toString() { | |||
| String buffer = (namespace != null ? namespace : "(anonymous)") | |||
| + ' ' + (url != null ? (url + " ") : "") | |||
| + (file != null ? file.getAbsolutePath() : ""); | |||
| return buffer; | |||
| return (namespace == null ? "(anonymous)" : namespace) | |||
| + (url == null ? "" : " " + url) | |||
| + (file == null ? "" : " " + file.getAbsolutePath()); | |||
| } | |||
| } //SchemaLocation | |||
| } | |||
| } | |||
| @@ -20,11 +20,11 @@ package org.apache.tools.ant.taskdefs.optional.depend; | |||
| import java.io.File; | |||
| import java.io.IOException; | |||
| import java.io.InputStream; | |||
| import java.nio.file.Files; | |||
| import java.nio.file.Paths; | |||
| import java.util.Collections; | |||
| import java.util.HashSet; | |||
| import java.util.Set; | |||
| import java.nio.file.Files; | |||
| import java.nio.file.Paths; | |||
| import java.util.Vector; | |||
| import java.util.zip.ZipEntry; | |||
| import java.util.zip.ZipFile; | |||
| @@ -812,11 +812,7 @@ public class IPlanetEjbc { | |||
| String base = "\\ejb-jar\\enterprise-beans\\" + ejbType; | |||
| if ((base + "\\ejb-name").equals(currentLoc)) { | |||
| currentEjb = ejbs.get(value); | |||
| if (currentEjb == null) { | |||
| currentEjb = new EjbInfo(value); | |||
| ejbs.put(value, currentEjb); | |||
| } | |||
| currentEjb = ejbs.computeIfAbsent(value, EjbInfo::new); | |||
| } else if ((base + "\\home").equals(currentLoc)) { | |||
| currentEjb.setHome(value); | |||
| } else if ((base + "\\remote").equals(currentLoc)) { | |||
| @@ -846,18 +842,13 @@ public class IPlanetEjbc { | |||
| String base = "\\ias-ejb-jar\\enterprise-beans\\" + ejbType; | |||
| if ((base + "\\ejb-name").equals(currentLoc)) { | |||
| currentEjb = ejbs.get(value); | |||
| if (currentEjb == null) { | |||
| currentEjb = new EjbInfo(value); | |||
| ejbs.put(value, currentEjb); | |||
| } | |||
| currentEjb = ejbs.computeIfAbsent(value, EjbInfo::new); | |||
| } else if ((base + "\\iiop").equals(currentLoc)) { | |||
| currentEjb.setIiop(value); | |||
| } else if ((base + "\\failover-required").equals(currentLoc)) { | |||
| currentEjb.setHasession(value); | |||
| } else if ((base | |||
| + "\\persistence-manager\\properties-file-location") | |||
| .equals(currentLoc)) { | |||
| + "\\persistence-manager\\properties-file-location").equals(currentLoc)) { | |||
| currentEjb.addCmpDescriptor(value); | |||
| } | |||
| } | |||
| @@ -869,15 +860,15 @@ public class IPlanetEjbc { | |||
| * | |||
| */ | |||
| private class EjbInfo { | |||
| private String name; // EJB's display name | |||
| private Classname home; // EJB's home interface name | |||
| private Classname remote; // EJB's remote interface name | |||
| private Classname implementation; // EJB's implementation class | |||
| private Classname primaryKey; // EJB's primary key class | |||
| private String beantype = "entity"; // or "stateful" or "stateless" | |||
| private boolean cmp = false; // Does this EJB support CMP? | |||
| private boolean iiop = false; // Does this EJB support IIOP? | |||
| private boolean hasession = false; // Does this EJB require failover? | |||
| private String name; // EJB's display name | |||
| private Classname home; // EJB's home interface name | |||
| private Classname remote; // EJB's remote interface name | |||
| private Classname implementation; // EJB's implementation class | |||
| private Classname primaryKey; // EJB's primary key class | |||
| private String beantype = "entity"; // or "stateful" or "stateless" | |||
| private boolean cmp = false; // Does this EJB support CMP? | |||
| private boolean iiop = false; // Does this EJB support IIOP? | |||
| private boolean hasession = false; // Does this EJB require failover? | |||
| private List<String> cmpDescriptors = new ArrayList<>(); // CMP descriptor list | |||
| /** | |||
| @@ -389,6 +389,7 @@ public class JDependTask extends Task { | |||
| * @exception BuildException if an error occurs | |||
| */ | |||
| @Override | |||
| @SuppressWarnings("deprecated") | |||
| public void execute() throws BuildException { | |||
| CommandlineJava commandline = new CommandlineJava(); | |||
| @@ -627,6 +628,7 @@ public class JDependTask extends Task { | |||
| return new ExecuteWatchdog(getTimeout()); | |||
| } | |||
| @SuppressWarnings("deprecated") | |||
| private Optional<Path> getWorkingPath() { | |||
| Optional<Path> result = Optional.ofNullable(getClassespath()); | |||
| if (result.isPresent()) { | |||
| @@ -129,8 +129,7 @@ public class ClassNameReader { | |||
| /* int accessFlags = */ data.readUnsignedShort(); | |||
| int classIndex = data.readUnsignedShort(); | |||
| Integer stringIndex = (Integer) values[classIndex]; | |||
| String className = (String) values[stringIndex]; | |||
| return className; | |||
| return (String) values[stringIndex]; | |||
| } | |||
| } | |||
| @@ -35,8 +35,6 @@ import org.apache.tools.ant.types.CommandlineJava; | |||
| public abstract class DefaultJspCompilerAdapter | |||
| implements JspCompilerAdapter { | |||
| private static String lSep = System.lineSeparator(); | |||
| /** | |||
| * Logs the compilation parameters, adds the files to compile and logs the | |||
| * "niceSourceList" | |||
| @@ -50,13 +48,12 @@ public abstract class DefaultJspCompilerAdapter | |||
| jspc.log("Compilation " + cmd.describeJavaCommand(), | |||
| Project.MSG_VERBOSE); | |||
| String niceSourceList = (compileList.size() == 1 ? "File" : "Files") + | |||
| " to be compiled:" + lSep + | |||
| compileList.stream() | |||
| String niceSourceList = compileList.stream() | |||
| .peek(arg -> cmd.createArgument().setValue(arg)) | |||
| .map(arg -> " " + arg) | |||
| .collect(Collectors.joining(lSep)); | |||
| jspc.log(niceSourceList, Project.MSG_VERBOSE); | |||
| .collect(Collectors.joining(System.lineSeparator())); | |||
| jspc.log(String.format("File%s to be compiled:%n%s", | |||
| compileList.size() == 1 ? "" : "s", niceSourceList), Project.MSG_VERBOSE); | |||
| } | |||
| // CheckStyle:VisibilityModifier OFF - bc | |||
| @@ -133,8 +133,6 @@ import org.apache.tools.ant.util.StringUtils; | |||
| */ | |||
| public class JUnitTask extends Task { | |||
| private static final String LINE_SEP | |||
| = System.getProperty("line.separator"); | |||
| private static final String CLASSPATH = "CLASSPATH"; | |||
| private static final int STRING_BUFFER_SIZE = 128; | |||
| @@ -1381,11 +1379,10 @@ public class JUnitTask extends Task { | |||
| e.hasMoreElements();) { | |||
| final URL current = e.nextElement(); | |||
| if (previous != null && !urlEquals(current, previous)) { | |||
| log("WARNING: multiple versions of ant detected " | |||
| + "in path for junit " | |||
| + LINE_SEP + " " + previous | |||
| + LINE_SEP + " and " + current, | |||
| Project.MSG_WARN); | |||
| log(String.format( | |||
| "WARNING: multiple versions of ant detected in path for junit%n" | |||
| + " %s%n and %s", previous, current), | |||
| Project.MSG_WARN); | |||
| return; | |||
| } | |||
| previous = current; | |||
| @@ -1429,10 +1426,8 @@ public class JUnitTask extends Task { | |||
| * @return created file | |||
| */ | |||
| private File createTempPropertiesFile(final String prefix) { | |||
| final File propsFile = | |||
| FILE_UTILS.createTempFile(prefix, ".properties", | |||
| tmpDir != null ? tmpDir : getProject().getBaseDir(), true, true); | |||
| return propsFile; | |||
| return FILE_UTILS.createTempFile(prefix, ".properties", | |||
| tmpDir != null ? tmpDir : getProject().getBaseDir(), true, true); | |||
| } | |||
| @@ -1701,8 +1696,8 @@ public class JUnitTask extends Task { | |||
| * @since 1.9.8 | |||
| */ | |||
| private void checkModules() { | |||
| if (hasPath(getCommandline().getModulepath()) || | |||
| hasPath(getCommandline().getUpgrademodulepath())) { | |||
| if (hasPath(getCommandline().getModulepath()) | |||
| || hasPath(getCommandline().getUpgrademodulepath())) { | |||
| if (!batchTests.stream().allMatch(BaseTest::getFork) | |||
| || !tests.stream().allMatch(BaseTest::getFork)) { | |||
| throw new BuildException( | |||
| @@ -77,7 +77,6 @@ public class SummaryJUnitResultFormatter | |||
| */ | |||
| @Override | |||
| public void startTestSuite(JUnitTest suite) { | |||
| String newLine = System.getProperty("line.separator"); | |||
| StringBuilder sb = new StringBuilder("Running "); | |||
| int antThreadID = suite.getThread(); | |||
| @@ -87,7 +86,7 @@ public class SummaryJUnitResultFormatter | |||
| sb.append(" in thread "); | |||
| sb.append(antThreadID); | |||
| } | |||
| sb.append(newLine); | |||
| sb.append(System.lineSeparator()); | |||
| writeOutputLine(sb.toString().getBytes()); | |||
| } | |||
| /** | |||
| @@ -166,8 +165,7 @@ public class SummaryJUnitResultFormatter | |||
| */ | |||
| @Override | |||
| public void endTestSuite(JUnitTest suite) throws BuildException { | |||
| String newLine = System.getProperty("line.separator"); | |||
| StringBuilder sb = new StringBuilder("Tests run: "); | |||
| StringBuilder sb = new StringBuilder("Tests run: "); | |||
| sb.append(suite.runCount()); | |||
| sb.append(", Failures: "); | |||
| sb.append(suite.failureCount()); | |||
| @@ -189,17 +187,15 @@ public class SummaryJUnitResultFormatter | |||
| sb.append(", Class: "); | |||
| sb.append(suite.getName()); | |||
| } | |||
| sb.append(newLine); | |||
| sb.append(System.lineSeparator()); | |||
| if (withOutAndErr) { | |||
| if (systemOutput != null && systemOutput.length() > 0) { | |||
| sb.append("Output:").append(newLine).append(systemOutput) | |||
| .append(newLine); | |||
| sb.append(String.format("Output:%n%s%n", systemOutput)); | |||
| } | |||
| if (systemError != null && systemError.length() > 0) { | |||
| sb.append("Error: ").append(newLine).append(systemError) | |||
| .append(newLine); | |||
| sb.append(String.format("Output:%n%s%n", systemError)); | |||
| } | |||
| } | |||
| @@ -28,8 +28,6 @@ import java.util.Optional; | |||
| */ | |||
| abstract class AbstractJUnitResultFormatter implements TestResultFormatter { | |||
| protected static String NEW_LINE = System.getProperty("line.separator"); | |||
| protected TestExecutionContext context; | |||
| private SysOutErrContentStore sysOutStore; | |||
| @@ -44,7 +42,6 @@ abstract class AbstractJUnitResultFormatter implements TestResultFormatter { | |||
| this.sysOutStore.store(data); | |||
| } catch (IOException e) { | |||
| handleException(e); | |||
| return; | |||
| } | |||
| } | |||
| @@ -57,7 +54,6 @@ abstract class AbstractJUnitResultFormatter implements TestResultFormatter { | |||
| this.sysErrStore.store(data); | |||
| } catch (IOException e) { | |||
| handleException(e); | |||
| return; | |||
| } | |||
| } | |||
| @@ -394,7 +394,6 @@ public class JUnitLauncherTask extends Task { | |||
| } catch (IOException e) { | |||
| task.log("Failed while streaming " + (this.streamType == StreamType.SYS_OUT ? "sysout" : "syserr") + " data", | |||
| e, Project.MSG_INFO); | |||
| return; | |||
| } finally { | |||
| streamContentDeliver.stop = true; | |||
| // just "wakeup" the delivery thread, to take into account | |||
| @@ -500,7 +499,6 @@ public class JUnitLauncherTask extends Task { | |||
| closeAndWait(sysErr); | |||
| } catch (InterruptedException e) { | |||
| Thread.currentThread().interrupt(); | |||
| return; | |||
| } | |||
| } | |||
| } | |||
| @@ -99,7 +99,6 @@ class LegacyPlainResultFormatter extends AbstractJUnitResultFormatter implements | |||
| } | |||
| } catch (IOException ioe) { | |||
| handleException(ioe); | |||
| return; | |||
| } | |||
| } | |||
| @@ -258,8 +257,7 @@ class LegacyPlainResultFormatter extends AbstractJUnitResultFormatter implements | |||
| return; | |||
| } | |||
| final Throwable throwable = result.getThrowable().get(); | |||
| sb.append(": ").append(throwable.getMessage()); | |||
| sb.append(NEW_LINE); | |||
| sb.append(String.format(": %s%n", throwable.getMessage())); | |||
| final StringWriter stacktrace = new StringWriter(); | |||
| throwable.printStackTrace(new PrintWriter(stacktrace)); | |||
| sb.append(stacktrace.toString()); | |||
| @@ -61,7 +61,6 @@ class LegacyXmlResultFormatter extends AbstractJUnitResultFormatter implements T | |||
| new XMLReportWriter().write(); | |||
| } catch (IOException | XMLStreamException e) { | |||
| handleException(e); | |||
| return; | |||
| } | |||
| } | |||
| @@ -60,11 +60,11 @@ public class BuiltinNative2Ascii implements Native2AsciiAdapter { | |||
| private BufferedReader getReader(File srcFile, String encoding, | |||
| boolean reverse) throws IOException { | |||
| if (!reverse && encoding != null) { | |||
| return new BufferedReader(new InputStreamReader( | |||
| Files.newInputStream(srcFile.toPath()), encoding)); | |||
| if (reverse || encoding == null) { | |||
| return new BufferedReader(new FileReader(srcFile)); | |||
| } | |||
| return new BufferedReader(new FileReader(srcFile)); | |||
| return new BufferedReader(new InputStreamReader( | |||
| Files.newInputStream(srcFile.toPath()), encoding)); | |||
| } | |||
| private Writer getWriter(File destFile, String encoding, | |||
| @@ -72,12 +72,12 @@ public class BuiltinNative2Ascii implements Native2AsciiAdapter { | |||
| if (!reverse) { | |||
| encoding = "ASCII"; | |||
| } | |||
| if (encoding != null) { | |||
| return new BufferedWriter( | |||
| new OutputStreamWriter(Files.newOutputStream(destFile.toPath()), | |||
| encoding)); | |||
| if (encoding == null) { | |||
| return new BufferedWriter(new FileWriter(destFile)); | |||
| } | |||
| return new BufferedWriter(new FileWriter(destFile)); | |||
| return new BufferedWriter( | |||
| new OutputStreamWriter(Files.newOutputStream(destFile.toPath()), | |||
| encoding)); | |||
| } | |||
| private void translate(BufferedReader input, Writer output, | |||
| @@ -1202,13 +1202,7 @@ public class FTP extends Task implements FTPTaskConfig { | |||
| * @since ant 1.6 | |||
| */ | |||
| private boolean isFunctioningAsFile(FTPClient ftp, String dir, FTPFile file) { | |||
| if (file.isDirectory()) { | |||
| return false; | |||
| } | |||
| if (file.isFile()) { | |||
| return true; | |||
| } | |||
| return !isFunctioningAsDirectory(ftp, dir, file); | |||
| return !file.isDirectory() && (file.isFile() || !isFunctioningAsDirectory(ftp, dir, file)); | |||
| } | |||
| /** | |||
| @@ -1901,8 +1895,7 @@ public class FTP extends Task implements FTPTaskConfig { | |||
| * @return the filename as it will appear on the server. | |||
| */ | |||
| protected String resolveFile(String file) { | |||
| return file.replace(System.getProperty("file.separator").charAt(0), | |||
| remoteFileSep.charAt(0)); | |||
| return file.replace(File.separator.charAt(0), remoteFileSep.charAt(0)); | |||
| } | |||
| /** | |||
| @@ -1280,8 +1280,7 @@ public class FTPTaskMirrorImpl implements FTPTaskMirror { | |||
| * @return the filename as it will appear on the server. | |||
| */ | |||
| protected String resolveFile(String file) { | |||
| return file.replace(System.getProperty("file.separator").charAt(0), | |||
| task.getSeparator().charAt(0)); | |||
| return file.replace(File.separator.charAt(0), task.getSeparator().charAt(0)); | |||
| } | |||
| /** | |||
| @@ -218,7 +218,7 @@ public class SSHExec extends SSHBase { | |||
| * will be stored. | |||
| * @since Apache Ant 1.9.4 | |||
| */ | |||
| public void setErrorproperty (final String property) { | |||
| public void setErrorproperty(final String property) { | |||
| errorProperty = property; | |||
| } | |||
| @@ -319,9 +319,7 @@ public class ScpFromMessage extends AbstractSshMessage { | |||
| throw new JSchException("failed to stat remote file", e); | |||
| } | |||
| FileUtils.getFileUtils().setFileLastModified(localFile, | |||
| ((long) fileAttributes | |||
| .getMTime()) | |||
| * 1000); | |||
| ((long) fileAttributes.getMTime()) * 1000); | |||
| } | |||
| /** | |||
| @@ -132,7 +132,7 @@ public class ScpFromMessageBySftp extends ScpFromMessage { | |||
| private void getDir(final ChannelSftp channel, | |||
| final String remoteFile, | |||
| final File localFile) throws IOException, SftpException { | |||
| final File localFile) throws SftpException { | |||
| String pwd = remoteFile; | |||
| if (remoteFile.lastIndexOf('/') != -1) { | |||
| if (remoteFile.length() > 1) { | |||
| @@ -196,9 +196,7 @@ public class ScpFromMessageBySftp extends ScpFromMessage { | |||
| } | |||
| if (getPreserveLastModified()) { | |||
| FileUtils.getFileUtils().setFileLastModified(localFile, | |||
| ((long) le.getAttrs() | |||
| .getMTime()) | |||
| * 1000); | |||
| ((long) le.getAttrs().getMTime()) * 1000); | |||
| } | |||
| } | |||
| } | |||
| @@ -592,7 +592,7 @@ public abstract class AbstractFileSet extends DataType | |||
| return getRef(getProject()).hasSelectors(); | |||
| } | |||
| dieOnCircularReference(); | |||
| return !(selectors.isEmpty()); | |||
| return !selectors.isEmpty(); | |||
| } | |||
| /** | |||
| @@ -605,10 +605,8 @@ public abstract class AbstractFileSet extends DataType | |||
| return getRef(getProject()).hasPatterns(); | |||
| } | |||
| dieOnCircularReference(); | |||
| if (defaultPatterns.hasPatterns(getProject())) { | |||
| return true; | |||
| } | |||
| return additionalPatterns.stream().anyMatch(ps -> ps.hasPatterns(getProject())); | |||
| return defaultPatterns.hasPatterns(getProject()) | |||
| || additionalPatterns.stream().anyMatch(ps -> ps.hasPatterns(getProject())); | |||
| } | |||
| /** | |||
| @@ -30,7 +30,6 @@ import java.util.stream.Stream; | |||
| import org.apache.tools.ant.BuildException; | |||
| import org.apache.tools.ant.ProjectComponent; | |||
| import org.apache.tools.ant.taskdefs.condition.Os; | |||
| import org.apache.tools.ant.util.StringUtils; | |||
| /** | |||
| * Commandline objects help handling command lines specifying processes to | |||
| @@ -66,12 +65,8 @@ public class Commandline implements Cloneable { | |||
| */ | |||
| private String executable = null; | |||
| protected static final String DISCLAIMER = | |||
| StringUtils.LINE_SEP | |||
| + "The \' characters around the executable and arguments are" | |||
| + StringUtils.LINE_SEP | |||
| + "not part of the command." | |||
| + StringUtils.LINE_SEP; | |||
| protected static final String DISCLAIMER = String.format( | |||
| "%nThe ' characters around the executable and arguments are%nnot part of the command.%n"); | |||
| /** | |||
| * Create a command line from a string. | |||
| @@ -676,14 +671,10 @@ public class Commandline implements Cloneable { | |||
| if (args == null || args.length <= offset) { | |||
| return ""; | |||
| } | |||
| StringBuilder buf = new StringBuilder("argument"); | |||
| if (args.length > offset) { | |||
| buf.append("s"); | |||
| } | |||
| buf.append(":").append(StringUtils.LINE_SEP); | |||
| StringBuilder buf = new StringBuilder(); | |||
| buf.append(String.format("argument%s:%n", args.length > offset ? "s" : "")); | |||
| for (int i = offset; i < args.length; i++) { | |||
| buf.append("\'").append(args[i]).append("\'") | |||
| .append(StringUtils.LINE_SEP); | |||
| buf.append(String.format("\'%s\'%n", args[i])); | |||
| } | |||
| buf.append(DISCLAIMER); | |||
| return buf.toString(); | |||
| @@ -18,7 +18,6 @@ | |||
| package org.apache.tools.ant.types; | |||
| import java.util.Enumeration; | |||
| import java.util.LinkedList; | |||
| import java.util.List; | |||
| import java.util.ListIterator; | |||
| @@ -113,11 +112,8 @@ public class CommandlineJava implements Cloneable { | |||
| } | |||
| } | |||
| Properties propertySetProperties = mergePropertySets(); | |||
| for (Enumeration<?> e = propertySetProperties.keys(); | |||
| e.hasMoreElements();) { | |||
| String key = (String) e.nextElement(); | |||
| String value = propertySetProperties.getProperty(key); | |||
| listIt.add("-D" + key + "=" + value); | |||
| for (String key : propertySetProperties.stringPropertyNames()) { | |||
| listIt.add("-D" + key + "=" + propertySetProperties.getProperty(key)); | |||
| } | |||
| } | |||
| @@ -140,10 +136,9 @@ public class CommandlineJava implements Cloneable { | |||
| try { | |||
| sys = System.getProperties(); | |||
| Properties p = new Properties(); | |||
| for (Enumeration<?> e = sys.propertyNames(); e.hasMoreElements();) { | |||
| String name = (String) e.nextElement(); | |||
| for (String name : sys.stringPropertyNames()) { | |||
| String value = sys.getProperty(name); | |||
| if (name != null && value != null) { | |||
| if (value != null) { | |||
| p.put(name, value); | |||
| } | |||
| } | |||
| @@ -568,8 +568,7 @@ public class PropertySet extends DataType implements ResourceCollection { | |||
| pushAndInvokeCircularReferenceCheck(mapper, stk, p); | |||
| } | |||
| for (PropertySet propertySet : setRefs) { | |||
| pushAndInvokeCircularReferenceCheck(propertySet, stk, | |||
| p); | |||
| pushAndInvokeCircularReferenceCheck(propertySet, stk, p); | |||
| } | |||
| setChecked(true); | |||
| } | |||
| @@ -120,10 +120,7 @@ public class PropertyResource extends Resource { | |||
| */ | |||
| @Override | |||
| public boolean equals(Object o) { | |||
| if (super.equals(o)) { | |||
| return true; | |||
| } | |||
| return isReferenceOrProxy() && getReferencedOrProxied().equals(o); | |||
| return super.equals(o) || isReferenceOrProxy() && getReferencedOrProxied().equals(o); | |||
| } | |||
| /** | |||
| @@ -37,8 +37,8 @@ public class TarResource extends ArchiveResource { | |||
| private String userName = ""; | |||
| private String groupName = ""; | |||
| private int uid; | |||
| private int gid; | |||
| private long uid; | |||
| private long gid; | |||
| /** | |||
| * Default constructor. | |||
| @@ -134,26 +134,44 @@ public class TarResource extends ArchiveResource { | |||
| /** | |||
| * @return the uid for the tar entry | |||
| * @since 1.10.4 | |||
| */ | |||
| public int getUid() { | |||
| public long getLongUid() { | |||
| if (isReference()) { | |||
| return getCheckedRef().getUid(); | |||
| return getCheckedRef().getLongUid(); | |||
| } | |||
| checkEntry(); | |||
| return uid; | |||
| } | |||
| /** | |||
| * @return the uid for the tar entry | |||
| */ | |||
| @Deprecated | |||
| public int getUid() { | |||
| return (int) getLongUid(); | |||
| } | |||
| /** | |||
| * @return the gid for the tar entry | |||
| * @since 1.10.4 | |||
| */ | |||
| public int getGid() { | |||
| public long getLongGid() { | |||
| if (isReference()) { | |||
| return getCheckedRef().getGid(); | |||
| return getCheckedRef().getLongGid(); | |||
| } | |||
| checkEntry(); | |||
| return gid; | |||
| } | |||
| /** | |||
| * @return the uid for the tar entry | |||
| */ | |||
| @Deprecated | |||
| public int getGid() { | |||
| return (int) getLongGid(); | |||
| } | |||
| /** | |||
| * fetches information from the named entry inside the archive. | |||
| */ | |||
| @@ -194,8 +212,8 @@ public class TarResource extends ArchiveResource { | |||
| setMode(e.getMode()); | |||
| userName = e.getUserName(); | |||
| groupName = e.getGroupName(); | |||
| uid = e.getUserId(); | |||
| gid = e.getGroupId(); | |||
| uid = e.getLongUserId(); | |||
| gid = e.getLongGroupId(); | |||
| } | |||
| } | |||
| @@ -310,10 +310,10 @@ public class URLResource extends Resource implements URLProvider { | |||
| if (another == null || another.getClass() != getClass()) { | |||
| return false; | |||
| } | |||
| URLResource otheru = (URLResource) another; | |||
| URLResource other = (URLResource) another; | |||
| return getURL() == null | |||
| ? otheru.getURL() == null | |||
| : getURL().equals(otheru.getURL()); | |||
| ? other.getURL() == null | |||
| : getURL().equals(other.getURL()); | |||
| } | |||
| /** | |||
| @@ -53,10 +53,7 @@ public abstract class ResourceComparator extends DataType implements Comparator< | |||
| if (isReference()) { | |||
| return getCheckedRef().equals(o); | |||
| } | |||
| if (o == null) { | |||
| return false; | |||
| } | |||
| return o == this || o.getClass().equals(getClass()); | |||
| return o != null && (o == this || o.getClass().equals(getClass())); | |||
| } | |||
| /** | |||
| @@ -154,6 +154,8 @@ public final class SelectorUtils { | |||
| } | |||
| // Fail if string is not exhausted or pattern is exhausted | |||
| // Otherwise the pattern now holds ** while string is not exhausted | |||
| // this will generate false positives but we can live with that. | |||
| return strIdxStart > strIdxEnd || patIdxStart <= patIdxEnd; | |||
| } | |||
| @@ -151,8 +151,6 @@ public class DOMElementWriter { | |||
| this.namespacePolicy = namespacePolicy; | |||
| } | |||
| private static String lSep = System.getProperty("line.separator"); | |||
| // CheckStyle:VisibilityModifier OFF - bc | |||
| /** | |||
| * Don't try to be too smart but at least recognize the predefined | |||
| @@ -219,7 +217,7 @@ public class DOMElementWriter { | |||
| case Node.ELEMENT_NODE: | |||
| hasChildElements = true; | |||
| if (i == 0) { | |||
| out.write(lSep); | |||
| out.write(StringUtils.LINE_SEP); | |||
| } | |||
| write((Element) child, out, indent + 1, indentWith); | |||
| break; | |||
| @@ -367,7 +365,7 @@ public class DOMElementWriter { | |||
| } else { | |||
| removeNSDefinitions(element); | |||
| out.write(" />"); | |||
| out.write(lSep); | |||
| out.write(StringUtils.LINE_SEP); | |||
| out.flush(); | |||
| } | |||
| } | |||
| @@ -408,7 +406,7 @@ public class DOMElementWriter { | |||
| } | |||
| out.write(element.getTagName()); | |||
| out.write(">"); | |||
| out.write(lSep); | |||
| out.write(StringUtils.LINE_SEP); | |||
| out.flush(); | |||
| } | |||
| @@ -434,10 +432,8 @@ public class DOMElementWriter { | |||
| } | |||
| private String encode(final String value, final boolean encodeWhitespace) { | |||
| final int len = value.length(); | |||
| final StringBuilder sb = new StringBuilder(len); | |||
| for (int i = 0; i < len; i++) { | |||
| final char c = value.charAt(i); | |||
| final StringBuilder sb = new StringBuilder(value.length()); | |||
| for (final char c : value.toCharArray()) { | |||
| switch (c) { | |||
| case '<': | |||
| sb.append("<"); | |||
| @@ -522,13 +518,12 @@ public class DOMElementWriter { | |||
| while (prevEnd < len) { | |||
| final int end = (cdataEndPos < 0 ? len : cdataEndPos); | |||
| // Write out stretches of legal characters in the range [prevEnd, end). | |||
| for (int prevLegalCharPos = prevEnd; prevLegalCharPos < end;/*empty*/) { | |||
| int illegalCharPos; | |||
| for (illegalCharPos = prevLegalCharPos; true; ++illegalCharPos) { | |||
| if (illegalCharPos >= end | |||
| || !isLegalCharacter(value.charAt(illegalCharPos))) { | |||
| break; | |||
| } | |||
| int prevLegalCharPos = prevEnd; | |||
| while (prevLegalCharPos < end) { | |||
| int illegalCharPos = prevLegalCharPos; | |||
| while (illegalCharPos < end | |||
| && isLegalCharacter(value.charAt(illegalCharPos))) { | |||
| ++illegalCharPos; | |||
| } | |||
| out.write(value, prevLegalCharPos, illegalCharPos - prevLegalCharPos); | |||
| prevLegalCharPos = illegalCharPos + 1; | |||
| @@ -318,12 +318,12 @@ public final class DateUtils { | |||
| } | |||
| } | |||
| final private static ThreadLocal<DateFormat> iso8601WithTimeZone = | |||
| private static final ThreadLocal<DateFormat> iso8601WithTimeZone = | |||
| ThreadLocal.withInitial(() -> { | |||
| // An arbitrary easy-to-read format to normalize to. | |||
| return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS Z"); | |||
| }); | |||
| final private static Pattern iso8601normalizer = Pattern.compile( | |||
| private static final Pattern iso8601normalizer = Pattern.compile( | |||
| "^(\\d{4,}-\\d{2}-\\d{2})[Tt ]" + // yyyy-MM-dd | |||
| "(\\d{2}:\\d{2}(:\\d{2}(\\.\\d{3})?)?) ?" + // HH:mm:ss.SSS | |||
| "(?:Z|([+-]\\d{2})(?::?(\\d{2}))?)?$"); // Z | |||
| @@ -1615,7 +1615,6 @@ public class FileUtils { | |||
| if (0 < toPathStack.length && 0 < fromPathStack.length) { | |||
| if (!fromPathStack[0].equals(toPathStack[0])) { | |||
| // not the same device (would be "" on Linux/Unix) | |||
| return getPath(Arrays.asList(toPathStack)); | |||
| } | |||
| } else { | |||
| @@ -1623,14 +1622,11 @@ public class FileUtils { | |||
| return getPath(Arrays.asList(toPathStack)); | |||
| } | |||
| int minLength = Math.min(fromPathStack.length, toPathStack.length); | |||
| int same = 1; // Used outside the for loop | |||
| // get index of parts which are equal | |||
| for (; | |||
| same < minLength && fromPathStack[same].equals(toPathStack[same]); | |||
| same++) { | |||
| // Do nothing | |||
| int minLength = Math.min(fromPathStack.length, toPathStack.length); | |||
| int same = 1; | |||
| while (same < minLength && fromPathStack[same].equals(toPathStack[same])) { | |||
| same++; | |||
| } | |||
| List<String> relativePathStack = new ArrayList<>(); | |||
| @@ -279,6 +279,7 @@ public final class JavaEnvUtils { | |||
| * @return true if the version of Java is the same as the given version. | |||
| * @since Ant 1.5 | |||
| */ | |||
| @SuppressWarnings("deprecated") | |||
| public static boolean isJavaVersion(String version) { | |||
| return javaVersion.equals(version) | |||
| || (javaVersion.equals(JAVA_9) && JAVA_1_9.equals(version)); | |||
| @@ -338,7 +338,7 @@ public class LayoutPreservingProperties extends Properties { | |||
| s = "\n" + s; | |||
| } else { | |||
| // could be a comment, if first non-whitespace is a # or ! | |||
| comment = s.matches("^( |\t|\f)*(#|!).*"); | |||
| comment = s.matches("^([ \t\f])*([#!]).*"); | |||
| } | |||
| // continuation if not a comment and the line ends is an | |||
| @@ -29,7 +29,7 @@ import java.util.Hashtable; | |||
| * @since Ant 1.6 | |||
| */ | |||
| @Deprecated | |||
| public class LazyHashtable extends Hashtable { | |||
| public class LazyHashtable<K, V> extends Hashtable<K, V> { | |||
| // CheckStyle:VisibilityModifier OFF - bc | |||
| protected boolean initAllDone = false; | |||
| // CheckStyle:VisibilityModifier OFF - bc | |||
| @@ -55,7 +55,7 @@ public class LazyHashtable extends Hashtable { | |||
| * Get a enumeration over the elements. | |||
| * @return an enumeration. | |||
| */ | |||
| public Enumeration elements() { | |||
| public Enumeration<V> elements() { | |||
| initAll(); | |||
| return super.elements(); | |||
| } | |||
| @@ -111,7 +111,7 @@ public class LazyHashtable extends Hashtable { | |||
| * Get an enumeration over the keys. | |||
| * @return an enumeration. | |||
| */ | |||
| public Enumeration keys() { | |||
| public Enumeration<K> keys() { | |||
| initAll(); | |||
| return super.keys(); | |||
| } | |||
| @@ -34,11 +34,6 @@ public class LineOrientedOutputStreamRedirector | |||
| private OutputStream stream; | |||
| // these should be in the ASCII range and hopefully are single bytes | |||
| // (for LF and CR respectively) for any encoding thrown at this class | |||
| private static final byte[] EOL = | |||
| System.getProperty("line.separator").getBytes(); | |||
| public LineOrientedOutputStreamRedirector(OutputStream stream) { | |||
| this.stream = stream; | |||
| } | |||
| @@ -46,12 +41,12 @@ public class LineOrientedOutputStreamRedirector | |||
| @Override | |||
| protected void processLine(byte[] b) throws IOException { | |||
| stream.write(b); | |||
| stream.write(EOL); | |||
| stream.write(System.lineSeparator().getBytes()); | |||
| } | |||
| @Override | |||
| protected void processLine(String line) throws IOException { | |||
| stream.write((line + System.getProperty("line.separator")).getBytes()); | |||
| stream.write(String.format("%s%n", line).getBytes()); | |||
| } | |||
| @Override | |||
| @@ -796,14 +796,9 @@ public class ResourceUtils { | |||
| return false; | |||
| } | |||
| final FileProvider fileResource1 = resource1.as(FileProvider.class); | |||
| if (fileResource1 == null) { | |||
| return false; | |||
| } | |||
| final FileProvider fileResource2 = resource2.as(FileProvider.class); | |||
| if (fileResource2 == null) { | |||
| return false; | |||
| } | |||
| return FileUtils.getFileUtils().areSame(fileResource1.getFile(), fileResource2.getFile()); | |||
| return fileResource1 != null && fileResource2 != null | |||
| && FileUtils.getFileUtils().areSame(fileResource1.getFile(), fileResource2.getFile()); | |||
| } | |||
| private static void log(final Project project, final String message) { | |||
| @@ -45,7 +45,7 @@ public final class StringUtils { | |||
| } | |||
| /** the line separator for this OS */ | |||
| public static final String LINE_SEP = System.getProperty("line.separator"); | |||
| public static final String LINE_SEP = System.lineSeparator(); | |||
| /** | |||
| * Splits up a string into a list of lines. It is equivalent | |||
| @@ -61,9 +61,8 @@ public class Jdk14RegexpMatcher implements RegexpMatcher { | |||
| */ | |||
| protected Pattern getCompiledPattern(int options) | |||
| throws BuildException { | |||
| int cOptions = getCompilerOptions(options); | |||
| try { | |||
| return Pattern.compile(this.pattern, cOptions); | |||
| return Pattern.compile(this.pattern, getCompilerOptions(options)); | |||
| } catch (PatternSyntaxException e) { | |||
| throw new BuildException(e); | |||
| } | |||
| @@ -729,10 +729,8 @@ class BlockSort { | |||
| } | |||
| break; | |||
| } // while x > 0 | |||
| else { | |||
| if ((block[i1] & 0xff) <= (block[i2] & 0xff)) { | |||
| break; | |||
| } | |||
| else if ((block[i1] & 0xff) <= (block[i2] & 0xff)) { | |||
| break; | |||
| } | |||
| } else if ((block[i1 + 5] & 0xff) <= (block[i2 + 5] & 0xff)) { | |||
| break; | |||
| @@ -74,7 +74,7 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants { | |||
| private int currentChar = -1; | |||
| private static final int EOF = 0; | |||
| private static final int EOF = 0; | |||
| private static final int START_BLOCK_STATE = 1; | |||
| private static final int RAND_PART_A_STATE = 2; | |||
| private static final int RAND_PART_B_STATE = 3; | |||
| @@ -85,8 +85,10 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants { | |||
| private int currentState = START_BLOCK_STATE; | |||
| private int storedBlockCRC, storedCombinedCRC; | |||
| private int computedBlockCRC, computedCombinedCRC; | |||
| private int storedBlockCRC; | |||
| private int storedCombinedCRC; | |||
| private int computedBlockCRC; | |||
| private int computedCombinedCRC; | |||
| // Variables used by setup* methods exclusively | |||
| @@ -343,10 +343,7 @@ public class TarEntry implements TarConstants { | |||
| */ | |||
| @Override | |||
| public boolean equals(Object it) { | |||
| if (it == null || getClass() != it.getClass()) { | |||
| return false; | |||
| } | |||
| return equals((TarEntry) it); | |||
| return it != null && getClass() == it.getClass() && equals((TarEntry) it); | |||
| } | |||
| /** | |||
| @@ -425,7 +422,7 @@ public class TarEntry implements TarConstants { | |||
| */ | |||
| @Deprecated | |||
| public int getUserId() { | |||
| return (int) (userId & 0xffffffff); | |||
| return (int) userId; | |||
| } | |||
| /** | |||
| @@ -466,7 +463,7 @@ public class TarEntry implements TarConstants { | |||
| */ | |||
| @Deprecated | |||
| public int getGroupId() { | |||
| return (int) (groupId & 0xffffffff); | |||
| return (int) groupId; | |||
| } | |||
| /** | |||
| @@ -753,13 +750,8 @@ public class TarEntry implements TarConstants { | |||
| * @return <i>true</i> if it is a 'normal' file | |||
| */ | |||
| public boolean isFile() { | |||
| if (file != null) { | |||
| return file.isFile(); | |||
| } | |||
| if (linkFlag == LF_OLDNORM || linkFlag == LF_NORMAL) { | |||
| return true; | |||
| } | |||
| return !getName().endsWith("/"); | |||
| return file != null ? file.isFile() | |||
| : linkFlag == LF_OLDNORM || linkFlag == LF_NORMAL || !getName().endsWith("/"); | |||
| } | |||
| /** | |||
| @@ -207,10 +207,8 @@ public final class ZipEightByteInteger { | |||
| */ | |||
| @Override | |||
| public boolean equals(Object o) { | |||
| if (o instanceof ZipEightByteInteger) { | |||
| return value.equals(((ZipEightByteInteger) o).getValue()); | |||
| } | |||
| return false; | |||
| return o instanceof ZipEightByteInteger | |||
| && value.equals(((ZipEightByteInteger) o).getValue()); | |||
| } | |||
| /** | |||
| @@ -168,10 +168,7 @@ public final class ZipLong implements Cloneable { | |||
| */ | |||
| @Override | |||
| public boolean equals(Object o) { | |||
| if (o instanceof ZipLong) { | |||
| return value == ((ZipLong) o).getValue(); | |||
| } | |||
| return false; | |||
| return o instanceof ZipLong && value == ((ZipLong) o).getValue(); | |||
| } | |||
| /** | |||
| @@ -133,10 +133,7 @@ public final class ZipShort implements Cloneable { | |||
| */ | |||
| @Override | |||
| public boolean equals(Object o) { | |||
| if (o instanceof ZipShort) { | |||
| return value == ((ZipShort) o).getValue(); | |||
| } | |||
| return false; | |||
| return o instanceof ZipShort && value == ((ZipShort) o).getValue(); | |||
| } | |||
| /** | |||
| @@ -39,7 +39,7 @@ public class DispatchTaskTest { | |||
| try { | |||
| buildRule.executeTarget("disp"); | |||
| fail("BuildException should have been thrown"); | |||
| } catch(BuildException ex) { | |||
| } catch (BuildException ex) { | |||
| //FIXME the previous method used here ignored the build exception - what are we trying to test | |||
| } | |||
| } | |||
| @@ -259,12 +259,12 @@ public class IntrospectionHelperTest { | |||
| } | |||
| private void assertElemMethod(String elemName, String methodName, | |||
| Class returnType, Class methodArg) { | |||
| Class<?> returnType, Class<?> methodArg) { | |||
| Method m = ih.getElementMethod(elemName); | |||
| assertEquals("Method name", methodName, m.getName()); | |||
| Class expectedReturnType = (returnType == null)? Void.TYPE: returnType; | |||
| Class<?> expectedReturnType = (returnType == null)? Void.TYPE: returnType; | |||
| assertEquals("Return type", expectedReturnType, m.getReturnType()); | |||
| Class[] args = m.getParameterTypes(); | |||
| Class<?>[] args = m.getParameterTypes(); | |||
| if (methodArg != null) { | |||
| assertEquals("Arg Count", 1, args.length); | |||
| assertEquals("Arg Type", methodArg, args[0]); | |||
| @@ -491,14 +491,14 @@ public class IntrospectionHelperTest { | |||
| @Test | |||
| public void testGetAttributes() { | |||
| Map attrMap = getExpectedAttributes(); | |||
| Enumeration e = ih.getAttributes(); | |||
| Map<String, Class<?>> attrMap = getExpectedAttributes(); | |||
| Enumeration<String> e = ih.getAttributes(); | |||
| while (e.hasMoreElements()) { | |||
| String name = (String) e.nextElement(); | |||
| Class expect = (Class) attrMap.get(name); | |||
| assertNotNull("Support for "+name+" in IntrospectionHelperTest?", | |||
| String name = e.nextElement(); | |||
| Class<?> expect = attrMap.get(name); | |||
| assertNotNull("Support for " + name + " in IntrospectionHelperTest?", | |||
| expect); | |||
| assertEquals("Type of "+name, expect, ih.getAttributeType(name)); | |||
| assertEquals("Type of " + name, expect, ih.getAttributeType(name)); | |||
| attrMap.remove(name); | |||
| } | |||
| attrMap.remove("name"); | |||
| @@ -511,7 +511,7 @@ public class IntrospectionHelperTest { | |||
| Map<String, Class<?>> actualMap = ih.getAttributeMap(); | |||
| for (Map.Entry<String, Class<?>> entry : actualMap.entrySet()) { | |||
| String attrName = entry.getKey(); | |||
| Class attrClass = attrMap.get(attrName); | |||
| Class<?> attrClass = attrMap.get(attrName); | |||
| assertNotNull("Support for " + attrName + | |||
| " in IntrospectionHelperTest?", attrClass); | |||
| assertEquals("Type of " + attrName, attrClass, entry.getValue()); | |||
| @@ -568,7 +568,7 @@ public class IntrospectionHelperTest { | |||
| } | |||
| private void assertAttrMethod(String attrName, String methodName, | |||
| Class methodArg, Object arg, Object badArg) { | |||
| Class<?> methodArg, Object arg, Object badArg) { | |||
| Method m = ih.getAttributeMethod(attrName); | |||
| assertMethod(m, methodName, methodArg, arg, badArg); | |||
| } | |||
| @@ -614,14 +614,14 @@ public class IntrospectionHelperTest { | |||
| } | |||
| public void setEleven(boolean b) { | |||
| assertTrue(!b); | |||
| assertFalse(b); | |||
| } | |||
| public void setTwelve(Boolean b) { | |||
| assertTrue(!b); | |||
| assertFalse(b); | |||
| } | |||
| public void setThirteen(Class c) { | |||
| public void setThirteen(Class<?> c) { | |||
| assertEquals(Project.class, c); | |||
| } | |||
| @@ -664,7 +664,7 @@ public class IntrospectionHelperTest { | |||
| @Test | |||
| public void testGetExtensionPoints() { | |||
| List extensions = ih.getExtensionPoints(); | |||
| List<Method> extensions = ih.getExtensionPoints(); | |||
| final int adders = 2; | |||
| assertEquals("extension count", adders, extensions.size()); | |||
| @@ -675,28 +675,23 @@ public class IntrospectionHelperTest { | |||
| // combinatorics are too hard to check. We really only want | |||
| // to ensure that the more derived Hashtable can be found | |||
| // before Map. | |||
| // assertExtMethod(extensions.get(0), "add", Number.class, | |||
| // assertMethod(extensions.get(0), "add", Number.class, | |||
| // new Integer(2), new Integer(3)); | |||
| // addConfigured(Hashtable) should come before addConfigured(Map) | |||
| assertExtMethod(extensions.get(adders - 2), | |||
| assertMethod(extensions.get(adders - 2), | |||
| "addConfigured", Hashtable.class, | |||
| makeTable("key", "value"), makeTable("1", "2")); | |||
| assertExtMethod(extensions.get(adders - 1), "addConfigured", Map.class, | |||
| new HashMap(), makeTable("1", "2")); | |||
| } | |||
| private void assertExtMethod(Object mo, String methodName, Class methodArg, | |||
| Object arg, Object badArg) { | |||
| assertMethod((Method) mo, methodName, methodArg, arg, badArg); | |||
| assertMethod(extensions.get(adders - 1), "addConfigured", Map.class, | |||
| new HashMap<String, String>(), makeTable("1", "2")); | |||
| } | |||
| private void assertMethod(Method m, String methodName, Class methodArg, | |||
| private void assertMethod(Method m, String methodName, Class<?> methodArg, | |||
| Object arg, Object badArg) { | |||
| assertEquals("Method name", methodName, m.getName()); | |||
| assertEquals("Return type", Void.TYPE, m.getReturnType()); | |||
| Class[] args = m.getParameterTypes(); | |||
| Class<?>[] args = m.getParameterTypes(); | |||
| assertEquals("Arg Count", 1, args.length); | |||
| assertEquals("Arg Type", methodArg, args[0]); | |||
| @@ -717,7 +712,7 @@ public class IntrospectionHelperTest { | |||
| } | |||
| } | |||
| public List add(List l) { | |||
| public List<Object> add(List l) { | |||
| // INVALID extension point | |||
| return null; | |||
| } | |||
| @@ -728,11 +723,11 @@ public class IntrospectionHelperTest { | |||
| // assertEquals(2, n.intValue()); | |||
| // } | |||
| public void add(List l, int i) { | |||
| public void add(List<Object> l, int i) { | |||
| // INVALID extension point | |||
| } | |||
| public void addConfigured(Map m) { | |||
| public void addConfigured(Map<Object, Object> m) { | |||
| // Valid extension point | |||
| assertTrue(m.isEmpty()); | |||
| } | |||
| @@ -34,6 +34,7 @@ import org.junit.Test; | |||
| import static org.apache.tools.ant.AntAssert.assertContains; | |||
| import static org.junit.Assert.assertEquals; | |||
| import static org.junit.Assert.assertFalse; | |||
| import static org.junit.Assert.assertNotNull; | |||
| import static org.junit.Assert.assertNull; | |||
| import static org.junit.Assert.assertSame; | |||
| @@ -189,7 +190,7 @@ public class ProjectTest { | |||
| } catch (BuildException e) { | |||
| assertEquals(message, e.getMessage()); | |||
| mbl.assertEmpty(); | |||
| assertTrue(!p.getTaskDefinitions().containsKey(dummyName)); | |||
| assertFalse(p.getTaskDefinitions().containsKey(dummyName)); | |||
| } | |||
| } | |||
| @@ -90,9 +90,8 @@ public class PropertyExpansionTest { | |||
| /** | |||
| * little helper method to validate stuff | |||
| */ | |||
| private void assertExpandsTo(String source,String expected) { | |||
| String actual = buildRule.getProject().replaceProperties(source); | |||
| assertEquals(source,expected,actual); | |||
| private void assertExpandsTo(String source, String expected) { | |||
| assertEquals(source, expected, buildRule.getProject().replaceProperties(source)); | |||
| } | |||
| } | |||
| @@ -17,7 +17,6 @@ | |||
| */ | |||
| package org.apache.tools.ant.taskdefs; | |||
| import org.apache.tools.ant.AntAssert; | |||
| import org.apache.tools.ant.BuildFileRule; | |||
| import org.junit.After; | |||
| import org.junit.Before; | |||
| @@ -26,6 +25,7 @@ import org.junit.Test; | |||
| import java.io.File; | |||
| import static org.apache.tools.ant.AntAssert.assertContains; | |||
| import static org.junit.Assert.assertFalse; | |||
| import static org.junit.Assert.assertTrue; | |||
| @@ -57,7 +57,7 @@ public class AbstractCvsTaskTest { | |||
| File f = new File(buildRule.getProject().getProperty("output") + "/src/Makefile"); | |||
| assertFalse("starting empty", f.exists()); | |||
| buildRule.executeTarget("package-attribute"); | |||
| AntAssert.assertContains("U src/Makefile", buildRule.getLog()); | |||
| assertContains("U src/Makefile", buildRule.getLog()); | |||
| assertTrue("now it is there", f.exists()); | |||
| } | |||
| @@ -66,7 +66,7 @@ public class AbstractCvsTaskTest { | |||
| File f = new File(buildRule.getProject().getProperty("output") + "/src/Makefile"); | |||
| assertFalse("starting empty", f.exists()); | |||
| buildRule.executeTarget("tag-attribute"); | |||
| AntAssert.assertContains("OPENBSD_5_3", buildRule.getLog()); | |||
| assertContains("OPENBSD_5_3", buildRule.getLog()); | |||
| assertTrue("now it is there", f.exists()); | |||
| } | |||
| } | |||
| @@ -31,6 +31,7 @@ import java.util.Hashtable; | |||
| import static org.apache.tools.ant.AntAssert.assertContains; | |||
| import static org.junit.Assert.assertEquals; | |||
| import static org.junit.Assert.assertFalse; | |||
| import static org.junit.Assert.assertTrue; | |||
| import static org.junit.Assert.fail; | |||
| @@ -83,31 +84,34 @@ public class AntStructureTest { | |||
| public void printHead(PrintWriter out, Project p, | |||
| Hashtable<String, Class<?>> tasks, | |||
| Hashtable<String, Class<?>> types) { | |||
| assertTrue(!headCalled); | |||
| assertTrue(!targetCalled); | |||
| assertTrue(!tailCalled); | |||
| assertFalse(headCalled); | |||
| assertFalse(targetCalled); | |||
| assertFalse(tailCalled); | |||
| assertEquals(0, elementCalled); | |||
| headCalled = true; | |||
| } | |||
| public void printTargetDecl(PrintWriter out) { | |||
| assertTrue(headCalled); | |||
| assertTrue(!targetCalled); | |||
| assertTrue(!tailCalled); | |||
| assertFalse(targetCalled); | |||
| assertFalse(tailCalled); | |||
| assertEquals(0, elementCalled); | |||
| targetCalled = true; | |||
| } | |||
| public void printElementDecl(PrintWriter out, Project p, String name, | |||
| Class<?> element) { | |||
| assertTrue(headCalled); | |||
| assertTrue(targetCalled); | |||
| assertTrue(!tailCalled); | |||
| assertFalse(tailCalled); | |||
| elementCalled++; | |||
| this.p = p; | |||
| } | |||
| public void printTail(PrintWriter out) { | |||
| assertTrue(headCalled); | |||
| assertTrue(targetCalled); | |||
| assertTrue(!tailCalled); | |||
| assertFalse(tailCalled); | |||
| assertTrue(elementCalled > 0); | |||
| tailCalled = true; | |||
| p.log(TAIL_CALLED); | |||
| @@ -22,7 +22,6 @@ import java.io.File; | |||
| import junit.framework.AssertionFailedError; | |||
| import org.apache.tools.ant.AntAssert; | |||
| import org.apache.tools.ant.BuildEvent; | |||
| import org.apache.tools.ant.BuildException; | |||
| import org.apache.tools.ant.BuildFileRule; | |||
| @@ -35,6 +34,7 @@ import org.junit.Before; | |||
| import org.junit.Rule; | |||
| import org.junit.Test; | |||
| import static org.apache.tools.ant.AntAssert.assertContains; | |||
| import static org.junit.Assert.assertEquals; | |||
| import static org.junit.Assert.assertFalse; | |||
| import static org.junit.Assert.assertNull; | |||
| @@ -65,7 +65,7 @@ public class AntTest { | |||
| try { | |||
| buildRule.executeTarget("test1"); | |||
| fail("recursive call"); | |||
| } catch(BuildException ex) { | |||
| } catch (BuildException ex) { | |||
| //TODO assert exception message | |||
| } | |||
| } | |||
| @@ -76,7 +76,7 @@ public class AntTest { | |||
| try { | |||
| buildRule.executeTarget("test2"); | |||
| fail("required argument not specified"); | |||
| } catch(BuildException ex) { | |||
| } catch (BuildException ex) { | |||
| //TODO assert exception message | |||
| } | |||
| } | |||
| @@ -87,7 +87,7 @@ public class AntTest { | |||
| try { | |||
| buildRule.executeTarget("test1"); | |||
| fail("recursive call"); | |||
| } catch(BuildException ex) { | |||
| } catch (BuildException ex) { | |||
| //TODO assert exception message | |||
| } | |||
| } | |||
| @@ -107,7 +107,7 @@ public class AntTest { | |||
| try { | |||
| buildRule.executeTarget("test4b"); | |||
| fail("target doesn't exist"); | |||
| } catch(BuildException ex) { | |||
| } catch (BuildException ex) { | |||
| //TODO assert exception message | |||
| } | |||
| } | |||
| @@ -290,7 +290,7 @@ public class AntTest { | |||
| buildRule.getProject().setUserProperty("test", "7"); | |||
| buildRule.executeTarget("test-property-override-inheritall-start"); | |||
| AntAssert.assertContains("The value of test is 7", buildRule.getLog()); | |||
| assertContains("The value of test is 7", buildRule.getLog()); | |||
| } | |||
| @Test | |||
| @@ -298,20 +298,20 @@ public class AntTest { | |||
| buildRule.getProject().setUserProperty("test", "7"); | |||
| buildRule.executeTarget("test-property-override-no-inheritall-start"); | |||
| AntAssert.assertContains("The value of test is 7", buildRule.getLog()); | |||
| assertContains("The value of test is 7", buildRule.getLog()); | |||
| } | |||
| @Test | |||
| public void testOverrideWinsInheritAll() { | |||
| buildRule.executeTarget("test-property-override-inheritall-start"); | |||
| AntAssert.assertContains("The value of test is 4", buildRule.getLog()); | |||
| assertContains("The value of test is 4", buildRule.getLog()); | |||
| } | |||
| @Test | |||
| public void testOverrideWinsNoInheritAll() { | |||
| buildRule.executeTarget("test-property-override-no-inheritall-start"); | |||
| AntAssert.assertContains("The value of test is 4", buildRule.getLog()); | |||
| assertContains("The value of test is 4", buildRule.getLog()); | |||
| } | |||
| @Test | |||
| @@ -327,7 +327,7 @@ public class AntTest { | |||
| try { | |||
| buildRule.executeTarget("infinite-loop-via-depends"); | |||
| fail("recursive call"); | |||
| } catch(BuildException ex) { | |||
| } catch (BuildException ex) { | |||
| //TODO assert exception message | |||
| } | |||
| } | |||
| @@ -371,7 +371,7 @@ public class AntTest { | |||
| try { | |||
| buildRule.executeTarget("blank-target"); | |||
| fail("target name must not be empty"); | |||
| } catch(BuildException ex) { | |||
| } catch (BuildException ex) { | |||
| //TODO assert exception message | |||
| } | |||
| } | |||
| @@ -37,7 +37,7 @@ import static org.junit.Assert.fail; | |||
| * | |||
| */ | |||
| public class CVSPassTest { | |||
| private final String EOL = System.getProperty("line.separator"); | |||
| private final String EOL = System.lineSeparator(); | |||
| private static final String JAKARTA_URL = | |||
| ":pserver:anoncvs@jakarta.apache.org:/home/cvspublic Ay=0=h<Z"; | |||
| private static final String XML_URL = | |||
| @@ -18,7 +18,6 @@ | |||
| package org.apache.tools.ant.taskdefs; | |||
| import org.apache.tools.ant.AntAssert; | |||
| import org.apache.tools.ant.BuildException; | |||
| import org.apache.tools.ant.BuildFileRule; | |||
| import org.junit.Before; | |||
| @@ -27,6 +26,7 @@ import org.junit.Test; | |||
| import java.util.Vector; | |||
| import static org.apache.tools.ant.AntAssert.assertContains; | |||
| import static org.junit.Assert.assertEquals; | |||
| import static org.junit.Assert.fail; | |||
| @@ -47,7 +47,7 @@ public class CallTargetTest { | |||
| @Test | |||
| public void testInheritRefFileSet() { | |||
| buildRule.executeTarget("testinheritreffileset"); | |||
| AntAssert.assertContains("calltarget.xml", buildRule.getLog()); | |||
| assertContains("calltarget.xml", buildRule.getLog()); | |||
| } | |||
| // see bugrep 21724 (references not passing through with antcall) | |||
| @@ -64,7 +64,7 @@ public class CallTargetTest { | |||
| v.add("call-multi"); | |||
| v.add("call-multi"); | |||
| buildRule.getProject().executeTargets(v); | |||
| AntAssert.assertContains("multi is SETmulti is SET", buildRule.getLog()); | |||
| assertContains("multi is SETmulti is SET", buildRule.getLog()); | |||
| } | |||
| @Test | |||
| @@ -31,6 +31,7 @@ import java.io.IOException; | |||
| import static org.apache.tools.ant.AntAssert.assertContains; | |||
| import static org.junit.Assert.assertEquals; | |||
| import static org.junit.Assert.assertFalse; | |||
| import static org.junit.Assert.assertTrue; | |||
| import static org.junit.Assert.fail; | |||
| @@ -240,7 +241,7 @@ public class ConcatTest { | |||
| try { | |||
| buildRule.executeTarget("samefile"); | |||
| fail("Build exception should have been thrown - output file same as input"); | |||
| } catch(BuildException ex) { | |||
| } catch (BuildException ex) { | |||
| //TODO assert value | |||
| } | |||
| } | |||
| @@ -261,7 +262,7 @@ public class ConcatTest { | |||
| public void testmultireader() { | |||
| buildRule.executeTarget("testmultireader"); | |||
| assertTrue(buildRule.getLog().contains("Bye")); | |||
| assertTrue(!buildRule.getLog().contains("Hello")); | |||
| assertFalse(buildRule.getLog().contains("Hello")); | |||
| } | |||
| /** | |||
| * Check if fixlastline works | |||
| @@ -269,7 +270,7 @@ public class ConcatTest { | |||
| @Test | |||
| public void testfixlastline() throws IOException { | |||
| buildRule.executeTarget("testfixlastline"); | |||
| assertContains("end of line" + System.getProperty("line.separator") + "This has", | |||
| assertContains("end of line" + System.lineSeparator() + "This has", | |||
| FileUtilities.getFileContents(buildRule.getProject(), "concat.line4")); | |||
| } | |||
| @@ -35,6 +35,7 @@ import java.io.IOException; | |||
| import static org.apache.tools.ant.AntAssert.assertContains; | |||
| import static org.junit.Assert.assertEquals; | |||
| import static org.junit.Assert.assertFalse; | |||
| import static org.junit.Assert.assertNotEquals; | |||
| import static org.junit.Assert.assertTrue; | |||
| import static org.junit.Assert.fail; | |||
| @@ -105,7 +106,7 @@ public class CopyTest { | |||
| @Test | |||
| public void testFilterTest() { | |||
| buildRule.executeTarget("filtertest"); | |||
| assertTrue(!buildRule.getLog().contains("loop in tokens")); | |||
| assertFalse(buildRule.getLog().contains("loop in tokens")); | |||
| } | |||
| @Test | |||
| @@ -159,8 +159,11 @@ public class DefaultExcludesTest { | |||
| assertEquals(message + " : string array length match", expected.length, actual.length); | |||
| for (String element : expected) { | |||
| boolean found = false; | |||
| for (int i = 0; !found && i < actual.length; i++) { | |||
| found |= element.equals(actual[i]); | |||
| for (String member : actual) { | |||
| found |= element.equals(member); | |||
| if (found) { | |||
| break; | |||
| } | |||
| } | |||
| assertTrue(message + " : didn't find element " | |||
| + element + " in array match", found); | |||