* overridden as desired.
 *
 * <p>Usage example:
 *
 * {@snippet :
 * CacheLoader<Key, Graph> loader = new CacheLoader<Key, Graph>() {
 *   public Graph load(Key key) throws AnyException {
 *     return createExpensiveGraph(key);
 *   }
 * };
 * LoadingCache<Key, Graph> cache = CacheBuilder.newBuilder().build(loader);
 * }
 *

   * {@code key}, simply waits for that thread to finish and returns its loaded value. Note that
   * multiple threads can concurrently load values for distinct keys.
   *
   * <p>Caches loaded by a {@link CacheLoader} will call {@link CacheLoader#load} to load new values
   * into the cache. Newly loaded values are added to the cache using {@code

   *
   * When we reference FinalizableReferenceQueue in this test, we are referencing a class that is
   * loaded by this test and that will obviously remain loaded for as long as the test is running.
   * So in order to check ClassLoader garbage collection we need to create a new ClassLoader and
   * make it load its own version of FinalizableReferenceQueue. Then we need to interact with that

        final InputStream in = URLUtil.openStream(url);

        try {
            props.load(in);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        } finally {
            CloseableUtil.close(in);
        }
    }

    /**
     * Loads a resource from the context class loader into the {@link Properties} (wraps exception handling).
     *
     * @param props

                logger.debug("Loaded test system properties");
            } else {
                logger.warn("system.properties not found in test classpath, using defaults");
                setDefaultProperties();
            }
        } catch (IOException e) {
            logger.warn("Failed to load system.properties, using defaults", e);
            setDefaultProperties();
        }
    }

    private void setDefaultProperties() {

     */
    boolean changePassword(String username, String password);

    /**
     * Loads user information from the authentication chain.
     * @param user The user template containing search criteria.
     * @return The loaded user, or null if not found.
     */
    User load(User user);

    }

    /**
     * Loads user information by processing through all authentication chains.
     * @param user The user template containing search criteria.
     * @return The loaded and enriched user information.
     */
    public User load(final User user) {
        User u = user;
        for (final AuthenticationChain chain : chains) {
            u = chain.load(u);
        }
        return u;
    }

 * loader. That way, this class doesn't prevent the main class loader from getting garbage
 * collected, and this class can detect when the main class loader has been garbage collected and
 * stop itself.
 */
public class Finalizer implements Runnable {

  private static final Logger logger = Logger.getLogger(Finalizer.class.getName());

  /**

  private static long hashLength33To64(byte[] bytes, int offset, int length) {
    long z = load64(bytes, offset + 24);
    long a = load64(bytes, offset) + (length + load64(bytes, offset + length - 16)) * K0;
    long b = rotateRight(a + z, 52);
    long c = rotateRight(a, 37);
    a += load64(bytes, offset + 8);
    c += rotateRight(a, 7);
    a += load64(bytes, offset + 16);
    long vf = a + z;
    long vs = b + rotateRight(a, 31) + c;

   * {@link CacheLoader#load} calls to {@code loader}.
   */
  static <K, V> CacheLoader<K, V> bulkLoader(CacheLoader<K, V> loader) {
    checkNotNull(loader);
    return new CacheLoader<K, V>() {
      @Override
      public V load(K key) throws Exception {
        return loader.load(key);
      }

      @Override