fix tests not behaving consistently with Android TNG#347

It seems like Gradle Android support treats Java and Android libraries differently. When run from Gradle `ClassLoader.getResources(..)` would return a package entry only from the library JAR, but not the Android JAR. When run from Android Studio it seems like plain file paths and no archives are used, so `ClassLoader.getResources(..)` returns URLs from both libraries.
In the beginning we only used `ClassLoader.getResources(..)`, but then the first bug occurring was that JARs containing a package would not be detected if the folder entry for the package was missing (e.g. look for `java.io` but the entry `/java/io` from the JAR is missing, even though `/java/io/File.class` is there, then `ClassLoader.getResources("/java/io/")` would not give a result). As a workaround we would check if the requested resource was no class file and we got no result and then in turn look through all the JARs on the classpath to return all entries starting with the respective package prefix. Unfortunately this did not work for Android, because `ClassLoader.getResources(..)` provided a partial result, just missing some entries that should be present on the classpath. The only consistent solution seems to be to immediately do the scanning through the classpath ourselves and completely drop the usage of `ClassLoader.getResources(..)`.
I did some performance analysis on Hibernate Core which seemed fine (similar times). What was needed though is a cache for the entries or the build time would explode. This will not make a difference if every location is only scanned once, but as soon as we repeatedly import classes from the classpath the scanning of all archives would cost massive performance (in the end the `ClassLoader` caches all these entries internally as well). I have compared the heap usage with and without the cache on Hibernate core and could not notice a significant increase. Thus it seems okay to go this way and keeping the resource entries in the cache for the lifetime of ArchUnit seems okay.

Author: codecholeric

archunit/src/jdk9main/java/com/tngtech/archunit/core/importer/ModuleLocationFactory.java

@@ -100,7 +100,7 @@ public boolean isArchive() {
         }
 
         @Override
