import org.codehaus.plexus.personality.plexus.lifecycle.phase.Contextualizable;

/**
 * A conflict resolver factory that obtains instances from a plexus container.
 *
 * TODO you don't need the container in here with the active maps (jvz).
 * @since 3.0
 */
@Named
@Singleton
@Deprecated
public class DefaultConflictResolverFactory implements ConflictResolverFactory, Contextualizable {

import org.junit.jupiter.api.extension.ExtensionContext
import org.junit.rules.TestRule
import org.junit.runner.Description
import org.junit.runners.model.Statement

/**
 * A log handler that records which log messages were published so that a calling test can make
 * assertions about them.
 */
class TestLogHandler(
  private val logger: Logger,
) : TestRule, BeforeEachCallback, AfterEachCallback {

    return unsafeDelegateList(delegateList().subList(fromIndex, toIndex));
  }

  @Override
  public Object[] toArray() {
    // Note that ArrayList.toArray() doesn't work here because it returns E[]
    // instead of Object[].
    return delegateList().toArray(new Object[size()]);
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    return delegateList().equals(obj);
  }

@SuppressWarnings("serial") // uses writeReplace(), not default serialization
@ElementTypesAreNonnullByDefault
final class SingletonImmutableSet<E> extends ImmutableSet<E> {
  // We deliberately avoid caching the asList and hashCode here, to ensure that with
  // compressed oops, a SingletonImmutableSet packs all the way down to the optimal 16 bytes.

  final transient E element;

  SingletonImmutableSet(E element) {

            challenge.charset,
          )
        return request.newBuilder()
          .header(credentialHeader, credential)
          .build()
      }
    }

    return null // No challenges were satisfied!
  }

  @Throws(IOException::class)
  private fun Proxy.connectToInetAddress(
    url: HttpUrl,
    dns: Dns,
  ): InetAddress {
    return when (type()) {

 * default} methods. Specifically, it forwards calls only for methods that existed <a
 * href="https://docs.oracle.com/javase/7/docs/api/java/util/ListIterator.html">before {@code
 * default} methods were introduced</a>. For newer methods, like {@code forEachRemaining}, it
 * inherits their default implementations. When those implementations invoke methods, they invoke
 * methods on the {@code ForwardingListIterator}.
 *

 * default} methods. Specifically, it forwards calls only for methods that existed <a
 * href="https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ConcurrentMap.html">before
 * {@code default} methods were introduced</a>. For newer methods, like {@code forEach}, it inherits
 * their default implementations. When those implementations invoke methods, they invoke methods on
 * the {@code ForwardingConcurrentMap}.
 *

 * on TypeToken.where.) So, in the interest of failing fast and encouraging the user to switch to a
 * non-null bound if possible, let's require a non-null bound here.
 *
 * TODO(cpovirk): Elaborate on "wouldn't behave as users might expect."
 */
public abstract class TypeParameter<T> extends TypeCapture<T> {

  final TypeVariable<?> typeVariable;

  protected TypeParameter() {

            // The root locator can be used very early during the setup of Maven,
            // even before the arguments from the command line are parsed.  Any exception
            // that would happen here should cause the build to fail at a later stage
            // (when actually parsing the POM) and will lead to a better exception being
            // displayed to the user, so just bail out and return false.
        }

    @Test
    void testNoProblems() {
        ToolchainsBuildingException e = new ToolchainsBuildingException(Collections.<Problem>emptyList());
        assertEquals("0 problems were encountered while building the effective toolchains" + LS, e.getMessage());
    }

    @Test
    void testOneProblem() {
        ProblemCollector problemCollector = ProblemCollectorFactory.newInstance(null);