<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.

	// 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.

 * 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 {

// 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 {

    self.parent = parent
    # CHECK: tf_saved_model.global_tensor
    # CHECK-SAME: tf_saved_model.exported_names = ["child.my_variable"]
    self.my_variable = tf.Variable(3.)


# Creates a cyclic object graph.
class TestModule(tf.Module):

  def __init__(self):
    super(TestModule, self).__init__()
    self.child = ReferencesParent(self)


if __name__ == '__main__':