this.moduleRegistry = moduleRegistry;
    }

    @Override
    public ClassPath findClassPath(String name) {
        if (name.equals("GRADLE_RUNTIME")) {
            // Use everything reachable from the daemon implementation
            return moduleRegistry.getModule("gradle-daemon-server").getAllRequiredModulesClasspath();
        }
        if (name.equals("GRADLE_INSTALLATION_BEACON")) {

 * `::1` will reach the IPv6 server.
 *
 * By orchestrating two different servers with the same port but different IP addresses, we can
 * test what OkHttp does when both are reachable, or if only one is reachable.
 *
 * This test only runs on host machines that have both IPv4 and IPv6 addresses for localhost.
 */
@Timeout(30)
class FastFallbackTest {
  @RegisterExtension

        }
        InetEndpoint address = (InetEndpoint) destinationAddress;
        LOGGER.debug("Attempting to connect to {}.", address);

        // Try each address in turn. Not all of them are necessarily reachable (eg when socket option IPV6_V6ONLY
        // is on - the default for debian and others), so we will try each of them until we can connect
        List<InetAddress> candidateAddresses = address.getCandidates();

    public TypeInspector() {
        stopAt.add(List.class);
        stopAt.add(Set.class);
        stopAt.add(Collection.class);
        stopAt.add(Map.class);
    }

    /**
     * Returns all interfaces reachable from the given interface, including the interface itself.
     */
    public Set<Class<?>> getReachableTypes(Class<?> type) {
        Set<Class<?>> types = inspected.get(type);
        if (types == null) {

  let description = [{
    This is a variation of DecomposeResourceOps pass. It operates on a module and
    only decomposes ops within a device cluster (tf_device.cluster op) and any
    functions reachable from the cluster.
  }];

  let constructor = "TFDevice::CreateDecomposeResourceOpsInClusterPass()";

	// for external load-balancers which use nodes as a second hop (e.g. many cloud LBs which only
	// understand nodes). For services that use externalTrafficPolicy=Local, this may mean that
	// any backends on excluded nodes are not reachable by those external load-balancers.
	// Implementations of this exclusion may vary based on provider.
	LabelNodeExcludeBalancers = "node.kubernetes.io/exclude-from-external-load-balancers"

	for _, b := range f.Blocks {
		blocks[b.ID].b = b
		if dom[b.ID] == nil {
			continue // entry or unreachable
		}
		parent := dom[b.ID].ID
		blocks[b.ID].parent = parent
		blocks[b.ID].sibling = blocks[parent].firstChild
		blocks[parent].firstChild = b.ID
	}

	// Compute euler tour ordering.
	// Each reachable block will appear #children+1 times in the tour.
	tour := make([]ID, 0, f.NumBlocks()*2-1)
	type queueEntry struct {

        tree.getProjectIdForClass(25) == 1
        tree.getProjectIdForClass(38) == 2
        tree.getTransitiveChildClassIds(51) == [42, 46, 50, 12, 25, 38]
    }

    def "adds additional dependency to projects reachable through api dependency"() {
        //      (Project Level 0)                 (Project Level 1)      (Project Level 2)
        // Project0  Project4  Project8    Project3  Project7 Project11     Project 12

// this cannot be used by some of the internal GC structures. For example when
// the sweeper is placing an unmarked object on the free list it does not want the
// write barrier to be called since that could result in the object being reachable.
type mlink struct {
	_    sys.NotInHeap
	next *mlink
}

// Initialize f to allocate objects of the given size,
// using the allocator to obtain chunks of memory.

	R_INITORDER

	// R_WEAK marks the relocation as a weak reference.
	// A weak relocation does not make the symbol it refers to reachable,
	// and is only honored by the linker if the symbol is in some other way
	// reachable.
	R_WEAK = -1 << 15

	R_WEAKADDR    = R_WEAK | R_ADDR
	R_WEAKADDROFF = R_WEAK | R_ADDROFF
)