*/
fun computeExternalDependenciesNotAccessibleFromProjectDependencies(
    rootComponent: ResolvedComponentResult,
    rootVariant: ResolvedVariantResult
): Set<ComponentIdentifier> {
    val locallyAccessible = mutableSetOf<ComponentIdentifier>()
    val externallyAccessible = mutableSetOf<ComponentIdentifier>()

    val seen = mutableSetOf<ResolvedVariantResult>()

  /**
   * Performs a {@linkplain java.lang.invoke.VarHandle#compareAndSet compare-and-set} operation on
   * {@link #listenersField}.
   */
  final boolean casListeners(@Nullable Listener expect, Listener update) {
    return ATOMIC_HELPER.casListeners(this, expect, update);
  }

  /**
   * Performs a {@linkplain java.lang.invoke.VarHandle#getAndSet get-and-set} operation on {@link
   * #listenersField}.
   */

        }

        private Set<Artifact> createArtifacts(
                ArtifactFactory artifactFactory,
                Set<Artifact> dependencies,
                String inheritedScope,
                ArtifactFilter dependencyFilter)
                throws InvalidVersionSpecificationException {
            Set<Artifact> projectArtifacts = new HashSet<>();

  sufficient copyright rights in its Contribution, if any, to grant
  the copyright license set forth in this Agreement.

  e) Notwithstanding the terms of any Secondary License, no
  Contributor makes additional grants to any Recipient (other than
  those set forth in this Agreement) as a result of such Recipient's
  receipt of the Program under the terms of a Secondary License

    }

    @Test
    @DisplayName("Test hasMoreElements becomes false when all data is sent")
    void testHasMoreElementsBecomeFalse() {
        // Set small amounts so everything fits in one message
        transaction.setParameterBytesWritten(10);
        transaction.setDataBytesWritten(10);

        // First call processes all data
        transaction.nextElement();

            }
        }
    }

    private static String getExecutionId(Plugin plugin, String goal) {
        Set<String> existingIds = plugin != null
                ? plugin.getExecutions().stream().map(PluginExecution::getId).collect(Collectors.toSet())
                : Set.of();
        String base = "default-" + goal;
        String id = base;
        for (int index = 1; existingIds.contains(id); index++) {

      Iterable<Cell<R, C, V>> cells,
      @Nullable Comparator<? super R> rowComparator,
      @Nullable Comparator<? super C> columnComparator) {
    Set<R> rowSpaceBuilder = new LinkedHashSet<>();
    Set<C> columnSpaceBuilder = new LinkedHashSet<>();
    ImmutableList<Cell<R, C, V>> cellList = ImmutableList.copyOf(cells);
    for (Cell<R, C, V> cell : cells) {
      rowSpaceBuilder.add(cell.getRowKey());

import java.util.Collection;
import java.util.Comparator;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import org.jspecify.annotations.Nullable;

/**
 * A {@code SetMultimap} whose set of values for a given key are kept sorted; that is, they comprise

 */
package org.apache.maven.repository.metadata;

import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.factory.ArtifactFactory;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.versioning.ArtifactVersion;

    });

    System.out.printf("open this URL in a browser: %s\n", authorizeUrl);
  }

  /** Set the OAuth session for this client. */
  public synchronized void initOauthSession(OAuthSession session) {
    this.session = session;
    this.notifyAll();
  }

  /** Waits for an OAuth session for this client to be set. */
  public synchronized void awaitAccessToken(Timeout timeout) throws InterruptedIOException {