import org.elasticsearch.gradle.internal.precommit.DependencyLicensesTask;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.plugins.JavaPlugin;

public class DependenciesInfoPlugin implements Plugin<Project> {
    @Override
    public void apply(final Project project) {
        project.getPlugins().apply(CompileOnlyResolvePlugin.class);

/**
 * Ideally, this plugin is intended to be temporary and in the long run we want to move
 * forward to port our test fixtures to use the gradle test fixtures plugin.
 * */
public class InternalTestArtifactPlugin implements Plugin<Project> {

    @Override
    public void apply(Project project) {
        project.getPlugins().apply(InternalTestArtifactBasePlugin.class);

package org.codelibs.fess.app.web.base.login;

import org.lastaflute.web.login.credential.UserPasswordCredential;

/**
 * The credential for a local user.
 */
public class LocalUserCredential extends UserPasswordCredential implements FessCredential {
    /**
     * Creates a new LocalUserCredential with the specified user and password.
     *
     * @param user the username
     * @param password the password
     */

 * limitations under the License.
 */
package gradlebuild.docs.dsl.docbook;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.LinkedList;

public class DefaultGenerationListener implements GenerationListener {
    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultGenerationListener.class);
    private final LinkedList<String> contextStack = new LinkedList<String>();

    @Override

import org.codelibs.core.exception.ClUnsupportedOperationException;

/**
 * An empty {@link Iterator}.
 *
 * @author higa
 * @param <T> the element type
 */
public class EmptyIterator<T> implements Iterator<T> {

    /**
     * Creates an {@link EmptyIterator}.
     */
    public EmptyIterator() {
    }

    @Override
    public void remove() {

 */
package org.apache.maven.profiles.activation;

import org.apache.maven.model.Profile;

/**
 * DetectedProfileActivator
 */
@Deprecated
public abstract class DetectedProfileActivator implements ProfileActivator {
    @Override
    public boolean canDetermineActivation(Profile profile) {
        return canDetectActivation(profile);
    }

    protected abstract boolean canDetectActivation(Profile profile);

import org.lastaflute.core.json.JsonMappingOption;
import org.lastaflute.core.json.JsonMappingOption.JsonFieldNaming;
import org.lastaflute.core.json.JsonResourceProvider;

public class FessJsonResourceProvider implements JsonResourceProvider {
    @Override
    public boolean isNullsSuppressed() {
        return true;
    }

    @Override
    public boolean isPrettyPrintSuppressed() {
        return false;
    }

 */
package org.codelibs.fess.script;

import org.codelibs.fess.util.ComponentUtil;

/**
 * The abstract class for ScriptEngine.
 */
public abstract class AbstractScriptEngine implements ScriptEngine {

    /**
     * Default constructor.
     */
    public AbstractScriptEngine() {
        // nothing
    }

    /**
     * Register this script engine.
     */

 */
package org.codelibs.core.misc;

/**
 * Represents a disposable resource.
 * <p>
 * If there are resources that must be disposed of when the S2 container shuts down,
 * create a class that implements this interface and register it with {@link DisposableUtil}.
 * </p>
 *
 * @author koichik
 */
public interface Disposable {

    /**
     * Disposes of the resources held by this object.
     *
     */

 */

package org.elasticsearch.gradle.internal.util.ports;

import java.io.IOException;
import java.net.DatagramSocket;
import java.net.ServerSocket;

public class DefaultPortDetector implements PortDetector {
    /**
     * Checks to see if a specific port is available.
     *
     * @param port the port to check for availability
     * @return true if the port is available, false otherwise
     */