-        Iterable<NormalizedResourceName> iterateEntries() {
+        Iterable<NormalizedResourceName> iterateEntriesInternal() {
             return doWithModuleReader(moduleReference, moduleReader -> moduleReader.list()
                     .filter(resourceName::isStartOf)
                     .map(NormalizedResourceName::from)

archunit/src/main/java/com/tngtech/archunit/core/importer/Location.java

@@ -31,10 +31,14 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
 import java.util.regex.Pattern;
 
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
 import com.google.common.collect.ImmutableList;
 import com.tngtech.archunit.PublicAPI;
 import com.tngtech.archunit.base.ArchUnitException.LocationException;
@@ -63,6 +67,14 @@ public abstract class Location {
         ImportPlugin.Loader.loadForCurrentPlatform().plugInLocationFactories(factories);
     }
 
+    private static final Cache<NormalizedUri, Iterable<NormalizedResourceName>> ENTRY_CACHE = CacheBuilder.newBuilder().build();
+    private final Callable<Iterable<NormalizedResourceName>> readResourceEntries = new Callable<Iterable<NormalizedResourceName>>() {
+        @Override
+        public Iterable<NormalizedResourceName> call() {
+            return iterateEntriesInternal();
+        }
+    };
+
     final NormalizedUri uri;
 
     Location(NormalizedUri uri) {
@@ -133,6 +145,19 @@ void checkScheme(String scheme, NormalizedUri uri) {
                 uri, getClass().getSimpleName(), scheme, uri.getScheme());
     }
 
+    /**
+     * @return An iterable containing all class file names under this location, e.g. relative file names, Jar entry names, ...
+     */
+    final Iterable<NormalizedResourceName> iterateEntries() {
+        try {
+            return ENTRY_CACHE.get(uri, readResourceEntries);
+        } catch (ExecutionException e) {
+            throw new LocationException(e);
+        }
+    }
+
+    abstract Iterable<NormalizedResourceName> iterateEntriesInternal();
+
     @Override
     public int hashCode() {
         return Objects.hash(uri);
@@ -189,11 +214,6 @@ static URI toURI(URL url) {
         }
     }
 
-    /**
-     * @return An iterable containing all class file names under this location, e.g. relative file names, Jar entry names, ...
-     */
-    abstract Iterable<NormalizedResourceName> iterateEntries();
-
     interface Factory {
         boolean supports(String scheme);
 
@@ -270,7 +290,7 @@ public boolean isArchive() {
         }
 
         @Override
-        Iterable<NormalizedResourceName> iterateEntries() {
+        Iterable<NormalizedResourceName> iterateEntriesInternal() {
             File file = getFileOfJar();
             if (!file.exists()) {
                 return emptySet();
@@ -341,7 +361,7 @@ public boolean isArchive() {
         }
 
         @Override
-        Iterable<NormalizedResourceName> iterateEntries() {
+        Iterable<NormalizedResourceName> iterateEntriesInternal() {
             try {
                 return getAllFilesBeneath(uri);
             } catch (IOException e) {

archunit/src/main/java/com/tngtech/archunit/core/importer/Locations.java

@@ -15,23 +15,16 @@
  */
 package com.tngtech.archunit.core.importer;
 
-import java.io.IOException;
 import java.net.URL;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
 
-import com.google.common.base.Predicate;
-import com.google.common.collect.FluentIterable;
 import com.google.common.collect.ImmutableSet;
 import com.tngtech.archunit.PublicAPI;
-import com.tngtech.archunit.base.ArchUnitException.LocationException;
 import com.tngtech.archunit.core.InitialConfiguration;
 
-import static com.google.common.collect.Sets.newHashSet;
 import static com.tngtech.archunit.PublicAPI.Usage.ACCESS;
-import static com.tngtech.archunit.base.ClassLoaders.getCurrentClassLoader;
-import static java.util.Collections.list;
 
 /**
  * Represents a set of {@link Location locations} of Java class files. Also offers methods to derive concrete locations (i.e. URIs) from
@@ -113,37 +106,20 @@ private static String asResourceName(String qualifiedName) {
     private static Set<Location> getLocationsOf(String resourceName) {
         UrlSource classpath = locationResolver.get().resolveClassPath();
         NormalizedResourceName normalizedResourceName = NormalizedResourceName.from(resourceName);
-        return ImmutableSet.copyOf(getResourceLocations(getCurrentClassLoader(Locations.class), normalizedResourceName, classpath));
-    }
-
-    private static Collection<Location> getResourceLocations(ClassLoader loader, NormalizedResourceName resourceName, Iterable<URL> classpath) {
-        try {
-            Set<Location> result = newHashSet(Locations.of(list(loader.getResources(resourceName.toString()))));
-            if (result.isEmpty() && !resourceName.belongsToClassFile()) {
-                return findMissedClassesDueToLackOfPackageEntry(classpath, resourceName);
-            }
-            return result;
-        } catch (IOException e) {
-            throw new LocationException(e);
-        }
+        return ImmutableSet.copyOf(getResourceLocations(normalizedResourceName, classpath));
     }
 
     /**
-     * Unfortunately the behavior with archives is not completely consistent. Originally,
-     * {@link Locations#ofPackage(String)} simply asked all {@link java.net.URLClassLoader}s, for
-     * {@link ClassLoader#getResources(String)} of the respective resource name.
-     * E.g.
-     * <pre><code>importPackage("org.junit") -> getResources("/org/junit")</code></pre>
-     * However, this only works, if all respective archives contain an entry for the folder, which is not always the
-     * case. Consider the standard JRE "rt.jar", which does not contain an entry "/java/io", but nonetheless
-     * entries like "/java/io/File.class". Thus an import of "java.io", relying on
-     * {@link ClassLoader#getResources(String)}, would not import <code>java.io.File</code>.
+     * We cannot use {@link ClassLoader#getResources(String)} here, because this behaves inconsistently
+     * if JAR files are missing package folder entries.<br>
+     * E.g. loading the package via
+     * <pre><code>importPackage("java.io") -> classLoader.getResources("/java/io")</code></pre>
+     * does not behave correctly for older Java versions,
+     * because the folder entry {@code /java/io} is missing from {@code rt.jar}.
      */
-    private static Collection<Location> findMissedClassesDueToLackOfPackageEntry(
-            Iterable<URL> classpath, NormalizedResourceName resourceName) {
-
+    private static Collection<Location> getResourceLocations(NormalizedResourceName resourceName, Iterable<URL> classpath) {
         Set<Location> result = new HashSet<>();
-        for (Location location : archiveLocationsOf(classpath)) {
+        for (Location location : Locations.of(classpath)) {
             if (containsEntryWithPrefix(location, resourceName)) {
                 result.add(location.append(resourceName.toString()));
             }
@@ -159,15 +135,4 @@ private static boolean containsEntryWithPrefix(Location location, NormalizedReso
         }
         return false;
     }
-
-    private static Set<Location> archiveLocationsOf(Iterable<URL> urls) {
-        return FluentIterable.from(Locations.of(urls))
-                .filter(new Predicate<Location>() {
-                    @Override
-                    public boolean apply(Location input) {
-                        return input.isArchive();
-                    }
-                }).toSet();
-    }
-
 }