* declaration that has the most transitive steps away from the project being built.
 *
 * @since 3.0
 */
@Named("farthest")
@Singleton
@Deprecated
public class FarthestConflictResolver implements ConflictResolver {
    // ConflictResolver methods -----------------------------------------------

    /*

import org.codehaus.plexus.interpolation.InterpolationPostProcessor;
import org.codehaus.plexus.interpolation.util.ValueSourceUtils;

/**
 *
 */
@Deprecated
public class PathTranslatingPostProcessor implements InterpolationPostProcessor {

    private final List<String> unprefixedPathKeys;
    private final File projectDir;
    private final PathTranslator pathTranslator;
    private final List<String> expressionPrefixes;

import java.util.ArrayList;
import java.util.List;

import org.jline.console.CommandRegistry;

import static java.util.Objects.requireNonNull;

public class ShellCommandRegistryHolder implements AutoCloseable {
    private final List<CommandRegistry> commandRegistries;

    public ShellCommandRegistryHolder() {
        this.commandRegistries = new ArrayList<>();
    }

import org.apache.maven.execution.ProjectExecutionEvent;
import org.apache.maven.execution.ProjectExecutionListener;
import org.apache.maven.lifecycle.LifecycleExecutionException;

public class CompoundProjectExecutionListener implements ProjectExecutionListener {
    private final Collection<ProjectExecutionListener> listeners;

    public CompoundProjectExecutionListener(Collection<ProjectExecutionListener> listeners) {

 */
@GwtCompatible
@J2ktIncompatible
@SuppressWarnings("EnumOrdinal") // This is one of the low-level utilities where it's suitable.
public final class EnumMultiset<E extends Enum<E>> extends AbstractMultiset<E>
    implements Serializable {
  /** Creates an empty {@code EnumMultiset}. */
  public static <E extends Enum<E>> EnumMultiset<E> create(Class<E> type) {
    return new EnumMultiset<>(type);
  }

  /**

import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class ErrorReportingTestListener implements TestOutputListener, TestListener {
    private static final String REPRODUCE_WITH_PREFIX = "REPRODUCE WITH";

    private final TestExceptionFormatter formatter;
    private final File outputDirectory;

        .url("https://publicobject.com/helloworld.txt")
        .build();

    Response response = client.newCall(request).execute();
    response.body().close();
  }

  private static class LoggingInterceptor implements Interceptor {
    @Override public Response intercept(Chain chain) throws IOException {
      long t1 = System.nanoTime();
      Request request = chain.request();
      logger.info(String.format("Sending request %s on %s%n%s",

 *
 * @since 3.3.0
 * @deprecated since 4.0.0, use {@code org.apache.maven.api.services.ToolchainsBuilder} instead
 */
@Deprecated(since = "4.0.0")
public class DefaultToolchainsBuildingResult implements ToolchainsBuildingResult {

    private PersistedToolchains effectiveToolchains;

    private List<Problem> problems;

    /**
     * Default constructor
     *

import org.lastaflute.db.dbflute.exception.ProvidedClassificationNotFoundException;

/**
 * The provider of listed classification.
 *
 * @author jflute
 */
public class FessListedClassificationProvider implements ListedClassificationProvider {

    @Override
    public ClassificationMeta provide(final String classificationName) throws ProvidedClassificationNotFoundException {

      System.out.println(response.body().string());
    }
  }

  public static void main(String... args) throws Exception {
    new PreemptiveAuth().run();
  }

  static final class BasicAuthInterceptor implements Interceptor {
    private final String credentials;
    private final String host;

    BasicAuthInterceptor(String host, String username, String password) {
      this.credentials = Credentials.basic(username, password);