<modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>cyclic-reference</groupId>
    <artifactId>parent</artifactId>
    <version>1.0-SNAPSHOT</version>
  </parent>
  <artifactId>module-a</artifactId>

  <dependencies>
    <dependency>
      <groupId>cyclic-reference</groupId>
      <artifactId>module-b</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>

  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>cyclic-reference</groupId>
    <artifactId>parent</artifactId>
    <version>1.0-SNAPSHOT</version>
  </parent>
  <artifactId>module-b</artifactId>

  <dependencies>
    <dependency>
      <groupId>cyclic-reference</groupId>
      <artifactId>module-a</artifactId>
      <version>1.0-SNAPSHOT</version>
    </dependency>

        types2.is(types)
    }

    def "inspects cyclic types"() {
        expect:
        def types = inspector.getReachableTypes(Parent)
        types == [Parent, Child] as Set

        def types2 = inspector.getReachableTypes(Child)
        types2 == types
    }

    def "inspects cyclic generic types"() {
        expect:
        def types = inspector.getReachableTypes(GenericChild)

  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>cyclic-reference</groupId>
  <artifactId>parent</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>

  <modules>
    <module>module-a</module>
    <module>module-b</module>
  </modules>

// compiledir

// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 5125: cyclic dependencies between types confuse
// the hashability test during import.

 * limitations under the License.
 */

package org.gradle.test.fixtures.server.http;

import java.time.Duration;
import java.util.Collection;
import java.util.concurrent.locks.Lock;

/**
 * A cyclic barrier for {@link BlockingHttpServer} where expectations are optional.
 */
class MaybeNConcurrentRequests extends ExpectMaxNConcurrentRequests {

	// For any possible reference cycle that might be encountered,
	// hard(v1, v2) needs to return true for at least one of the types in the cycle,
	// and it's safe and valid to get Value's internal pointer.
	hard := func(v1, v2 Value) bool {
		switch v1.Kind() {
		case Pointer:
			if !v1.typ().Pointers() {
				// not-in-heap pointers can't be cyclic.

// Test that buffered channels are garbage collected properly.
// An interesting case because they have finalizers and used to
// have self loops that kept them from being collected.
// (Cyclic data with finalizers is never finalized, nor collected.)

package main

import (
	"fmt"
	"os"
	"runtime"
)

func main() {
	const N = 10000
	st := new(runtime.MemStats)

 * under the License.
 */
package org.apache.maven.di.impl;

import org.apache.maven.di.Injector;

/**
 * A runtime exception that is thrown on startup when some static conditions fail
 * (missing or cyclic dependencies, incorrect annotations etc.) or in runtime when
 * you ask an {@link Injector} for an instance it does not have a {@link Binding binding} for.
 */
public final class DIException extends RuntimeException {

 *
 * When caching a service inside another service, the property should also be [lazy] to avoid issues with cyclic service initialization and
 * excessive class loading on startup.
 *
 * The [KaCachedService] annotation itself is currently not enforced by any checkers or inspections, but it serves as an anchor for