import org.apache.maven.artifact.resolver.ArtifactResolutionException;

/**
 */
@Deprecated
public interface ArtifactTransformation {
    String ROLE = ArtifactTransformation.class.getName();

    /**
     * Take in an artifact and return the transformed artifact for locating in the remote repository. If no
     * transformation has occurred the original artifact is returned.
     *

            return false;
        }

        ActivationProperty property = activation.getProperty();

        if (property == null) {
            return false;
        }

        String name = property.getName();
        boolean reverseName = false;

        if (name != null && name.startsWith("!")) {
            reverseName = true;
            name = name.substring(1);
        }

import org.apache.maven.artifact.versioning.VersionRange;

/**
 * Listens to the resolution process and handles events.
 *
 */
@Deprecated
public interface ResolutionListener {
    String ROLE = ResolutionListener.class.getName();

    int TEST_ARTIFACT = 1;

    int PROCESS_CHILDREN = 2;

    int FINISH_PROCESSING_CHILDREN = 3;

    int INCLUDE_ARTIFACT = 4;

    int OMIT_FOR_NEARER = 5;

    int UPDATE_SCOPE = 6;

 * assertions about them.
 */
class TestLogHandler(
  private val logger: Logger,
) : TestRule, BeforeEachCallback, AfterEachCallback {
  constructor(loggerName: Class<*>) : this(Logger.getLogger(loggerName.getName()))

  private val logs = LinkedBlockingQueue<String>()

  private val handler =
    object : Handler() {
      override fun publish(logRecord: LogRecord) {
        logs += "${logRecord.level}: ${logRecord.message}"

    stack.runTearDown();
  }

  static final Exception EXCEPTION = new Exception();

  static class ExampleClassUnderTest {
    static final Logger logger = Logger.getLogger(ExampleClassUnderTest.class.getName());

    static void foo() {
      logger.log(Level.INFO, "message", EXCEPTION);
    }
  }

            scm.setDeveloperConnection(normalize(scm.getDeveloperConnection()));
        }

        DistributionManagement dist = model.getDistributionManagement();
        if (dist != null) {
            Site site = dist.getSite();
            if (site != null) {
                site.setUrl(normalize(site.getUrl()));
            }
        }
    }

    private String normalize(String url) {
        return urlNormalizer.normalize(url);

  @SuppressWarnings("deprecation")
  @Override
  public void tearDown() throws Exception {
    stop();
    join();

    if (uncaughtThrowable != null) {
      throw new AssertionError("Uncaught throwable in " + getName(), uncaughtThrowable);
    }
  }

  /**
   * Causes this thread to call the named void method, and asserts that the call returns normally.
   */

            }

            if (logger.isDebugEnabled()) {
                logger.debug("principal={}", principal);
            }

            final String[] username = principal.getName().split("@", 2);
            if (logger.isDebugEnabled()) {
                logger.debug("username: {}", Arrays.toString(username));
            }
            return new SpnegoCredential(username[0]);

        return convertEmptyToNull(generator);
    }

    public void setGenerator(String value) {
        registerModifiedProperty("generator");
        this.generator = value;
    }

    public String getPath() {
        checkSpecifiedProperty("path");
        return convertEmptyToNull(path);
    }

    public void setPath(String value) {
        registerModifiedProperty("path");
        this.path = value;

 *
 * @author Kevin Bourrillion
 * @author Chris Povirk
 */
final class InterruptionUtil {
  private static final Logger logger = Logger.getLogger(InterruptionUtil.class.getName());

  /** Runnable which will interrupt the target thread repeatedly when run. */
  private static final class Interruptenator implements Runnable {
    private final long everyMillis;
    private final Thread interruptee;