1 /*

     2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 /**

    25  * @test

    26  * @requires vm.aot

    27  * @modules jdk.aot/jdk.tools.jaotc

    28  *          jdk.aot/jdk.tools.jaotc.collect

    29  * @run junit/othervm jdk.tools.jaotc.test.collect.ClassSearchTest

    30  */

    31 

    32 

    33 

    34 package jdk.tools.jaotc.test.collect;

    35 

    36 import java.util.ArrayList;

    37 import java.util.HashSet;

    38 import java.util.List;

    39 import java.util.Set;

    40 import java.util.function.BiConsumer;

    41 import java.util.function.BiFunction;

    42 

    43 import org.junit.Assert;

    44 import org.junit.Test;

    45 

    46 import jdk.tools.jaotc.LoadedClass;

    47 import jdk.tools.jaotc.collect.ClassSearch;

    48 import jdk.tools.jaotc.collect.ClassSource;

    49 import jdk.tools.jaotc.collect.SearchFor;

    50 import jdk.tools.jaotc.collect.SearchPath;

    51 import jdk.tools.jaotc.collect.SourceProvider;

    52 

    53 public class ClassSearchTest {

    54     @Test(expected = InternalError.class)

    55     public void itShouldThrowExceptionIfNoProvidersAvailable() {

    56         ClassSearch target = new ClassSearch();

    57         SearchPath searchPath = new SearchPath();

    58         target.search(list(new SearchFor("foo")), searchPath);

    59     }

    60 

    61     @Test

    62     public void itShouldFindAProviderForEachEntry() {

    63         Set<String> searched = new HashSet<>();

    64         ClassSearch target = new ClassSearch();

    65         target.addProvider(provider("", (name, searchPath) -> {

    66             searched.add(name);

    67             return new NoopSource();

    68         }));

    69         target.search(searchForList("foo", "bar", "foobar"), null);

    70         Assert.assertEquals(hashset("foo", "bar", "foobar"), searched);

    71     }

    72 

    73     private static SourceProvider provider(String supports, BiFunction<String, SearchPath, ClassSource> fn) {

    74         return new SourceProvider() {

    75             @Override

    76             public ClassSource findSource(String name, SearchPath searchPath) {

    77                 return fn.apply(name, searchPath);

    78             }

    79 

    80             @Override

    81             public boolean supports(String type) {

    82                 return supports.equals(type);

    83             }

    84         };

    85     }

    86 

    87     @Test

    88     public void itShouldOnlySearchSupportedProvidersForKnownType() {

    89         Set<String> visited = new HashSet<>();

    90         ClassSearch target = new ClassSearch();

    91 

    92         target.addProvider(provider("jar", (name, searchPath) -> {

    93             visited.add("jar");

    94             return null;

    95         }));

    96 

    97         target.addProvider(provider("dir", (name, searchPath) -> {

    98             visited.add("dir");

    99             return null;

   100         }));

   101 

   102         try {

   103             target.search(list(new SearchFor("some", "dir")), null);

   104         } catch (InternalError e) {

   105             // throws because no provider gives a source

   106         }

   107 

   108         Assert.assertEquals(hashset("dir"), visited);

   109     }

   110 

   111     @Test(expected = InternalError.class)

   112     public void itShouldThrowErrorIfMultipleSourcesAreAvailable() {

   113         ClassSearch target = new ClassSearch();

   114         target.addProvider(provider("", (name, searchPath) -> consumer -> Assert.fail()));

   115         target.addProvider(provider("", (name, searchPath) -> consumer -> Assert.fail()));

   116 

   117         target.search(searchForList("somethign"), null);

   118     }

   119 

   120     @Test

   121     public void itShouldSearchAllProvidersForUnknownType() {

   122         Set<String> visited = new HashSet<>();

   123         ClassSearch target = new ClassSearch();

   124         target.addProvider(provider("", (name, searchPath) -> {

   125             visited.add("1");

   126             return null;

   127         }));

   128         target.addProvider(provider("", (name, searchPath) -> {

   129             visited.add("2");

   130             return null;

   131         }));

   132 

   133         try {

   134             target.search(searchForList("foo"), null);

   135         } catch (InternalError e) {

   136             // throws because no provider gives a source

   137         }

   138 

   139         Assert.assertEquals(hashset("1", "2"), visited);

   140     }

   141 

   142     @Test

   143     public void itShouldTryToLoadSaidClassFromClassLoader() {

   144         Set<String> loaded = new HashSet<>();

   145 

   146         ClassSearch target = new ClassSearch();

   147         target.addProvider(new SourceProvider() {

   148             @Override

   149             public boolean supports(String type) {

   150                 return true;

   151             }

   152 

   153             @Override

   154             public ClassSource findSource(String name, SearchPath searchPath) {

   155                 return new ClassSource() {

   156                     @Override

   157                     public void eachClass(BiConsumer<String, ClassLoader> consumer) {

   158                         consumer.accept("foo.Bar", new ClassLoader() {

   159                             @Override

   160                             public Class<?> loadClass(String nm) throws ClassNotFoundException {

   161                                 loaded.add(nm);

   162                                 return null;

   163                             }

   164                         });

   165                     }

   166                 };

   167             }

   168         });

   169 

   170         java.util.List<LoadedClass> search = target.search(searchForList("/tmp/something"), null);

   171         Assert.assertEquals(list(new LoadedClass("foo.Bar", null)), search);

   172     }

   173 

   174     @Test(expected = InternalError.class)

   175     public void itShouldThrowInternalErrorWhenClassLoaderFails() {

   176         ClassLoader classLoader = new ClassLoader() {

   177             @Override

   178             public Class<?> loadClass(String name1) throws ClassNotFoundException {

   179                 throw new ClassNotFoundException("failed to find " + name1);

   180             }

   181         };

   182 

   183         ClassSearch target = new ClassSearch();

   184         target.addProvider(provider("", (name, searchPath) -> consumer -> consumer.accept("foo.Bar", classLoader)));

   185         target.search(searchForList("foobar"), null);

   186     }

   187 

   188     private static List<SearchFor> searchForList(String... entries) {

   189         List<SearchFor> list = new ArrayList<>();

   190         for (String entry : entries) {

   191             list.add(new SearchFor(entry));

   192         }

   193         return list;

   194     }

   195 

   196     @SafeVarargs

   197     private static <T> List<T> list(T... entries) {

   198         List<T> list = new ArrayList<>();

   199         for (T entry : entries) {

   200             list.add(entry);

   201         }

   202         return list;

   203     }

   204 

   205     @SafeVarargs

   206     private static <T> Set<T> hashset(T... entries) {

   207         Set<T> set = new HashSet<>();

   208         for (T entry : entries) {

   209             set.add(entry);

   210         }

   211         return set;

   212     }

   213 

   214     private static class NoopSource implements ClassSource {

   215         @Override

   216         public void eachClass(BiConsumer<String, ClassLoader> consumer) {

   217         }

   218     }

   219 }