<function-class>org.codelibs.fess.taglib.FessFunctions</function-class>
    <function-signature>boolean fileExists(java.lang.String)</function-signature>
    <example>
      ${fe:fileExists(path)}
    </example>
  </function>

  <function>
    <description>Calculates URL.</description>
    <name>url</name>
    <function-class>org.codelibs.fess.taglib.FessFunctions</function-class>

        }
    }

    private static class LookupClassDefiner extends AbstractClassLoaderLookuper implements ClassDefiner {
        private MethodType defineClassMethodType = MethodType.methodType(Class.class, new Class<?>[]{String.class, byte[].class, int.class, int.class});

        @Override
        @SuppressWarnings("unchecked")

    }

    def "change to #retention retention annotation class recompiles #desc"() {
        def annotationClass = file("src/main/${language.name}/SomeAnnotation.${language.name}") << """
            import java.lang.annotation.*;

            @Retention(RetentionPolicy.$retention)
            public @interface SomeAnnotation {}
        """
        source "@SomeAnnotation class A {}", "class B {}"

						<span class="navbar-toggler-icon"></span>
					</button>
					<div class="collapse navbar-collapse" id="navbar">
						<div class="mr-auto"></div>
						<ul class="nav navbar-nav">
							<c:if test="${eoled}">
								<li class="nav-item" data-toggle="tooltip" data-placement="left" title="<la:message key="labels.eol_error" />">

public synchronized class ComponentRepositoryE extends Exception { private static final long serialVersionUID = 3698017788731736736; public void ComponentRepositoryE(String); public void ComponentRepositoryE(String, Throwable); } org/codehaus/plexus/ComponentLookupManag$1.class package org.codehaus.plexus; synchronized class ComponentLookupManag$1 { } org/codehaus/plexus/ComponentLookupManag.class package org.codehaus.plexus; public abstract interface ComponentLookupManag { public static final String...

 * Default implementation of {@link SerializerRegistry}.
 *
 * This class must be thread-safe because multiple tasks may be registering serializable classes concurrently, while other tasks are calling {@link #build(Class)}.
 */
@ThreadSafe
public class DefaultSerializerRegistry implements SerializerRegistry {
    private static final Comparator<Class<?>> CLASS_COMPARATOR = new Comparator<Class<?>>() {
        @Override

            taskAssertion("cabin", Copy::class),
            taskAssertion("castle", Task::class, equalTo("null!")),
            taskAssertion("valley", Copy::class, equalTo("null!")),
            taskAssertion("hill", Copy::class, equalTo("null!")),
            taskAssertion("bat"),
            taskAssertion("pipistrelle", Copy::class, equalTo("nullABC")),
            taskAssertion("yate"),
            taskAssertion("quartern", Copy::class),

makeReadOnly(); } org/codehaus/plexus/context/ContextException.class package org.codehaus.plexus.context; public synchronized class ContextException extends Exception { private static final long serialVersionUID = 2030206863811644180; public void ContextException(String); public void ContextException(String, Throwable); } org/codehaus/plexus/logging/AbstractLogEnabled.class package org.codehaus.plexus.logging; public abstract synchronized class AbstractLogEnabled implements LogEnabled { private Logger...

import static org.gradle.test.precondition.TestPrecondition.notSatisfied;

class IntegTestPreconditions {

    static final class IsLongLivingProcess implements TestPrecondition {
        @Override
        boolean isSatisfied() throws Exception {
            return GradleContextualExecuter.isLongLivingProcess()
        }
    }

    static final class IsEmbeddedExecutor implements TestPrecondition {
        @Override

import java.util.Queue;
import java.util.concurrent.atomic.AtomicReference;

public class IsolationScheme<IMPLEMENTATION, PARAMS> {
    private final Class<IMPLEMENTATION> interfaceType;
    private final Class<PARAMS> paramsType;
    private final Class<? extends PARAMS> noParamsType;

    public IsolationScheme(Class<IMPLEMENTATION> interfaceType, Class<PARAMS> paramsType, Class<? extends PARAMS> noParamsType) {
        this.interfaceType = interfaceType;