*
 * <ul>
 *   <li>It looks only for files and JARs in URLs available from {@link URLClassLoader} instances or
 *       the {@linkplain ClassLoader#getSystemClassLoader() system class loader}. This means it does
 *       not look for classes in the <i>module path</i>.
 *   <li>It understands only {@code file:} URLs. This means that it does not understand <a

                            log.debug("Failed to load handler class " + className, ex);
                        }
                        if (handlerClass == null) {
                            handlerClass = ClassLoader.getSystemClassLoader().loadClass(className);
                        }
                        handler = (URLStreamHandler) handlerClass.newInstance();
                        break;
                    } catch (final Exception ex) {

                        } catch (final Exception ex) {}
                        if (handlerClass == null) {
                            handlerClass = ClassLoader.getSystemClassLoader().loadClass(className);
                        }
                        handler = (URLStreamHandler) handlerClass.newInstance();
                        break;
                    } catch (final Exception ex) {}

    // Check the assumptions above.

    // FRQ tries to load the Finalizer class (for the reference-collecting thread) in a few ways.
    // If the class is accessible to the system ClassLoader (ClassLoader.getSystemClassLoader())
    // then FRQ does not bother to load Finalizer.class through a separate ClassLoader. That happens
    // in our test environment, which foils the purpose of this test, so we disable the logic for

                }
            }
        }
        return logs;
    }

    protected ClassWorld createClassWorld() {
        return new ClassWorld("plexus.core", ClassLoader.getSystemClassLoader());
    }

    protected abstract Invoker createInvoker(ClassWorld classWorld);

    protected abstract Parser createParser();

            return targetClassLoader;
        }
        if (thisClassLoader != null) {
            return thisClassLoader;
        }

        final ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        if (systemClassLoader != null) {
            return systemClassLoader;
        }

        throw new ClIllegalStateException(MessageFormatter.getMessage("ECL0001", "ClassLoader"));
    }

    /**

    // Check the assumptions above.

    // FRQ tries to load the Finalizer class (for the reference-collecting thread) in a few ways.
    // If the class is accessible to the system ClassLoader (ClassLoader.getSystemClassLoader())
    // then FRQ does not bother to load Finalizer.class through a separate ClassLoader. That happens
    // in our test environment, which foils the purpose of this test, so we disable the logic for

            return nameSet.stream().sorted().collect(Collectors.toList());
        }
        for (final File jarFile : jarFiles) {
            try (FileSystem fs = FileSystems.newFileSystem(jarFile.toPath(), ClassLoader.getSystemClassLoader())) {
                final Path xmlPath = fs.getPath("fess_ds++.xml");
                if (!Files.exists(xmlPath)) {
                    if (logger.isDebugEnabled()) {

        .testEquals();
  }

  @AndroidIncompatible // ClassPath is documented as not supporting Android

  public void testScanAllResources() throws IOException {
    assertThat(scanResourceNames(ClassLoader.getSystemClassLoader()))
        .contains("com/google/common/reflect/ClassPathTest.class");
  }

  private static ClassPath.ClassInfo findClass(
      Iterable<ClassPath.ClassInfo> classes, Class<?> cls) {

        // We need not worry about class unloading under Android. Plus, this approach wouldn't work.
        return null;
      }
      ClassLoader systemLoader;
      try {
        systemLoader = ClassLoader.getSystemClassLoader();
      } catch (SecurityException e) {
        logger.info("Not allowed to access system class loader.");
        return null;
      }
      if (systemLoader != null) {
        try {