}
        return request;
    }

    @Override
    public void injectTransformedArtifacts(RepositorySystemSession repositorySession, MavenProject currentProject)
            throws IOException {
        for (PomArtifactTransformer transformer : transformers.values()) {
            transformer.injectTransformedArtifacts(repositorySession, currentProject);
        }
    }

            ReactorContext reactorContext,
            ProjectBuildList projectBuilds,
            List<TaskSegment> taskSegments,
            ReactorBuildStatus reactorBuildStatus)
            throws ExecutionException, InterruptedException;

    return super.toString() + "[status=SUCCESS, result=[" + value + "]]";
  }

  static final class ImmediateFailedFuture<V extends @Nullable Object> extends TrustedFuture<V> {
    ImmediateFailedFuture(Throwable thrown) {
      setException(thrown);
    }
  }

  static final class ImmediateCancelledFuture<V extends @Nullable Object> extends TrustedFuture<V> {
    static final @Nullable ImmediateCancelledFuture<Object> INSTANCE =

        return applicationVersion;
    }

    @Override
    public void initialize() throws InitializationException {
        String mavenVersion = rtInfo.getMavenVersion();

        if (mavenVersion == null || mavenVersion.isEmpty()) {
            throw new InitializationException("Unable to read Maven version from maven-core");
        }

      if (actualException instanceof InterruptedException) {
        return Outcome.INTERRUPT;
      } else {
        throw new AssertionError("unexpected exception", targetException);
      }
    } catch (IllegalAccessException e) {
      throw new AssertionError("unexpected exception", e);
    }
  }

  private void enterSatisfyGuardAndLeaveInCurrentThread() {
    monitor.enter();

    setDefault(EndpointPair.class, EndpointPair.ordered("A", "B"));
  }

  @Override
  public void testNulls() throws Exception {
    try {
      super.testNulls();
    } catch (AssertionError e) {
      assertWithMessage("Method did not throw null pointer OR element not in graph exception.")
          .that(e)
          .hasCauseThat()
          .hasMessageThat()

  val routes = mutableListOf<Route>()

  fun onlyResponse() = responses.single()

  fun onlyRoute() = routes.single()

  @Throws(IOException::class)
  override fun authenticate(
    route: Route?,
    response: Response,
  ): Request? {
    if (route == null) throw NullPointerException("route == null")
    responses += response
    routes += route
    if (!schemeMatches(response) || credential == null) return null

            throws ArtifactResolutionException, ArtifactNotFoundException {
        if (Artifact.RELEASE_VERSION.equals(artifact.getVersion())) {
            try {
                String version = resolveVersion(artifact, request);

                if (Artifact.RELEASE_VERSION.equals(version)) {

 *
 */
@PlexusTest
@Deprecated
class LegacyRepositorySystemTest {
    @Inject
    private LegacyRepositorySystem repositorySystem;

    @Test
    void testThatLocalRepositoryWithSpacesIsProperlyHandled() throws Exception {
        File basedir = new File("target/spacy path").getAbsoluteFile();
        ArtifactRepository repo = repositorySystem.createLocalRepository(basedir);
        assertEquals(basedir, new File(repo.getBasedir()));

        this.pluginVersionResolver = pluginVersionResolver;
    }

    public void resolveMissingPluginVersions(MavenProject project, MavenSession session)
            throws PluginVersionResolutionException {
        Map<String, String> versions = new HashMap<>(64);

        for (Plugin plugin : project.getBuildPlugins()) {
            if (plugin.getVersion() == null) {