public class CycleDetectedInPluginGraphException extends Exception {
    private final Plugin plugin;

    public CycleDetectedInPluginGraphException(Plugin plugin, CycleDetectedInComponentGraphException e) {
        super("A cycle was detected in the component graph of the plugin: " + plugin.getArtifactId());

        this.plugin = plugin;
    }

    public Plugin getPlugin() {
        return plugin;
    }

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.artifact.resolver;

import org.apache.maven.artifact.Artifact;

/**
 * Indicates a cycle in the dependency graph.
 *
 */
public class CyclicDependencyException extends ArtifactResolutionException {
    private Artifact artifact;

    public CyclicDependencyException(String message, Artifact artifact) {

  }

  public void testConcat_infiniteIterable() throws IOException {
    CharSource source = CharSource.wrap("abcd");
    Iterable<CharSource> cycle = Iterables.cycle(ImmutableList.of(source));
    CharSource concatenated = CharSource.concat(cycle);

    String expected = "abcdabcd";

    // read the first 8 chars manually, since there's no equivalent to ByteSource.slice

    // but also for <parent>, <build><plugin>, <reports>. We need multiple DAG's
    // since a DAG can only handle 1 type of relationship properly.
    // Use case:  This is detected as a cycle:
    // org.apache.maven:maven-plugin-api                -(PARENT)->
    // org.apache.maven:maven                           -(inherited REPORTING)->
    // org.apache.maven.plugins:maven-checkstyle-plugin -(DEPENDENCY)->

compatibility.

Starting with go1.19.txt, each API feature line must end in "#nnnnn"
giving the GitHub issue number of the proposal issue that accepted
the new API. This helps with our end-of-cycle audit of new APIs.
The same requirement applies to next/* (described below), which will
become a go1.XX.txt for XX >= 19.

The next/ directory contains the only files intended to be mutated.

      }
      // First, check whether var -> arg forms a cycle
      for (Type t = arg; t != null; t = mappings.get(TypeVariableKey.forLookup(t))) {
        if (var.equalsType(t)) {
          // cycle detected, remove the entire cycle from the mapping so that
          // each type variable resolves deterministically to itself.
          // Otherwise, an F -> T cycle will end up resolving both F and T

                        testClassesDirs += sharedArchTestClasses.filter { it.isDirectory }
                        classpath += sourceSets["main"].output.classesDirs
                        systemProperty("package.cycle.exclude.patterns", packageCyclesExtension.excludePatterns.get().joinToString(","))
                        extensions.findByType<DevelocityTestConfiguration>()?.apply {

      <version>${junit.version}</version>
    </dependency>
    <dependency>
      <!--
      Do not include Truth in non-test scope! Doing so creates a problematic dependency cycle.
      -->
      <groupId>com.google.truth</groupId>
      <artifactId>truth</artifactId>
      <version>${truth.version}</version>
      <scope>test</scope>
      <exclusions>
        <exclusion>

        }
        return classDoc
    }

    private gradlebuild.docs.dsl.docbook.model.ClassDoc loadClassDoc(String className) {
        if (currentlyBuilding.contains(className)) {
            throw new RuntimeException("Cycle building $className. Currently building $currentlyBuilding")
        }
        currentlyBuilding.addLast(className)
        try {
            ClassMetaData classMetaData = classMetaData.find(className)

    return (NavigableSet<E>) super.elementSet();
  }

  @LazyInit private transient @Nullable UnmodifiableSortedMultiset<E> descendingMultiset;

  // TODO(b/418181860): This method creates retain cycles in J2ObjC. In order to break the cycle,
  // there needs to be separate classes for primary and descending multiset, where the primary one
  // would hold {@code @LazyInit @RetainedWith @Nullable} reference to its descending multiset, and