* 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);
 * }
 *

 * 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

   * {@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

     * </ol>
     * <p>
     * However, if both the class loader that loaded the target class and the class loader that loaded this class can be obtained,
     * and the class loader that loaded the target class is an ancestor of the class loader that loaded this class,
     * the class loader that loaded this class is returned.
     * </p>
     *

        return loadJsonResource(SettingsResourceLoader.class.getClassLoader(), resourcePath, substitutions);
    }

    /**
     * Loads a JSON resource file with the specified class loader.
     *
     * @param classLoader The class loader to use for loading the resource
     * @param resourcePath The path to the resource file
     * @param substitutions A map of placeholder patterns to replacement values

            settings = new String(is2.readAllBytes(), StandardCharsets.UTF_8);
        }

        assertNotNull("Mappings should be loaded", mappings);
        assertNotNull("Settings should be loaded", settings);
        assertTrue("Mappings should not be empty", mappings.length() > 0);
        assertTrue("Settings should not be empty", settings.length() > 0);
    }

    /**

        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