*
     * @param localRepository  the local repository
     * @param remoteRepository the remote repository it came from
     * @throws RepositoryMetadataStoreException in case of issue
     */
    void storeInLocalRepository(ArtifactRepository localRepository, ArtifactRepository remoteRepository)
            throws RepositoryMetadataStoreException;

    String extendedToString();

    }

    public void beforeMojoExecution(MojoExecutionEvent event) throws MojoExecutionException {
        for (WeakMojoExecutionListener provided : getProvidedListeners()) {
            provided.beforeMojoExecution(event);
        }
    }

    public void afterMojoExecutionSuccess(MojoExecutionEvent event) throws MojoExecutionException {
        for (WeakMojoExecutionListener provided : getProvidedListeners()) {

  protected ForwardingLoadingCache() {}

  @Override
  protected abstract LoadingCache<K, V> delegate();

  @CanIgnoreReturnValue // TODO(b/27479612): consider removing this
  @Override
  public V get(K key) throws ExecutionException {
    return delegate().get(key);
  }

  @CanIgnoreReturnValue // TODO(b/27479612): consider removing this
  @Override
  public V getUnchecked(K key) {
    return delegate().getUnchecked(key);

import okio.BufferedSource
import okio.ForwardingSource
import okio.buffer

/** Rewrites the response body returned from the server to be all uppercase.  */
class UppercaseResponseInterceptor : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Chain): Response {
    return uppercaseResponse(chain.proceed(chain.request()))
  }

  private fun uppercaseResponse(response: Response): Response {

     * @return The result of the toolchains building, never {@code null}.
     * @throws ToolchainsBuildingException If the effective toolchains could not be built.
     */
    ToolchainsBuildingResult build(ToolchainsBuildingRequest request) throws ToolchainsBuildingException;

   * Double#NEGATIVE_INFINITY} only, the result is {@link Double#NEGATIVE_INFINITY}.
   *
   * <p>If you only want to calculate the mean, use {@link #meanOf} instead of creating a {@link
   * Stats} instance.
   *
   * @throws IllegalStateException if the dataset is empty
   */
  public double mean() {
    checkState(count != 0);
    return mean;
  }

  /**
   * Returns the sum of the values.
   *

import java.net.URLStreamHandler;

public class Handler extends URLStreamHandler {

    public static final String PROTOCOL_TYPE = "test";

    @Override
    protected URLConnection openConnection(URL u) throws IOException {
        return null;
    }

package org.apache.maven.artifact.resolver;

/**
 */
@Deprecated
public interface ResolutionErrorHandler {

    void throwErrors(ArtifactResolutionRequest request, ArtifactResolutionResult result)
            throws ArtifactResolutionException;

 */
package org.apache.maven.cli.configuration;

import org.apache.maven.cli.CliRequest;

/**
 * ConfigurationProcessor
 */
public interface ConfigurationProcessor {
    void process(CliRequest request) throws Exception;

 */
package org.codelibs.fess.suggest.converter;

import junit.framework.TestCase;

public class ReadingConverterChainTest extends TestCase {
    public void test_convert() throws Exception {
        /*
         * TODO ReadingConverterChain chain = new ReadingConverterChain(); chain.addConverter(new KatakanaConverter());
         * chain.addConverter(new KatakanaToAlphabetConverter()); chain.init();