Improve a few unit tests and classes

src/core/org/apache/jmeter/report/core/SampleComparator.java

@@ -19,7 +19,7 @@
 
 /**
  * Defines a comparator for {@link Sample} instances
- * 
+ *
  * @since 3.0
  */
 public interface SampleComparator {
@@ -28,19 +28,17 @@ public interface SampleComparator {
      * Compares to sample
      * <p>
      * Must return an long integer that define the relational order of the 2
-     * compared samples :</p>
+     * compared samples:</p>
      * <ul>
      * <li>Negative long integer : s1 is lower than s2</li>
      * <li>Zero long integer : s1 is strictly equal to s2</li>
      * <li>Positive long integer : s1 is greater than s2</li>
      * </ul>
-     * 
-     * @param s1
-     *            The first sample to be compared
-     * @param s2
-     *            The second sample to compared
+     *
+     * @param s1 The first sample to be compared
+     * @param s2 The second sample to compared
      * @return A negative is <code>s1 &lt; s2</code>, <code>0 if s1 = s2</code>,
-     *         a positive integer if <code>s1 &gt; s2</code>
+     * a positive integer if <code>s1 &gt; s2</code>
      */
     long compare(Sample s1, Sample s2);
 
@@ -55,10 +53,8 @@ public interface SampleComparator {
      * Not that this function is the place to get sample column indexes for
      * better performance
      * </p>
-     * 
-     * @param metadata
-     *            The sample metadata of the sample to be compared by this
-     *            instance
+     *
+     * @param metadata The metadata of the sample to be compared by this instance
      */
     void initialize(SampleMetadata metadata);
 

src/core/org/apache/jmeter/report/processor/FieldSampleComparator.java

@@ -25,7 +25,7 @@
  * @since 3.0
  */
 public class FieldSampleComparator implements SampleComparator {
-    
+
     private int index;
 
     private final String fieldName;
@@ -39,15 +39,9 @@ public final void initialize(SampleMetadata metadata) {
         index = metadata.ensureIndexOf(fieldName);
     }
 
-    /*
-     * (non-Javadoc)
-     * 
-     * @see
-     * org.apache.jmeter.report.csv.core.SampleComparator#compare(org.apache
-     * .jmeter.report.csv.core.Sample, org.apache.jmeter.report.csv.core.Sample)
-     */
     @Override
     public long compare(Sample s1, Sample s2) {
-        return s1.getData(long.class, index, fieldName).compareTo(s2.getData(long.class, index, fieldName));
+        return s1.getData(long.class, index, fieldName)
+                .compareTo(s2.getData(long.class, index, fieldName));
     }
 }

src/protocol/http/org/apache/jmeter/protocol/http/control/DNSCacheManager.java

@@ -5,9 +5,9 @@
  * licenses this file to You under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
@@ -72,7 +72,7 @@ public class DNSCacheManager extends ConfigTestElement implements TestIterationL
 
     private static final String SERVERS = "DNSCacheManager.servers"; // $NON-NLS-1$
 
-    private  static final String HOSTS = "DNSCacheManager.hosts"; // $NON-NLS-1$
+    private static final String HOSTS = "DNSCacheManager.hosts"; // $NON-NLS-1$
 
     private static final String IS_CUSTOM_RESOLVER = "DNSCacheManager.isCustomResolver"; // $NON-NLS-1$
     //-- JMX tag values
@@ -85,7 +85,7 @@ public class DNSCacheManager extends ConfigTestElement implements TestIterationL
 
     final Map<String, InetAddress[]> cache;
 
-    transient Resolver resolver;
+    private transient Resolver resolver;
 
     private transient int timeoutMs;
 
@@ -113,9 +113,6 @@ public Object clone() {
         return clone;
     }
 
-    /**
-     * @return {@link Resolver}
-     */
     private Resolver createResolver() {
         CollectionProperty dnsServers = getServers();
         try {
@@ -140,7 +137,6 @@ private Resolver createResolver() {
     }
 
     /**
-     *
      * Resolves address using system or custom DNS resolver
      */
     @Override
@@ -154,29 +150,33 @@ public InetAddress[] resolve(String host) throws UnknownHostException {
         // https://docs.oracle.com/javase/8/docs/api/java/util/LinkedHashMap.html
         if (result != null || cache.containsKey(host)) {
             if (log.isDebugEnabled()) {
-                log.debug("Cache hit thr#{}: {} => {}", JMeterContextService.getContext().getThreadNum(), host,
-                        Arrays.toString(result));
+                logCache("hit", host, result);
             }
             return result;
         } else if (isStaticHost(host)) {
             InetAddress[] staticAddresses = fromStaticHost(host);
             if (log.isDebugEnabled()) {
-                log.debug("Cache miss thr#{}: (static) {} => {}", JMeterContextService.getContext().getThreadNum(), host,
-                        Arrays.toString(staticAddresses));
+                logCache("miss", host, staticAddresses);
             }
             cache.put(host, staticAddresses);
             return staticAddresses;
         } else {
             InetAddress[] addresses = requestLookup(host);
             if (log.isDebugEnabled()) {
-                log.debug("Cache miss thr#{}: {} => {}", JMeterContextService.getContext().getThreadNum(), host,
-                        Arrays.toString(addresses));
+                logCache("miss", host, addresses);
             }
             cache.put(host, addresses);
             return addresses;
         }
     }
 
+    private void logCache(String hitOrMiss, String host, InetAddress[] addresses) {
+        log.debug("Cache " + hitOrMiss + " thread#{}: {} => {}",
+                JMeterContextService.getContext().getThreadNum(),
+                host,
+                Arrays.toString(addresses));
+    }
+
     private boolean isStaticHost(String host) {
         JMeterProperty p = getProperty(HOSTS);
         if (p instanceof NullProperty) {
@@ -209,32 +209,32 @@ private InetAddress[] fromStaticHost(String host) {
             return new InetAddress[0];
         }
         CollectionProperty property = (CollectionProperty) p;
-        PropertyIterator iterator = property.iterator();
-        while (iterator.hasNext()) {
-            StaticHost entry = (StaticHost) ((TestElementProperty)iterator.next()).getObjectValue();
-            if (entry.getName().equals(host)) {
-                List<InetAddress> addresses = new ArrayList<>();
-                for (String address : Arrays.asList(entry.getAddress().split("\\s*,\\s*"))) {
-                    try {
-                        final InetAddress[] requestLookup = requestLookup(address);
-                        if (requestLookup == null) {
-                            addAsLiteralAddress(addresses, address);
-                        } else {
-                            addresses.addAll(Arrays.asList(requestLookup));
-                        }
-                    } catch (UnknownHostException e) {
+        for (JMeterProperty jMeterProperty : property) {
+            StaticHost entry = (StaticHost) ((TestElementProperty) jMeterProperty).getObjectValue();
+            if (!entry.getName().equals(host)) {
+                continue; // try the next property
+            }
+
+            List<InetAddress> addresses = new ArrayList<>();
+            for (String address : entry.getAddress().split("\\s*,\\s*")) {
+                try {
+                    final InetAddress[] requestLookup = requestLookup(address);
+                    if (requestLookup == null) {
                         addAsLiteralAddress(addresses, address);
-                        log.warn("Couldn't resolve static address {} for host {}", address, host, e);
+                    } else {
+                        addresses.addAll(Arrays.asList(requestLookup));
                     }
+                } catch (UnknownHostException e) {
+                    addAsLiteralAddress(addresses, address);
+                    log.warn("Couldn't resolve static address {} for host {}", address, host, e);
                 }
-                return addresses.toArray(new InetAddress[addresses.size()]);
             }
+            return addresses.toArray(new InetAddress[addresses.size()]);
         }
         return new InetAddress[0];
     }
 
-    private void addAsLiteralAddress(List<InetAddress> addresses,
-            String address) {
+    private void addAsLiteralAddress(List<InetAddress> addresses, String address) {
         try {
             addresses.add(InetAddress.getByName(address));
         } catch (UnknownHostException e) {
@@ -244,55 +244,61 @@ private void addAsLiteralAddress(List<InetAddress> addresses,
 
     /**
      * Sends DNS request via system or custom DNS resolver
-     * @param host Host
+     *
+     * @param host Host to lookup
      * @return array of {@link InetAddress} or null if lookup did not return result
      */
     private InetAddress[] requestLookup(String host) throws UnknownHostException {
         InetAddress[] addresses = null;
+
         if (isCustomResolver()) {
-            ExtendedResolver extendedResolver = getResolver();
-            if (extendedResolver != null) {
-                if(extendedResolver.getResolvers().length > 0) {
-                    try {
-                        Lookup lookup = new Lookup(host, Type.A);
-                        lookup.setCache(lookupCache);
-                        if (timeoutMs > 0) {
-                            resolver.setTimeout(timeoutMs / 1000, timeoutMs % 1000);
-                        }
-                        lookup.setResolver(resolver);
-                        Record[] records = lookup.run();
-                        if (records == null || records.length == 0) {
-                            throw new UnknownHostException("Failed to resolve host name: " + host);
-                        }
-                        addresses = new InetAddress[records.length];
-                        for (int i = 0; i < records.length; i++) {
-                            addresses[i] = ((ARecord) records[i]).getAddress();
-                        }
-                    } catch (TextParseException tpe) {
-                        log.debug("Failed to create Lookup object: {}", tpe.toString());
-                    }
-                    return addresses;
-                }
-            } else {
-                throw new UnknownHostException("Could not resolve host:"+host
-                        +", failed to initialize resolver"
-                        + " or no resolver found");
+            ExtendedResolver extendedResolver = getOrCreateResolver();
+            if (extendedResolver == null) {
+                throw new UnknownHostException("Could not resolve host:" + host
+                        + ", failed to initialize resolver or no resolver found");
+            } else if (extendedResolver.getResolvers().length > 0) {
+                addresses = customRequestLookup(host);
+            }
+        } else {
+            addresses = systemDefaultDnsResolver.resolve(host);
+            if (log.isDebugEnabled()) {
+                logCache("miss (resolved with system resolver)", host, addresses);
             }
         }
-        addresses = systemDefaultDnsResolver.resolve(host);
-        if (log.isDebugEnabled()) {
-            log.debug("Cache miss: {} Thread #{}, resolved with system resolver into {}", host,
-                    JMeterContextService.getContext().getThreadNum(), Arrays.toString(addresses));
+
+        return addresses;
+    }
+
+    private InetAddress[] customRequestLookup(String host) throws UnknownHostException {
+        InetAddress[] addresses = null;
+        try {
+            Lookup lookup = new Lookup(host, Type.A);
+            lookup.setCache(lookupCache);
+            if (timeoutMs > 0) {
+                resolver.setTimeout(timeoutMs / 1000, timeoutMs % 1000);
+            }
+            lookup.setResolver(resolver);
+            Record[] records = lookup.run();
+            if (records == null || records.length == 0) {
+                throw new UnknownHostException("Failed to resolve host name: " + host);
+            }
+            addresses = new InetAddress[records.length];
+            for (int i = 0; i < records.length; i++) {
+                addresses[i] = ((ARecord) records[i]).getAddress();
+            }
+        } catch (TextParseException tpe) {
+            log.debug("Failed to create Lookup object: {}", tpe.toString());
         }
         return addresses;
     }
 
     /**
-     * Tries to initialize resolver , otherwise sets initFailed to true
+     * Tries to initialize resolver, otherwise sets initFailed to true
+     *
      * @return ExtendedResolver if init succeeded or null otherwise
      */
-    private ExtendedResolver getResolver() {
-        if(resolver == null && !initFailed) {
+    private ExtendedResolver getOrCreateResolver() {
+        if (resolver == null && !initFailed) {
             resolver = createResolver();
         }
         return (ExtendedResolver) resolver;
@@ -331,6 +337,7 @@ private void clearServers() {
 
     /**
      * Add DNS Server
+     *
      * @param dnsServer DNS Server
      */
     public void addServer(String dnsServer) {
@@ -355,7 +362,8 @@ private void clearHosts() {
 
     /**
      * Add static host
-     * @param dnsHost DNS host
+     *
+     * @param dnsHost   DNS host
      * @param addresses Comma separated list of addresses
      */
     public void addHost(String dnsHost, String addresses) {
@@ -372,7 +380,7 @@ public CollectionProperty getHosts() {
 
     /**
      * Clean DNS cache each iteration
-     * 
+     *
      * @return boolean
      */
     public boolean isClearEachIteration() {
@@ -382,8 +390,7 @@ public boolean isClearEachIteration() {
     /**
      * Clean DNS cache each iteration
      *
-     * @param clear
-     *            flag whether DNS cache should be cleared on each iteration
+     * @param clear flag whether DNS cache should be cleared on each iteration
      */
     public void setClearEachIteration(boolean clear) {
         setProperty(new BooleanProperty(CLEAR_CACHE_EACH_ITER, clear));