*
 * @author koichik
 */
class JclLoggerAdapterFactory implements LoggerAdapterFactory {

    @Override
    public LoggerAdapter getLoggerAdapter(final Class<?> clazz) {
        return new JclLoggerAdapter(clazz);
    }

    @Override
    public void releaseAll() {
        LogFactory.releaseAll();
    }

     *
     * @param clazz
     *            クラス
     * @return コンバータ
     */
    protected Converter findDefaultConverter(final Class<?> clazz) {
        if (clazz == java.sql.Date.class) {
            return DEFAULT_DATE_CONVERTER;
        }
        if (clazz == Time.class) {
            return DEFAULT_TIME_CONVERTER;
        }
        if (java.util.Date.class.isAssignableFrom(clazz)) {

    }

    @Override
    public ClassLoader getLocalClassLoader() {
        return localClassLoader;
    }

    @Override
    public boolean defines(Class<?> clazz) {
        return localClassLoader.equals(clazz.getClassLoader());
    }

    @Override
    public void onReuse() {
        parent.onReuse();
        listener.childScopeCreated(parent.getId(), id, origin);

        normalizer.appendConfigurationToHasher(hasher)
        return hasher.hash()
    }

    private static byte[] bytesOf(Class<?> clazz) {
        String classFile = "/${clazz.getName().replaceAll('\\.', '/')}.class"
        return IOUtils.toByteArray(clazz.getResource(classFile).openStream())
    }

        Constructor[] constructors = NativeServices.getConstructors()

        expect:
        constructors.size() == 0
    }

    private static URL jar(Class clazz) {
        clazz.getProtectionDomain().getCodeSource().getLocation()
    }

        cast.apply(target);
    }

    @Override
    public void applyRules(@Nullable String pluginId, Class<?> clazz) {
        String message = String.format("Cannot apply model rules of plugin '%s' as the target '%s' is not model rule aware", clazz.getName(), target.toString());
        throw new UnsupportedOperationException(message);
    }

    @Override

                        interfaces.findAll { it.name.endsWith(suffix) }
                    }
                }

                void invokeMethods(Object object, Class<?> clazz) {
                    for (def method : clazz.methods) {
                        try {
                            if (method.parameterTypes.size() == 0) {
                                method.invoke(object)
                            }

        assertQueryBuilder("content", "아아", MatchPhraseQueryBuilder.class);
    }

    private void assertQueryBuilder(String field, String value, Class<?> clazz) {
        QueryBuilder queryBuilder = queryCommand.buildMatchPhraseQuery(field, value);
        assertEquals(clazz, queryBuilder.getClass());
    }

        classpath.addAll(DefaultClassPath.of(additionalClasspath).getAsURLs());

        Set<ClassLoader> uniqueClassloaders = new HashSet<>();
        for (Class<?> clazz : classes) {
            ClassLoader classLoader = clazz.getClassLoader();
            // System types come from the system classloader and their classloader is null.
            if (classLoader != null) {
                uniqueClassloaders.add(classLoader);

      // Force Finalizer to load from this class loader, not its parent.
      if (name.equals(Finalizer.class.getName())) {
        Class<?> clazz = findClass(name);
        if (resolve) {
          resolveClass(clazz);
        }
        return clazz;
      }

      return super.loadClass(name, resolve);
    }
  }

  public void testGetFinalizerUrl() {